martes, 24 de diciembre de 2013

FELIZ NAVIDAD, PRÓSPERO AÑO 2014

            Feliz navidad, un muy buen año 2014 para todos


        Atte. Benny.

domingo, 15 de diciembre de 2013

MICROCONTROLADORES PIC 27: SWITCH EN EL XC8

           En este caso se comenta como se utiliza la instrucción switch para trabajar con sentencias múltiples en el PIC, con la ayuda del programa XC8; lo que se quiere es realizar diferentes efectos en los leds conectados al puerto b del PIC16F84A.

           El vídeo es el siguiente:



       El esquema del circuito utilizado es el que sigue:


         A continuación el diagrama de flujo utilizado para realizar el programa:


      Aquí el programa codificado en el XC8:

#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer (WDT disabled)
#pragma config PWRTE = ON       // Power-up Timer Enable bit (Power-up Timer is enabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)

#include <xc.h>
#define _XTAL_FREQ 4000000

void main(void) {

    int cuenta=0;
    int efecto=0;
    TRISB=0;
    PORTB=0;

    __delay_ms(200);

    while(1){
        cuenta=cuenta+1;

        switch(cuenta){                              //Aquí el programa empieza a verificar los valores que
            case 10:                                     //va tomando la variable cuenta
                efecto=1;          
                PORTB=0b00000001;
                break;
            case 80:
                efecto=2;
                PORTB=0b01010101;
                break;
            case 160:
                efecto=3;
                PORTB=0b10000000;
                break;
            case 240:
                efecto=4;
                break;
        }

        switch(efecto){                            //Aquí el programa verifica los valores de la variable 
            case 1:                                    //efecto para que de acuerdo a ello el pic nos de diferentes
                __delay_ms(100);                //salidas por el puerto b, lo cual veremos a traves de leds
                PORTB<<=1;
                if(PORTB==0)
                    PORTB=0b00000001;
                break;
            case 2:
                __delay_ms(100);
                PORTB=~PORTB;
                break;
            case 3:
                __delay_ms(100);
                PORTB>>=1;
                if(PORTB==0)
                    PORTB=0b10000000;
                break;
            default:
                PORTB=0b10000001;
                __delay_ms(100);
                PORTB=0b01000010;
                __delay_ms(100);
                PORTB=0b00100100;
                __delay_ms(100);
                PORTB=0b00011000;
                __delay_ms(100);
                PORTB=0b00100100;
                __delay_ms(100);
                PORTB=0b01000010;
                __delay_ms(100);
        }

        if(cuenta==255)                                 //el programa está siempre verificando el valor de la
            cuenta=0;                                       //variable cuenta.
    }

    return;
}


         He aquí una imagen del circuito en plena operación:

Atte Benny.

sábado, 14 de diciembre de 2013

MICROCONTROLADORES PIC 26: SWITCH EN CCS

              En este caso se realiza un programa para mostrar como podemos hacer la selección múltiple en el CCS, para ello nos ayudamos de la instrucción SWITCH.
           
              El vídeo es el siguiente:


              A continuación el esquema del circuito utilizado:


             El que sigue es el diagrama de flujo que se utilizó para realizar el programa



            El siguiente es el código en realizado en CCS, para ver como utilizar el switch cuando se presenten condiciones múltiples:

#include <16F84A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES PUT                      //Power Up Timer

#use delay(crystal=4000000)

//Lo de arriba nos lo crea el asistente al preparar los bits de configuración
//para verlo haces click con el botón derecho sobre <led.h> (esto depende del nombre
//que le des a tu programa en este caso lo llamamos led)
//y le das click en open file at cursor


#include <led.h>
#use fast_io(b)
#byte portb=0x06

void main()
{  
   int16 tiempo=500;
   int8 contador=0;
  
      
   set_tris_b(0x00);
   portb=0x00;
   
   delay_ms(tiempo);

   while(TRUE)
   {
      contador=contador+1;
         
      switch(contador){
         case 20:
            portb=0b10101010;
            break;
         case 40:
            portb=0b00001111;
            break;
         case 60:
            portb=0b11111111;
            break;
         case 80:
            portb=0b11000011;
            break;
            
      }
      
      portb=~portb;
      
      if(contador==81)
         contador=0;
         
      delay_ms(tiempo);
         
   }

}

Atte Benny.

MICROCONTROLADORES PIC 25: PBP SELECT CASE 

          En este caso se realiza un programa muy sencillo en PBP, de lo que se trata aquí es ver como se utiliza la instrucción select case para poder realizar selecciones múltiples.

             El vídeo es el siguiente:


           El esquema del circuito utilizado:


           El diagrama de flujo utilizado para realizar el programa en PBP es el siguiente:

          El código del programa realizado en PBP es el que sigue:

#CONFIG
   __config _XT_OSC & _WDT_OFF & _PWRTE_ON & _CP_OFF

 #ENDCONFIG

DEFINE OSC 4

trisb.4=0
trisb.5=0
trisb.6=0
trisb.7=0

tiempo    var word
contador var byte

tiempo   =100
contador=0

symbol ledRojo        = portb.4
symbol ledAmarillo  = portb.5
symbol ledVerde      =portb.6
symbol ledNaranja   =portb.7

low ledRojo       
ledAmarillo  =0
ledVerde     =0
ledNaranja  =0

pause tiempo

inicio:
contador=contador+1

select case contador
case 80
ledRojo       =1
ledAmarillo  =0
ledVerde     =0
case 160
low   ledRojo
high  ledAmarillo 
low   ledVerde   
case 240
ledRojo       =0
ledAmarillo  =0
ledVerde     =1
case else
toggle ledNaranja
end select

if contador=255 then contador=0

pause tiempo

goto inicio
end

Atte Benny.

SELECT CASE EN PBP, SWITCH EN CCS Y XC8

          Se comenta sobre las instrucciones que nos ayudaran a programar nuestros PIC con las selecciones múltiples.

          Para el caso del PBP es de la siguiente manera:

select case valor

          case valor_1
          sentencias

          case valor_2
          sentencias
             .
             .
             .
          case valor_n
          sentencias

          case else
          sentencias

end select



            Para los casos del CCS y del XC8, como ambos están basados en el C, será de la siguiente forma:

switch(valor){

          case valor_1:
                  sentencias;
                  break;
          case valor_2:
                  sentencias;
                  break;
             .
             .
             .
          case valor_n:
                  sentencias;
                  break;

          default:
                  sentencias
}

          El vídeo relacionado lo puedes ver aquí:


        Atte Benny.

miércoles, 27 de noviembre de 2013

PRIMER PROGRAMA CON UN MICROCONTROLADOR PIC UTILIZANDO EL XC8 EN EL MPLABX

              En este caso la idea es conocer el IDE MPLABX y como utilizarlo para programar nuestros pic con el XC8, se desde como iniciar el programa, crear el archivo donde guardaremos nuestro programa, y luego hacemos un programa demostrativo muy sencillito que consiste en encender y apagar un par de leds.
              El vídeo lo puedes ver aquí:


El código del programa es el siguiente:

//Lo que va luego de los dos signos de división son comentarios, el programa los ignora

#pragma config FOSC = XT                  // Esta es la forma en que el xc8 prepara los bits de configuración
#pragma config WDTE = OFF              // el oscilador será un cristal, no se usará el WDTE.
#pragma config PWRTE = ON             // Power-up Timer está habilitado.
#pragma config CP = OFF                    //sin código de protección.

#include <xc.h>                                     //Esta línea lo crea el programa, es donde el programa encuentra
                                                             //lo referente al PIC que estemos usando, en este caso el                                                                               //PIC16F84A.
#define _XTAL_FREQ 4000000           //En esta línea le indicamos la velocidad de nuestro cristal.

void delay_ms(int);                                 //prototipo para crear una función para manejar los tiempos con
                                                              //una variable de tipo entero, en el vídeo se comenta el porque
                                                              //de esto.

void main(void) {                                   //Aquí se inicia la función principal
    int tiempo=500;                                 //se crea una variable llamada tiempo con un valor inicial de 500ms
    TRISBbits.TRISB3=0;                      //Así es como se configuran los pines individuales para que en
    TRISBbits.TRISB4=0;                      //este caso sean salidas, para entradas se iguala a 1.

    PORTBbits.RB3=0;                          //así es como se declara lo que en un inicio saldrá por el pin 
    PORTBbits.RB4=1;                         //0 para que salga un bajo, 1 para que salga un alto.

    delay_ms(tiempo);                             //función creada para poder utilizar la variable tiempo.

    while(1){                                           //Se inicia el ciclo repetitivo.
        PORTBbits.RB3=1;                      //Se invierten las salidas iniciales de los pines
        PORTBbits.RB4=0;                      //

        delay_ms(tiempo);                        //Se espera un tiempo.

        PORTBbits.RB3=0;                      //se vuelve a invertir la salida de los pines
        PORTBbits.RB4=1;

        delay_ms(tiempo);                        //se vuelve a esperar un tiempo, luego se repite lo que va dentro
                                                            //de while
    }
    return;                                              //se usa para indicarle al programa que ya se terminó el código
}

void delay_ms(int t){                            //Aquí se define la función que nos permitirá utilizar la variable
    for(int i=0;i<t;i++)                            //tiempo
        __delay_ms(1);                            //esta es función para tiempos que trae el xc8, la cual solo nos deja
}                                                          //ingresar números por eso se crea la función para poder utilizar
                                                            //variables.


Atte Benny.


martes, 26 de noviembre de 2013

TIPOS DE DATOS Y VARIABLES EN EL PBP3

           Lo que se comenta aquí lo puedes hallar en el manual del PBP3
           
           Las variables son nombres que nosotros le vamos a dar a los espacios de memoria del PIC esto es, a los registros de propósito general donde guardaremos nuestros datos con los cuales  vamos a trabajar; que el caso del PBP3 que  utilizaremos, los datos que podemos manipular son de 3 tipos como vemos a continuación:
           
TIPO                     NÚMERO DE BITS                     RANGO DE VALORES
bit                                     1                                           0 a 1
byte                                   8                                           0 al 255
word                                 16                                          0 al 65535

           Estos son los tipos de datos con los cuales podemos trabajar utilizando el PBP3, como vemos existe un dato de tipo bit en el cual solo podremos guardar un 0 o un 1; en los datos de tipo byte podremos guardar valores que van desde el 0 al 255 y si tenemos datos de mayor valor los tenemos que guardar en los datos de tipo word, pues aquí podemos guardar datos cuyos valores vayan del 0 al 65535; como vemos en el PBP3 no nos permite trabajar con valores negativos, pero para lo vamos a ir aprendiendo no lo vamos a necesitar.

           Para declarar una variable en PBP3 lo haremos con la palabra reservada var, la forma en que se realizará esta acción será:

nombre_variable var tipo_dato

          Por ejemplo si necesitamos un dato de un solo bit es decir un 0 o un 1,escogemos un nombre adecuado para el dato(el nombre de la variable es decisión tuya, para el ejemplo lo hemos llamado datobit) y lo declaramos así:

datobit var bit
para  asignarle un valor se hace así:
datobit = 0, si quieres guardar un cero o
datobit = 1, si quieres guardar un uno,
para este tipo de dato no tienes mas opciones.

             Si tu dato es un valor no negativo menor o igual a 255 tendrás que declarar tu variable de tipo byte, en este caso también se incluyen los caracteres, pues son datos que en ASCII no pasan de 255, estos datos los declaramos así(el nombre de la variable lo escoges tú, en el ejemplo lo hemos llamado datobyte):

datobyte var byte

             Para asignarle un valor en este caso tenemos mas posibilidades si se trata de un número, le podemos asignar el valor en forma binaria, en decimal o en hexadecimal, por ejemplo si a nuestra variable le queremos asignar el valor de 123 se haría así:

EN BINARIO                                       EN DECIMAL                        EN HEXADECIMAL
datobyte = %01111011                       datobyte = 123                          datobyte=$7B

                 Cualesquiera de las tres formas se puede utilizar, no olvidarse que en binario hay que anteponerle el signo  de porcentaje %, en decimal no se agrega nada se escribe tal cual y en hexadecimal hay que anteponerle el signo de dolar $.

                 Si lo que se quiere es guardar un carácter se tendrá que declarar poniendo el carácter entre comillas, por ejemplo si queremos guardar el carácter c, lo haremos así:
datobyte = "c", el carácter irá entre comillas.

                     Si nuestro dato tiene un valor mayor a 255 entonces nuestra variable en la que guardaremos el dato será de tipo word(este tipo de dato esta formado por dos bytes), este dato a lo mucho podrá tener un valor de 65535, es este caso a nuestra variable para el ejemplo la llamaremos datoword, recuerda que eres tú quien escoge el nombre, lo declararíamos de la siguiente manera:

datoword var word

                  Para asignarle un valor también podemos hacerlo en binario, en decimal o en hexadecimal, por ejemplo si queremos guardar el valor 23501, se haría en cualesquiera de las tres maneras:

EN BINARIO                                                EN DECIMAL                        EN HEXADECIMAL
datoword = %0101101111001101                 datoword = 23501                  datoword=$5BCD

siempre en binario anteponiendo el signo de porcentaje % y al hexadecimal el signo de dolar $.

Atte Benny.










PRIMER PROGRAMA CON UN MICROCONTROLADOR PIC UTILIZANDO EL CCS

              En este vídeo lo que se pretende es conocer como podemos empezar para realizar nuestros programas para el PIC con el CCS, en este caso se empieza por un programa muy sencillo que lo que hará será decirle a nuestro integrado que nos encienda y apague un led, pero nos será muy útil para comenzar a conocer algunas primeras funciones del CCS que nos ayudarán a hagamos programas para el PIC.

                   El CCS y su manual lo encontrarás aquí.

                   El vídeo con el cual comenzamos es el siguiente:


El programa en CCS creado es el siguiente:

//Los dos signos de división juntos indican que es un comentario
//el programa pasa de lo que aquí se haga.

#include <16F84A.h>                //Es la forma en que se le indica al CCS que pic se usará, siempre
                                                  //siempre debe ir al inicio de nuestros programas.

#FUSES NOWDT                     //Es la forma en que el CCS
#FUSES PUT                            //prepara las bits de configuración.

#use delay(crystal=4000000)      //así es como se declara de que valor el cristal que se usa
                                                   //hay que indicarle la velocidad de nuestro cristal.

void main()                                 //Aquí comienza nuestro programa siempre con void main().
{
   int16 tiempo=500;                   //declaramos una variable entera tiempo de 16 bits y lo inicializamos.
   delay_ms(tiempo);                   //le pedimos que nos espere un tiempo(500ms) antes de continuar
   while(TRUE)                           //comienza el ciclo repetitivo.
   {
      output_high(pin_b4);              //le decimos que por el pin rb4 nos envíe un uno.
      delay_ms(tiempo);                 //que nos espere un tiempo(500ms) y luego continua.
      output_low(pin_b4);              //Ahora envíanos un cero por el pin rb4. 
      delay_ms(tiempo);                 //vuelve a esperarnos 500ms y luego repite el ciclo.
   }

}

luego se le hace una pequeña modificación que podrás ver en vídeo.

Atte Benny.

EL PIN MCRL

                  En este caso se comenta sobre el pin de reseteo que lo tienen todos los microcontroladores PIC, en el caso del PIC16F84A este pin debe estar conectado constantemente a un alto(un uno, 5V, etc) si no queremos que nuestro pic se reinicie o se resetee en forma permanente, ya que si se pone a 0(un cero, 0V,etc) el microcontrolador se reiniciará, lo cual es conveniente cuando nuestro pic se queda colgado, es decir deja de realizar las tareas que le hemos encomendado mediante un programa, cuando eso pasa pues le mandamos un cero por el pin mclr y nuestro pic retornará al inicio de programa y volverá a trabajar adecuadamente.
En la figura puedes ver un arreglo Pull up(así llaman este arreglo)
para poder controlar lo que le llegará al pin de reseteo(MCLR)

                El PIC16F84A no permite configurar este pin para que realice otra actividad si vas a la hoja de datos de este pic encontrarás la figura con la descripción de los pines que trae, en este caso como podrás ver que el pin de reset es el pin 4, esa linea que trae sobre MCLR indica que el pin es activo en bajo, es decir que va realizar la actividad para la cual fue creada si le llega un bajo y lo que hace es pues resetear nuestro pic.

                   En otros pic como el PIC16F88, el pin de MCLR se puede configurar para que cumpla otras funciones, en este caso este pin no solo se puede utilizar para resetear el pic, si no que por programa tu puedes indicarle si quieres que funcione como pin de reset o en este pic como un pin de entrada/salida digital como puedes ver en la imagen de su distribución de pines.

                 En el vídeo que se preparó sobre este tema se indica como podemos seleccionar las resistencias adecuadas para utilizar el pin MCLR para que cumpla la función de reset, siempre siguiendo lo que nos indica las hojas de características del pic.

                  El siguiente es el vídeo:


Atte Benny.

domingo, 24 de noviembre de 2013

EL PICKIT3

                Este será el programador que se utilizará a lo largo de toda esta serie de  vídeos relacionados con los microcontroladores PIC, es un programador muy sencillo de utilizar, se conecta al ordenador mediante un cable USB, una vez que instalas el software que necesita ya está listo para ser usado, no es necesario configurar nada en el ordenador, cuando lo conectas a algún PIC el Pickit3 lo reconoce solo sin tener que decirle con que PIC está conectado, para programar solo hay que decirle donde se encuentra nuestro archivo.exe que queremos cargar en el PIC luego darle a write y listo, siempre y cuando el archivo.exe esté preparado para el PIC conectado al Pickit3.

               Aquí encuentras el software para el programador Pickit3

En la imagen puedes ver el Pickit3 antes de
conectarse al PIC


               Conforme vayamos avanzando en los siguientes vídeos iremos viendo algunas otras características con las cuales cuenta el Pickit3.
                 
                El vídeo es el siguiente.


                En el vídeo se comenta  la manera en que podemos conectar el Pickit3 al PIC que estemos utilizando, es decir a que pines del PIC hay que conectar cada salida del Pickit3; también se comenta como obtener el software necesario para poder utilizar nuestro programador, se hace una prueba de como programar nuestro PIC con el Pickit3.


El la imagen puedes ver el Pickit3 conectado al PIC


Atte Benny


PRIMER PROGRAMA CON UN MICROCONTROLADOR PIC UTILIZANDO EL PBP3


           Se realiza un primer programa muy sencillo con un microcontrolador PIC, en este caso se utiliza el integrado PIC16F84A, con este programa lo único que hará el PIC será que por uno de sus pines(en este caso el pin RB4) se hará parpadear un led.

         Se es muy detallista en este vídeo ya que se intenta quede lo mas claro posible como hay que proceder para que nuestro programa nos quede bien, vemos como utilizar la hoja de datos del PIC para empezar a familiarizarnos con sus registros, también vamos conociendo unas primeras instrucciones del PBP3, el como debemos declarar nuestros bits de configuración utilizando este programa.

             Aquí el enlace a la página donde encontrarás el PBP3.
             Aquí el enlace a la hoja de datos del PIC16F84A.

             El siguiente es el vídeo


          El programa en PBP3 con el cual se hace el efecto del parpadeo del led es el siguiente:

'lo que va luego de la comilla simple son comentarios que no afectan el programa
'se utilizan con el fin de hacerlo mas entendible y para documentación para no olvidarnos
'que es lo que hace cada linea de código, no es obligatorio, el programa igual
'funciona sin comentarios.
'------------------------------------------------------------------------------------------------
'se declaran los bits de configuración, esto se hace en assembler
 #CONFIG
   __config _XT_OSC & _WDT_OFF & _PWRTE_ON & _CP_OFF

 #ENDCONFIG

DEFINE OSC 4               'se define la velocidad del oscilador.

trisb.4=0                   'se utilizará el bit 4 del puerto b como salida.
portb.4=0                 'en un comienzo por el bit 4 del puerto b saldrá un cero o un bajo.
tiempo var word        'se declara una variable llamada tiempo de 16 bits.
tiempo=500              'se da un valor inicial a tiempo de 500(esto se puede cambiar a otros valores).

pause tiempo             'con esto le decimos que queremos una pausa de 500ms, pues tiempo es 500.

inicio:                                 'inicia el ciclo repetitivo del programa.
high portb.4               'en este momento el led se enciende.
pause tiempo             'el led estará encendido durante 500ms.
low portb.4                'en este momento el led se apaga.
pause tiempo             'el led estará apagado durante 500ms

goto inicio                          'se vuelve a inicio, el led vuelve a encenderse y esto se repite por siempre.
end                                    'siempre va al final de un programa echo en PBP3.


           Como puedes ver es un programita muy facilito, con el tiempo ya nos iremos complicando la vida, pero es así como hay que empezar.



Atte Benny


SOBRE LAS HOJAS DE DATOS DE LOS MICROCONTROLADORES PIC(DATASHEET)

             En este caso se comenta como se puede utilizar la hoja de datos del PIC que se esté usando para obtener información necesaria para poder programar nuestro microcontrolador, en la hoja de datos está toda la información que necesitemos para hacer que el PIC trabaje adecuadamente, allí encontraremos como está organizado, los registros de los cuales consta, una descripción detallada de dichos registros, los bits de configuración y mucho mas, por eso es importante saber utilizar estas hojas de datos(datasheet).
              
              Cuando queramos programar un PIC va a ser necesario siempre tener a mano su hoja de datos(a no ser que ya estés muy familiarizado con el PIC que utilices).

                Aquí el enlace al vídeo


viernes, 22 de noviembre de 2013

LOS PROGRAMAS PARA EL PIC

         Aquí se comenta sobre algunos programas que podemos utilizar para programar nuestro PIC, como son el PBP3, el CCS y el XC8, los cuales podemos descargar desde sus respectivas páginas, se ve la forma en que podemos descargarlos, instalarlos y como iniciar estos programas, en los cuales luego escribiremos las lineas de código necesarias para hacer que nuestros PIC comienzan ha hacer cosas.
        
          El PBP3 lo puedes descargar desde aquí.
          El CCS lo encuentras aquí.
          El MPLABX y el XC8 los tienes aquí.

          En los enlaces indicados encontrarás los programas así como sus manuales.

         El vídeo Microcontroladores PIC 2:Sobre los programas necesarios el siguiente:


Atte Benny.

MICROCONTROLADORES PIC

            Hola, comenzamos con una serie de vídeos relacionados con el tema de los microcontroladores PIC; aquí en el blog iremos complementando el tema según vayamos avanzando con los vídeos.
         Te dejo el enlace al primer vídeo aquí  donde se da una breve introducción al tema de los microcontroladores PIC; espero nos divirtamos en esta nueva aventura, desde ya un saludo.  


                Una imagen de una de las cosas que seremos capaces de llegar a realizar

                El siguiente es el  programa que se utilizó para la imagen que vez arriba, y el cual se puede ver trabajando en este nuestro primer vídeo sobre microcontroladores PIC; se usó el PIC18F4550, está echo en el CCS.

#include <18F4550.h>

#FUSES NOWDT                                
#FUSES HS                       
#FUSES NOBROWNOUT              
#FUSES NOLVP                    
#FUSES NOPBADEN                 
#FUSES NOXINST                              
#FUSES CPUDIV1                
#FUSES NOUSBDIV                 
#FUSES NOVREGEN              
#FUSES NOICPRT                 

#use delay(clock=20000000)
#use fast_io(b) 
  
#byte portb=0x0f81    

 #define LCD_DATA_PORT getenv("SFR:PORTD")
#define ENABLE_PIN D0
#define RS_PIN D1
#define RW_PIN D2
#define Data4 D4
#define Data5 D5     
#define Data6 D6
#define Data7 D7     
#include <lcd.c>      


void main()
{  
   int i=0;
   int16 tiempo=100;    
   
   set_tris_b(0x00);
   portb=0b01010101; 
   
   lcd_init();         
   delay_ms(200);
   
   lcd_putc("\f");
                  
   while(true){  
    
   
   if(i<=15){
    lcd_putc("\f");
   lcd_gotoxy(5,1);   
   printf(lcd_putc,"Que tal");  
   lcd_gotoxy(6,2);
   printf(lcd_putc,"Mundo");   
    
   }                
   if(i>15){ 
    lcd_putc("\f");    
    lcd_gotoxy(4,1);     
   printf(lcd_putc,"un saludo");   
   lcd_gotoxy(3,2);
   printf(lcd_putc,"de MrElberni");   
                      
    if(i==30)
    i=0;       
   }                       
   
   delay_ms(tiempo);
   portb=~portb;       
   i++; 
   }



 Atte Benny.

domingo, 23 de junio de 2013

DIENTE DE SIERRA CON EL SCR 2N5061

        Te dejo allí una imagen del circuito que se obtuvo en el vídeo, nos quedó por obtener el periodo de la onda diente de sierra obtenida, para ello hay que tener en cuenta lo que ve el condensador mientras se  va cargando, el condensador tendera a cargarse hasta los 8V por ende ese será su voltaje final, Vf en la imagen, pero el SCR sólo le permite cargarse hasta 2V, Vc en la imagen, el voltaje inicial Vi en la imagen es el voltaje a partir del cual se carga el condensador que es 0,7V que es la tensión que cae en el tiristor.

        Para hallar RC (la constante de tiempo) hay que tener en cuenta lo que ve el condensador mientras se va cargando, para ello aplicamos el Teorema de Thevenin, tal como vez en la imagen.

      La fórmula utilizada es la que le corresponde a la carga del condensador cuando este comienza a cargarse a partir de un cierto voltaje inicial, a partir de la cual solo tenemos que despejar t, el cual  vendría a ser el periodo de la onda diente de sierra, y si lo que te interesa es la frecuencia solo inviertes ese valor.

        Mas información sobre condensadores puedes encontrarlo en los libros:
Analisis Introductorio de Circuitos; de Boylestad.
Circuitos Eléctricos de Dorf.


                   El vídeo lo puedes ver aquí





          Esta es una foto de la onda diente de sierra que obtuvimos

         Y aquí está el circuito



                                                                                            Atte:   Benny

TIRISTORES 

        Hola , se comenzará a publicar una serie de vídeos sobre el tema de los tiristores, algunas cosas que se pasen por alto se tratará de completarlas a través del blog.
            Aquí  para el primero de ellos: Tiristor 1: Medidas importantes del SCR 2N5061


          Espero poder ayudarles.

                                                                                                                      Atte: Benny

lunes, 11 de marzo de 2013

Fuente de alimentación variable simétrica

             Hola, te dejo el esquema de la fuente de alimentación variable simétrica, esta fuente nos dará salidas de continua tanto positivas como negativas, que serán de 1,25V a poco mas de 16V en positivo, y de -1,25 a poco menos de -16V en negativo, están basados en los reguladores integrados LM317T para las tensiones positivas y el LM337T para las tensiones negativas.
         
            Para este caso necesitarás un transformador  que el secundario tenga en sus salidas una derivación central, en este caso se usa uno de 12V - 0V - 12V; el cual debe ser capaz de entregar en el secundario como mínimo 1A.

             El vídeo es el siguiente:



              
             Te dejo la imagen del esquema, y si no lo puedes ver bien, te lo puedes descargar aquí



           



                                                                                             Atte: Benny.