BOTTOM VIEW

Simple Solar Beam Bot

2011-10-17T17:31:00.006-03:00

Para la creacion de este sencillo robot solar se utilizaron los siguientes materiales:

celda solar 4.5 v , 90 mA
diodo in4007
2 super condensadores 4.7 faradios
motor dc

El circuito se muestra acontinuacion:

y el diseño queda a la imaginacion de cada cual, aqui presento el mio.

Mood Lamp

2011-10-06T20:42:00.000-03:00

Para la creación de esta lampara se utilizaron cuatro leds RGB cátodo común por medio de una resistencia de 100 ohms, la descripción de los pines es como la indica el programa, a continuación:

#include <16f84A.h>

#fuses XT,NOWDT,NOPROTECT

#use delay(clock=20000000)

#define periodo 125 //125 * 80microS =~10mS

#define duty 125 //parte del periodo que encenderan las lamparas

#define Tiempo_int 30 //50 * 125 * 80microS =~500mS entre cambio y cambio de intensidad

int c1=0; //rojo

int c2=0; //azul

int c3=0; //verde

int i2; //variable control de ciclo de retardo en intensidades

int i; //variable que controla el ciclo del periodo del pwm

int d = 0; //control porta

int z = 0; //control portb

/////////////////////////////////////////////////////////////////////////
void tiempo()

{

delay_ms(4000);

}

//led1_portb_0

void ciclo_PWM_10mS(){

for (i=1;i
{
if (i<=c1) //control intensidad rojo
{
bit_set(z,0); //led1_portb_0
bit_set(z,3); //led2_portb_3
bit_set(z,6); //led3_portb_6
bit_set(d,0); //led4_porta_0
}
else
{
bit_clear(z,0); //led1_portb_0
bit_clear(z,3); //led2_portb_3
bit_clear(z,6); //led3_portb_6
bit_clear(d,0); //led4_porta_0
}
if (i<=c2) //control intensidad azul
{
bit_set(z,1); //led1_portb_1
bit_set(z,4); //led2_portb_4
bit_set(z,7); //led3_portb_7
bit_set(d,2); //led4_porta_2
}
else
{
bit_clear(z,1); //led1_portb_1
bit_clear(z,4); //led2_portb_4
bit_clear(z,7); //led3_portb_7
bit_clear(d,2); //led4_porta_2
}
if (i<=c3)
{
bit_set(z,2); //led1_portb_2
bit_set(z,5); //led2_portb_5
bit_set(d,1); //led3_porta_1
bit_set(d,3); //led4_porta_3
}
else
{
bit_clear(z,2); //led1_portb_2
bit_clear(z,5); //led2_portb_5
bit_clear(d,1); //led3_porta_1
bit_clear(d,3); //led4_porta_3
}
output_b(z);
output_a(d);
}
delay_us(40);
}
/////////////////////////////////////////////////////////////////////////////////
void tonos_mas(){
for (c1=1,c2=1,c3=0; c1
{
for (i2=1; i2
ciclo_PWM_10mS() ;
}
}
void tonos_2_mas(){
for (c3=1,c1=1,c2=0; c3
{
for (i2=1; i2
ciclo_PWM_10mS() ;
}
}
void tonos_3_mas(){
for (c3=1,c1=0,c2=1; c3
{
for (i2=1; i2
ciclo_PWM_10mS() ;
}
}
void tonos_menos(){
for (c1=duty,c2=duty,c3=0; c1>1 ; c1--,c2--) //;control de tono magenta
{
for (i2=1; i2
ciclo_PWM_10mS() ;
}
}
void tonos_2_menos(){
for (c1=duty,c2=0,c3=duty; c1>1 ; c1--,c3--) //;control de tono amarillo
{
for (i2=1; i2
ciclo_PWM_10mS() ;
}
}
void tonos_3_menos(){
for (c3=duty,c1=0,c2=duty; c3>1; c3--,c2--) //;control de tono cyan
{
for (i2=1; i2
ciclo_PWM_10mS() ;
}
}
void negro() //color negro
{
z=0;
d=0;
output_b(z);
output_a(d);
tiempo();
}
void blanco() //color blanco
{
z=d=255;
output_b(z);
output_a(d);
tiempo();
z=d=0;
output_b(z);
output_a(d);
}
void rojo() //color rojo
{
output_b(0x49);
output_a(0x01);
tiempo();
z=d=0;
output_b(z);
output_a(d);
}
void verde() //color verde
{
output_b(0x24);
output_a(0x0a);
tiempo();
z=d=0;
output_b(z);
output_a(d);
}
void azul() //color azul
{
output_b(0x92);
output_a(0x04); tiempo();
z=d=0;
output_b(z);
output_a(d);
}
void amarillo() //color amarillo
{
output_b(0x6d);
output_a(0x0b);
tiempo();
z=d=0;
output_b(z);
output_a(d);
}
void cyan() //color cyan
{
output_b(0xb6);
output_a(0x0e);
tiempo();
z=d=0;
output_b(z);
output_a(d);
}
void magenta() //color magenta
{
output_b(0xdb);
output_a(0x05);
tiempo();
z=d=0;
output_b(z);
output_a(d);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
int main ()
{ //salida al puerto b=0
while (true)
{
// negro(); //(0, 0, 0) es negro
blanco(); //(255, 255, 255) es blanco
rojo(); //(255, 0, 0) es rojo
tonos_mas();
tonos_menos();
verde(); //(0, 255, 0) es verde
tonos_2_mas();
tonos_2_menos();
azul();
tonos_3_mas();
tonos_3_menos();
amarillo(); //(255, 255, 0) es amarillo
cyan(); //(0, 255, 255) es cyan
magenta(); //(255, 0, 255) es magenta
z=d=0;
output_b(z);
output_a(d);
}
return(0);
}

Propeller Clock

2010-01-03T13:58:00.005-03:00

para la realizacion de este reloj se utilizo un motor de grabadora el cual se polariza con 9[v], un Pic 16F84A, una bateria de 3,6 [v], un sensor infrarojo y un emisor infrarojo que se utiliza para producir una entrada alta en el Pin_A2, el circuito es el comun utilizado para el Pic 16F84A.

el codigo del programa utilizando ccs, es el siguiente:

#include <16f84a.h>
#FUSES NOWDT //No Watch Dog Timer
#FUSES XT //para cristal de 4MHz
#FUSES PUT //power up timer habilitado
#fuses XT,NOWDT,NOPROTECT,NOPUT // Configuracion
//lectura habilitada del codigo del pic
#use delay(clock=4000000)
#int_rtcc // Rutina que atiende interrupcion

#use fast_io(A)
#use fast_io(B)

int ss=0;
int i=1;
int s=0;
int m=0;
int mm=0;
int h=11;

char contador;
#int_rtcc // Rutina que atiende interrupcion

void interrupt(void)
{
contador++; // Incrementa la variable que cuenta las
set_rtcc(0x06); // interrupciones y recarga el timer
if(contador==250)
{
contador=0;
s++;
}

}

void cero (void){

OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B3);
delay_us(100);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B1);
delay_us(1800);
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);
}

void uno (void) {; //uno

OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B0);
delay_us(100);
OUTPUT_LOW(PIN_B0);
delay_us(900);
OUTPUT_HIGH(PIN_B0); // este está 2 veces....
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B1);

OUTPUT_HIGH(PIN_B3);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
delay_ms(1);
OUTPUT_LOW(PIN_B2);
}

void dos (void){
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B3);
delay_us(100);
OUTPUT_LOW(PIN_B3);
delay_us(1800);
OUTPUT_HIGH(PIN_B0); // este está 2 veces....
delay_us(100);

OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);
}

void tres (void){OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B1);
delay_us(100);

delay_us(1800);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
delay_us(100);

OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);
}

void cuatro (void){
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B1);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
delay_us(1800);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B2);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);}

void cinco(void){OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B0);
delay_us(100);
OUTPUT_LOW(PIN_B0);
delay_us(1800);
OUTPUT_HIGH(PIN_B3); // este está 2 veces....
delay_us(100);

OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);
}

void seis (void){
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
delay_us(100);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B3);
delay_us(1800);
OUTPUT_HIGH(PIN_B3); // este está 2 veces....
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);}

void siete (void){
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
delay_us(100);
OUTPUT_LOW(PIN_B0);
delay_us(1800);
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);}

void ocho (void){
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
OUTPUT_HIGH(PIN_B3);
delay_us(100);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B3);
delay_us(1800);
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);}

void nueve (void){
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
delay_us(100);
OUTPUT_LOW(PIN_B0);
delay_us(1800);
OUTPUT_HIGH(PIN_A3);
OUTPUT_HIGH(PIN_B0);
OUTPUT_HIGH(PIN_B3);
OUTPUT_HIGH(PIN_B1);
OUTPUT_HIGH(PIN_B2);
delay_us(100);
OUTPUT_LOW(PIN_A3);
OUTPUT_LOW(PIN_B0);
OUTPUT_LOW(PIN_B1);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B2);}

void dospuntos (void){

delay_ms(3);

OUTPUT_HIGH(PIN_B3);
OUTPUT_HIGH(PIN_B0);
delay_us(100);
OUTPUT_LOW(PIN_B3);
OUTPUT_LOW(PIN_B0);
delay_ms(3);
}

void segundos (void){
if (ss==0) cero();
if (ss==1) uno();
if (ss==2) dos();
if (ss==3) tres();
if(ss==4) cuatro();
if (ss==5) cinco();
delay_ms(2);
if (s==0) cero();
if (s==1) uno();
if (s==2) dos();
if (s==3) tres();
if(s==4) cuatro();
if (s==5) cinco();
if (s==6) seis();
if (s==7) siete();
if (s==8) ocho();
if (s==9) nueve();}

void minutos(void){
if (mm==0) cero();
if (mm==1) uno();
if (mm==2) dos();
if (mm==3) tres();
if(mm==4) cuatro();
if (mm==5) cinco();
delay_ms(2);
if (m==0) cero();
if (m==1) uno();
if (m==2) dos();
if (m==3) tres();
if(m==4) cuatro();
if (m==5) cinco();
if (m==6) seis();
if (m==7) siete();
if (m==8) ocho();
if (m==9) nueve();}

void horas (void){
if (h==0) cero();
if (h==1) uno();
if (h==2) dos();
if (h==3) tres();
if(h==4) cuatro();
if (h==5) cinco();
if (h==6) seis();
if (h==7) siete();
if (h==8) ocho();
if (h==9) nueve();
if (h==10){uno();delay_ms(2);cero();}
if (h==11){uno();delay_ms(2);uno();}
if (h==12){uno();delay_ms(2);dos();}}

void main()

{
setup_counters (RTCC_INTERNAL, RTCC_DIV_16); // Programacion timer0
set_timer0(0x06); // Carga el valor del timer0
enable_interrupts(INT_RTCC); // Habilita interrupcion timer0.
enable_interrupts(GLOBAL); // Habilita todas las interrupciones.

SET_TRIS_a(0x02);
//todo el puerto A como salida
OUTPUT_a(0x00);
//limpiamos los pines del puerto A
set_tris_b(0x00);
output_b(0x00);

do
{

output_high(PIN_A2);

IF (INPUT(PIN_A1)==1)
{
horas();
dospuntos();
minutos();
dospuntos();
segundos();

}
if (s>9) {ss++;i++;s=0;}
if (ss>5){m++;i=0;ss=0;}
if (m>9) {mm++;m=0;}
if (mm>5){h++;mm=0;}

}
while(1);
}

cabe mencionar que todavia no se crea aqui un sistema para la puesta a la hora, y la posicion de los numeros simplemente se modifica variando la posicion del sensor.

Conversor Voltaje a Corriente

2008-05-12T16:05:00.000-04:00

Una de las aplicaciones que tienen los amplificadores operacionales son los conversores de voltaje a corriente , es decir un voltaje de entrada puede utilizarse para controlar una corriente de salida. estos circuitos son muy utilizados en diversos circuitos de instrumentacion.
El circuito de la figura cuenta con dos buffer o seguidores de emisor la corriente de salida IL es igual a R2/(R1*R3)*Vi, si R1=R2=R3=R entonces simplemente IL=Vi/R. las ecuaciones del analisis del circuito se indican en la figura.

Comparador con Histeresis ( schmitt trigger)

2008-05-01T13:06:00.002-04:00

El amplificador operacional de la figura se encuentra polarizado entre mas Vcc y -Vcc, para comenzar el analisis del circuito supondremos que V0=- Vcc y que Vg comienza a aumentar, se sabe que un amplificador operacional en saturacion si su voltaje Vi es menor que cero entonces V0 se satura negativamente es decir Vo=-Vcc y si su voltaje Vi es mayor a cero entonces su voltaje de salida V0 se satura positivamente Vo=Vcc, en el circuito de la figura el voltaje Vi se puede obtener haciendo el siguiente LVK: Vi=Vx-Vref, para determinar el voltaje Vx nos ayudaremos del circuito que se muestra en la parte inferior de la figura, aplicando el teorema de superposicion obtenemos: Vx=R2/(R1+R2)*Vg-R1/(R1+ R2) Vcc entonces remplazando la ecuacion en Vi= Vx - Vref resulta : Vi=R2/(R1 + R2)*Vg-R1/(R1 + R2)* Vcc - Vref <0> R2/(R1+R2)*Vg - R1*Vcc/(R1+R2) - Vref=0 despejando: Vg= (R1+R2)Vref/R2 + R1*Vcc/R2= V2 como se puede ver en la grafica de la figura, V2 es el voltaje en donde la salida V0 conmuta de -Vcc a Vcc para la determinacion de V1 ahora Vo es igual a Vcc por lo que Vx queda de la siguiene manera: Vx= R2*Vg/(R1+R2) + R1* Vcc/(R1+ R2) entonces: Vg= (R1+ R2)Vref/R2 - R1*Vcc/R2=V1, que corresponde al voltaje en que Vo conmuta de Vcc a - Vcc. se le denomina ancho de histeresis a la distancia que existe entre V1 y V2 y corresponde al valor H=2*R1Vcc/R2

Circuito oscilador Puente de Wien

2007-10-25T16:36:00.000-03:00

El circuito genera una señal sinusoidal la que puede ser utilizada para elaborar una alarma audible en este caso 1590 Hz, la frecuencia viene dada segun la formula que se puede apreciar en la fotografia, los diodos se pusieron para que se haga mas facil ajustar el potenciometro y asi el puente quede oscilando, el puente de wien de la fotografia en la practica funciona con una frecuencia de 1735 Hz y con un voltaje peak de 0,57 V, para poder contruir una alarma con este oscilador es necesario conectar a la salida un amplificador de potencia y luego un parlante.

Circuito Acondicionador de Señales, Parte 3 y final: amplificador

2007-10-05T11:35:00.000-04:00

El circuito de la figura es la ultima parte de circuito acondicionador de señales para un termo resistor pt100, el proposito de esta parte consiste en arrojar un voltaje equivalente a 0 [v] cuando la resistencia este a 0 grados celcius y 5 [v] cuando este a 100 grados celcius. Para esto tomamos las salida del amplificador restador y lo conectamos a la entrada del circuito de la figura (Va), el circuito consta de dos partes la primera que es la rama vertical que se extiende hacia arriba que cuenta de 2 resistencias y un potenciometro que busca superponer un voltaje continuo con el proposito de igualar a 0 [v] la entrada al amplificador cuando el termoresistor tenga una resistencia equivalente a 100 [ohm], esto se logra ajustando los valores del potenciometro hasta obtener un Va igual a 0 volts, es importante que esta rama tenga una alta impedancia para no afectar el resto del circuito. la segunda parte del circuito de la figura es simplemente un amplificador inversor con ganancia ajustable para calibrar el voltaje de salida como ya hemos dicho entre 0 y 5 volts. el circuito final con las tres partes conectadas se muestra en el segundo esquematico incluyendo la conexion de la pt 100 de tres hilos.

Circuito Acondicionador de Señales, Parte 2: Amplificador restador

2007-09-29T23:09:00.000-04:00

El objetivo de esta parte del circuito es tomar la diferencia de voltaje en los terminales de la termoresistencia y amplificarlos para luego mas adelante obtener una salida de 0 a 5 volts.

V1: Caída de voltaje en la “pata” 1 de la termo-resistencia.
V2: Caída de voltaje en la “pata” 2 de la termo-resistencia.

El circuito requiere una gran impedancia de entrada para que no entre corriente proveniente de las fuentes de corriente al circuito , esto justifica los valores de las resistencias sobre todo de R4.
como se sabe la termoresistencia Pt100 tiene una resistencia de 138.5 omhs a 100 grados celcius y de 100 ohms a 0 grados celcius esto se utlizo para cacular los voltajes extremos que tomara la Pt100 en sus terminales y asi poder calcular los valores apropiados para R1,R2,R3 y R4.

Circuito Acondicionador de Señales, Parte 1: fuentes de corrriente

2007-09-27T23:23:00.000-04:00

Acontinuacion veremos la primera parte de un circuito acondicionador de señales para un termo resistor (pt100), consiste en la elaboracion de dos fuentes de corrientes para ser conectadas a la termorresistencia, el proposito de esto es eliminar la caida de tension que se genera en los cables, ya que esta caida no es despreciable en comparacion a los voltajes generados en el termoresistor, con los valores de los componentes de la figura se generan dos fuentes de 3 [mA] cuando el potenciometro esta en 2[Kohms], se diseño el circuito con un potenciometro para ajustarlo a la misma resistencia que R4 y asi generar dos fuentes de corrientes identicas.

contador 0 a 999

2007-09-15T14:55:00.000-04:00

Usando el mismo principio que el contador digital de 0 a 9 podemos contruir uno de 0 a 999 usando divisores de frecuencia, el problema aquí es generar una señal de reloj de periodo 10 veces mayor para generar las decenas y otra señal de periodo 100 veces mayor para las centenas, esto lo logramos ocupando la salida 1Q3 como reloj de entrada para el segundo contador y la salida 2Q3 se conecta al reloj de entrada del segundo 74ls393, si miramos las señales de la figura facilitara el entendimiento de los contadores utilizados como divisores de frecuencia. En el divisor por 10 que construimos la señal Q3 caerá a 0 volts cuando la señal de reloj halla concluido 10 cantos de bajada y si bien no genermos una señal de ciclo de trabajo 50 % si generamos una señal de periodo 10 veces el periodo de la señal de entrada.

Contador de 0 a 9

2007-09-12T21:10:00.000-04:00

El circuito de la figura es un contador digital de 0 a 9 accionado por cantos de bajada de la señal del Clock, en este caso se simplifico utilizando la fuente de reloj incluida en la protoboard, el funcionamiento es el siguiente:

El 74hc393 es un contador que suma 1 a la cuenta con cada canto de bajada del reloj así por ejemplo si en un instante en las salidas 1Q0 ,1Q1, 1Q2,1Q3 tenemos 0,0,0,0 respectivamente al cabo de un canto de bajada tendremos 1,0,0,0, es decir tendremos el numero binario 0001 al cabo de otro canto de bajada tendremos el numero 0010 si seguimos asi sucesivamente tendremos:

Contador......... ..binario
1 ..........................0001

2.......................... 0010

3 ..........................0011

4 ..........................0100

5 ..........................0101

6 ..........................0110

7 ..........................0111

8 ..........................1000

9 ..........................1001

10 ........................1010

Nótese que las salidas Q0, Q1,Q2,Q3 van formando señales de reloj en donde el periodo de Q1 es dos veces el periodo de Q0, es decir la salida Q1 representa un divisor de frecuencia por 4 ya que la salida Q0 ya dividió la frecuencia a la mitad del reloj de entrada, asi también la salida Q3 divide la frecuencia por 16. en nuestro circuito utilizamos un divisor de frecuencia por 10 esto lo logramos con la compuerta lógica AND aplicando Q1 & Q2 , esto arrojara 1 o Vcc cuando tanto Q1 como Q2 sean iguales a 1 lo que es exactamente el numero 10, entonces la salida de la compuerta AND va al reset del contador que como ya explicamos reseteara el contador cada 10 cantos de bajada.

Del driver 74LS47 por ahora solo diremos que transforma las cuatro entradas binarias en las 7 salidas que se conectan al display 7 segmentos, así por ejemplo si la entrada es 0001 el 74LS 47 arrojara Vcc por las salidas b y c con lo que visualizaremos el numero 1 en el display.

En la practica conviene conectar resistencias a las entradas del display, unas resistencias de 220 ohms por lo general permiten buena luminosidad y a su ves impiden sobrecalentar los displays , la fuente de reloj puede ser generada con un circuito aestable como el que explicamos anteriormente en el blog, para este circuito con una fuente Vcc de 5 volts debería andar todo muy bien.

Un buen programa donde poder practicar es el que se ve en la foto y se puede descargar de la siguiente pagina : http://www.geocities.com/tourdigital/SimuladorTTLconEscenarios.htm a su creador especiales agradecimientos por disponer de manera gratuita tan buen material.

Circuito Aestable

2007-08-15T17:52:00.000-04:00

El circuito de la figura genera una onda cuadrada que puede ser utilizadas de multiples formas, una de las mas comunes es cuando se utiliza como clock, mas adelante hablare algo sobre eso, por ahora avoquemonos a lo que es el funcionamiento de este circuito, el circuito consiste en basicamente el CI555 dos resistencias y un condensador, segun la descripccion detallada en el post anterior se puede deducir facilmente el comportamiento de este circuito, el condensador comenzara a cargarse y la salida por el pin 3 sera Vcc hasta que el voltaje en el condensador sea igual a 2/3 Vcc momento en el cual la salida caera a cero volts y el condensador se descargara por el pin 7 y solo atraves de una resistencia, esto ocurrira hasta que el voltaje en el condensador este por debajo de 1/3 Vcc y la salida vuelva a ser nuevamente Vcc y asi sucesivamente seguira oscilando el circuito.

Pines del 555

2007-08-15T17:31:00.000-04:00

El circuito de la foto es una equivalencia de lo que es el CI 555 por dentro,los numeros de la figura representan los pines del CI. 1= tierra GND ,2= trigger input, 3= output, 4= reset, 6= umbral ,7= transistor de descarga,8=Vcc. Si el voltaje en el pin 6 es mayor a 2/3 Vcc S esta en uno logico, si el voltaje en el pin 2 es menor que 1/3Vcc R esta en uno logico, cuando Qm+1 esta en uno logico se activa el transistor de descarga y el voltaje en el pin 3 es de cero volt, cuando Qm+1 esta en cero la salida es Vcc y el transistor de descarga cortado. Esta explicacion es la base para comprender el funcionamiento de ambos circuitos, tanto del monoestable como del aestable.

Circuito Monoestable

2007-08-10T18:21:00.000-04:00

Primero que nada una breve introduccion a lo que es el 555, para entender su funcionamiento usaremos la tabla de verdad del flip flop 555(ver imagen), si el voltaje en el pin 6 es mayor a 2/3 de vcc S esta en 1 logico, y si el voltaje en el pin 2 es menor que 1/3 vcc R esta en uno logico, cuando Qm+1 esta en vcc o en uno logico se activa el transistor de descarga(ver datasheet del 555) y no olvidar que la salida por el pin 3 es Qm+1 negado. en el ciruito monoestable el voltaje en el pin 2 debe estar en alto ( 1 logico o vcc),al apretar el boton de reset que llevara el voltaje del pin 2 a 0 por un corto periodo de tiempoel voltaje por el pin 3 sera vcc durante el tiempo determinado por t on=1,1 x R x C con lo que se activara el circuito.