TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: federico1 en 06 de Junio de 2008, 21:04:13

Título: Destellador de Leds con PIC
Publicado por: federico1 en 06 de Junio de 2008, 21:04:13
Estimados,
recien estoy empezando en este apasionante mundo de los pics, estoy leyendo el libro de desarrollo de proyectos de pic 16f84A. Tengo ganas de hacer una plaquita que haga lo siguiente, como demuestra el video

alguien tiene algun ejemplo parecido que pueda ser utilizado como ejemplo , o alguna web con proyectos similares?


desde ya muchas gracias
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 06 de Junio de 2008, 23:33:33
Hola Federico. Haz elegido un mal preyecto para emezar con los PIC. Primero empieza a gatear y luego a correr.

Este proyecto maneja audio, mas precisamente, se trata de luces audiorítmicas. Para hacerlo sin PIC, en la web, hay millones de circuitos, pero para utilizar un PIC, deberás saber manejar las entradas analógicas para lograr que titilen según el tono de voz.
Título: Re: Destellador de Leds con PIC
Publicado por: federico1 en 16 de Junio de 2008, 14:20:35
Hola Federico. Haz elegido un mal preyecto para emezar con los PIC. Primero empieza a gatear y luego a correr.

Este proyecto maneja audio, mas precisamente, se trata de luces audiorítmicas. Para hacerlo sin PIC, en la web, hay millones de circuitos, pero para utilizar un PIC, deberás saber manejar las entradas analógicas para lograr que titilen según el tono de voz.
Hola leon

lo que yo quiero hacer es muy basico, con un 16f84a, uso 2 pines de salida, a un pin le conecto una plaquita con 20 leds rojos y al otro pin 20 leds azules.
despues es programar las salidas que hagan algun tipo de juego raro de colore.
No tiene nada que ver con la voz ni el tono.

slds
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 16 de Junio de 2008, 14:46:08
Bueno, eso es muy facil. Lo que pasa es que el video, parecía que las luces titilaban al ritmo de la música.

Si te animás hacerlo tu mismo, te puedo ir ayudando. Pero primero tengo que saber si programas en assembler. En CCS te puedo ayudar también, pero aún no lo manejo muy bien.

También me gustaría saber si sabes manejar el mplab, si no, acá te paso un link con videostutoriales para aprender a manejarlo (http://www.todopic.com.ar/foros/index.php?topic=19177.0)
Título: Re: Destellador de Leds con PIC
Publicado por: federico1 en 16 de Junio de 2008, 15:07:43
Bueno, eso es muy facil. Lo que pasa es que el video, parecía que las luces titilaban al ritmo de la música.

Si te animás hacerlo tu mismo, te puedo ir ayudando. Pero primero tengo que saber si programas en assembler. En CCS te puedo ayudar también, pero aún no lo manejo muy bien.

También me gustaría saber si sabes manejar el mplab, si no, acá te paso un link con videostutoriales para aprender a manejarlo (http://www.todopic.com.ar/foros/index.php?topic=19177.0)
:)
Barbaro, gracias Leon!

si, manejo assembler y mplab.

un saludo

pd: tenes msn?
Título: Re: Destellador de Leds con PIC
Publicado por: navaismo en 16 de Junio de 2008, 15:13:04
Hola Federico. Haz elegido un mal preyecto para emezar con los PIC. Primero empieza a gatear y luego a correr.

Este proyecto maneja audio, mas precisamente, se trata de luces audiorítmicas. Para hacerlo sin PIC, en la web, hay millones de circuitos, pero para utilizar un PIC, deberás saber manejar las entradas analógicas para lograr que titilen según el tono de voz.
Hola leon

lo que yo quiero hacer es muy basico, con un 16f84a, uso 2 pines de salida, a un pin le conecto una plaquita con 20 leds rojos y al otro pin 20 leds azules.
despues es programar las salidas que hagan algun tipo de juego raro de colore.
No tiene nada que ver con la voz ni el tono.

slds

Mirate los ejemplos de PBP y proteus, incluso los de MKB donde hay algunos efectos como el del auto increible
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 16 de Junio de 2008, 16:24:07
Si tengo, pero vamos hacerlo por acá así otros que también se inician pueden seguir el hilo e ir preguntando también.

Vamos a comenzar por algo cencillo. Un LED. Este led lo vamos a conectar en el puerto b, más precisamente RB0. Atravez de una resistencia limitadora para no sobrecargar al pic, aunque el pic lo soporte bien.

Una vez que allamos encabezado nuestro programa, hay que recordar que RB0, debe ser configurado como salida.

El CP lo que debe hacer es una tarea muy cencilla, primero poner a RB0 a 1, luego de un tiempo, volver a ponerlo a 0

Por ejemplo:

Código: ASM
  1. DENUEVO   BSF      PORTB,0     ;Pongo a 1 a RB0
  2.            CALL    T20             ;llamo a la rutina de temporización de 20ms
  3.            BCF      PORTB,0     ;Pongo a 0 a RB0
  4.            CALL    T20
  5.            GOTO    DENUEVO    ;Voy a la etiqueta denuevo que continuará sin parar
  6. ;
  7. T20
  8. PLoop2  clrwdt              ; 1 clear watchdog
  9.         decfsz    PDel1, 1  ; 1 + (1) es el tiempo 0  ? (A)
  10.         goto      PLoop2    ; 2 no, loop
  11.         decfsz    PDel0,  1 ; 1 + (1) es el tiempo 0  ? (B)
  12.         goto      PLoop1    ; 2 no, loop
  13. PDelL1  goto PDelL2         ; 2 ciclos delay
  14.         clrwdt              ; 1 ciclo delay
  15.         return              ; 2+2 Fin.

       END

¿Entiendes este programa?
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 16 de Junio de 2008, 16:32:41
Muy bien, continuemos (lo divido en varios post para que no sea muy largo)

Vamos a complicarla un poco más. Vamos a simular un 4017. Para esto vamos a poner 8 LED en el puerto b, o sea, un led por cada bit del puerto.

Código: ASM
  1. DENUEVO   BSF      PORTB,RB0
  2.           CALL    T20
  3.           BCF      PORTB,RB0
  4.           BSF      PORTB,RB1
  5.           CALL    T20
  6.           BCF      PORTB,RB1
  7.           BSF      PORTB,RB2
  8.           CALL    T20
  9.           BCF      PORTB,RB2
  10.           BSF      PORTB,RB3
  11.           CALL    T20
  12.           BCF      PORTB,RB3
  13.           BSF      PORTB,RB4
  14.           CALL     T20
  15.           BCF      PORTB,RB4
  16.           BSF      PORTB,RB5
  17.           CALL    T20
  18.           BCF      PORTB,RB5
  19.           BSF      PORTB,RB6
  20.           CALL    T20
  21.           BCF      PORTB,RB6
  22.           BSF      PORTB,RB7
  23.           CALL    T20
  24.           BCF      PORTB,RB7
  25.           GOTO   DENUEVO

Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 16 de Junio de 2008, 16:39:58
Lo que quiero que hagas ahora es lo siguiente, vamos a colocar 12 LED, empezando por LED1 ubicado en RB0, LED2 ubicado en RB1, LED8 ubicado en RB7, LED9 ubicado en RA0 LED10 ubicado en RA1, LED12 ubicado en RA3.

El bit RA4 no lo vamos a utilizar porque es de colector abierto, para que funcione hay que poner una resistencia de 1K a VCC. Si te annimas a usarlo mejor. Entónces tendrás 13 LED.
Título: Re: Destellador de Leds con PIC
Publicado por: federico1 en 16 de Junio de 2008, 16:42:02
Muy buena informacion leon, gracias

lo que yo tenia pensado era usar 2 pines,

y a cada pin,conectar una placa con 40 leds por ejemplo, entendes lo que digo? entonces solo uso dos outputs, total prenden todos los rojos, o todos los azules.

un saludo y muchas gracias nuevamente
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 16 de Junio de 2008, 16:44:11
Si, ya se. Pero si no sabes hacer lo anterior, no vas a saber darles efectos a los LED. No te voy hacer yo el programa. Lo que quiero es que aprendas.

Si aún quieres insistir en eso, acuerdate de controlar los 40 LED, uno o varios transistores, porque el PIC, se te va a quemar.
Título: Re: Destellador de Leds con PIC
Publicado por: firepic en 16 de Junio de 2008, 17:13:20
Si aún quieres insistir en eso, acuerdate de controlar los 40 LED, uno o varios transistores, porque el PIC, se te va a quemar.

Yo diría explotar  :D  :D  :D
Leon, muy bueno que te pongas a enseñarle a federico y lo dejes en el foro... seguro alguien luego quiera hacer algo parecido... muchas gracias!
Excelente!
Saludos, nos leemos!  :mrgreen:
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 18 de Junio de 2008, 17:24:15
¿Y? ¿que pasó?
Título: Re: Destellador de Leds con PIC
Publicado por: firepic en 18 de Junio de 2008, 18:07:26
Tal vez federico terminó de hacer el destellador, comenzó a producirlo en serie y venderlo, se hizo rico y anda dando un paseo por el mundo en su avión privado...  :D  :D  :D
Título: Re: Destellador de Leds con PIC
Publicado por: Leon Pic en 18 de Junio de 2008, 18:18:47
 :D :D :D :D :D :D :D :D :D

Vamos a tenerle paciencia. Si no, luego lo continuaré.
Título: Re: Destellador de Leds con PIC
Publicado por: firepic en 18 de Junio de 2008, 18:29:05
 :D  :D  :D
De acuerdo Leon... por aquí seguiremos a la espera de sus avances...
Saludos, nos leemos!  :mrgreen:
Título: Re: Destellador de Leds con PIC
Publicado por: arenita en 05 de Mayo de 2013, 19:51:52
tienes el circuito y programa que me lo puedas pasar karnal mi correo es vic.linkinpark_666@hotmail.com
Título: Re: Destellador de Leds con PIC
Publicado por: jeremylf en 07 de Mayo de 2013, 02:26:30
No se si reírme o llorar =D
Título: Re: Destellador de Leds con PIC
Publicado por: pucara en 18 de Diciembre de 2014, 21:33:52
Hola Federico. Haz elegido un mal preyecto para emezar con los PIC. Primero empieza a gatear y luego a correr.

Este proyecto maneja audio, mas precisamente, se trata de luces audiorítmicas. Para hacerlo sin PIC, en la web, hay millones de circuitos, pero para utilizar un PIC, deberás saber manejar las entradas analógicas para lograr que titilen según el tono de voz.
Hola leon

lo que yo quiero hacer es muy basico, con un 16f84a, uso 2 pines de salida, a un pin le conecto una plaquita con 20 leds rojos y al otro pin 20 leds azules.
despues es programar las salidas que hagan algun tipo de juego raro de colore.
No tiene nada que ver con la voz ni el tono.
[/center]

Hola...    soy nuevo en esto de programar pic´s...   y estoy necesitando hacer un destellador programado, que haga dos disparos en un led, una pausa y dos disparos en otro led, volviendo con la pausa al primero...  sé que se puede hacer, y estoy tratando de hacerlo.     Me presento, soy Hugo ( pucara ) y este proyecto simple es para unas luces de puntas de ala, para un ultraliviano.   Agradezco me den una mano con la creacion de la placa, de la programacion, y poder desarrollar este proyecto, aprendiendo a aplicar los pic´s     Gracias.     Mi email es:    tresclavos@adinet.com.uy  y soy de URUGUAY.     FELICES FIESTAS.
Título: Re: Destellador de Leds con PIC
Publicado por: pucara en 25 de Diciembre de 2014, 12:42:51
Muy bien, continuemos (lo divido en varios post para que no sea muy largo)

Vamos a complicarla un poco más. Vamos a simular un 4017. Para esto vamos a poner 8 LED en el puerto b, o sea, un led por cada bit del puerto.

Código: ASM
  1. DENUEVO   BSF      PORTB,RB0
  2.           CALL    T20
  3.           BCF      PORTB,RB0
  4.           BSF      PORTB,RB1
  5.           CALL    T20
  6.           BCF      PORTB,RB1
  7.           BSF      PORTB,RB2
  8.           CALL    T20
  9.           BCF      PORTB,RB2
  10.           BSF      PORTB,RB3
  11.           CALL    T20
  12.           BCF      PORTB,RB3
  13.           BSF      PORTB,RB4
  14.           CALL     T20
  15.           BCF      PORTB,RB4
  16.           BSF      PORTB,RB5
  17.           CALL    T20
  18.           BCF      PORTB,RB5
  19.           BSF      PORTB,RB6
  20.           CALL    T20
  21.           BCF      PORTB,RB6
  22.           BSF      PORTB,RB7
  23.           CALL    T20
  24.           BCF      PORTB,RB7
  25.           GOTO   DENUEVO
Hola, soy Hugo desde Montevideo, y estoy empezando con esto de programar PIC´S...  deseo hacer algo parecido a lo que este amigo quiere hacer...   un juego de luces tipo las ambulancias, donde los blocks de leds destellan diferenciados, por ejemplo que hagan dos destellos seguidos, espera un tiempo y destellan dos veces el otro block de leds, para volver a esperar...  y seguir asi indefinido...   me interesa poder cambiar esta configuracion por programación y lograr que destellen en algun momento simultaneamente ambos blocks de leds..  y volver a los destellos diferenciados...   bueno, no quiero ser pesado por demas...   FELICES FIESTAS !!!!!    ESPERO VUESTROS COMENTARIOS.


Título: Re:Destellador de Leds con PIC
Publicado por: goico en 17 de Julio de 2017, 02:16:48
Hola, soy un usuario nuevo y recién hace unos días me estoy iniciando en electrónica y programación de pics, visto que en este tema se buscaba un juego de luces y yo programe lo mejor que pude unas balizas estilo policía a mi gusto, comparto con uds mi trabajo ya que gracias a toda la gente que comparte cosas y ayuda en internet es que yo las pude realizar.
/* Balizas para moviles de Bomberos */

#include <16F84A.H>
#use DELAY (clock= 4000000)
#fuses NOWDT, XT
#USE standard_io(b)

void main()
{
    output_b(0b00000000);
   while(true)
   {
   if(input(pin_b0)==1)
   {
   delay_ms(50);
   if(input(pin_b0)==0)
   {
     for (int i=0; i<10; i++)
      {
      output_b(0b00000000);
      delay_ms(50);
      output_b(0b01111110);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms (50);
      }
      for (int a=0; a<10; a++)
      {
      output_b(0b00001110);
      delay_ms(50);
      output_b(0b00001110);
      delay_ms(50);
      output_b(0b00001110);
      delay_ms(50);
      output_b(0b01110000);
      delay_ms(50);
      output_b(0b01110000);
      delay_ms(50);
      output_b(0b01110000);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms(50);
      }
       for (int b=0; b<5; b++)
       {
      output_b(0b00000000);
      delay_ms(50);
      output_b(0b00011000);
      delay_ms(50);
      output_b(0b00111100);
      delay_ms(50);
      output_b(0b01111110);
      delay_ms(50);
      output_b(0b00111100);
      delay_ms(50);
      output_b(0b00011000);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms(50);
       }
       for (int c=0; c<5; c++)
       {
      output_b(0b00000000);
      delay_ms(50);
      output_b(0b01000010);
      delay_ms(50);
      output_b(0b00100100);
      delay_ms(50);
      output_b(0b00011000);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms(50);
      output_b(0b00011000);
      delay_ms(50);
      output_b(0b00100100);
      delay_ms(50);
      output_b(0b01000010);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms(50);
      output_b(0b01111110);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms(50);
       }
       for (int d=0; d<5; d++)
       {
       output_b(0b00000000);
      delay_ms(50);
      output_b(0b01000010);
      delay_ms(50);
      output_b(0b01100110);
      delay_ms(50);
      output_b(0b01111110);
      delay_ms(50);
      output_b(0b00000000);
      delay_ms(50);
       }
   }
   }
   }
}


Eso es lo mejor que pude hacer con mis conocimientos de unos días... cualquier mejora que se les ocurra sera agradecida, ya esta andando en proteus solo me falta hacer andar bien el pulsador, ya que cuando lo oprimo inicia pero solo un siclo y se detiene y en realidad tendría que seguir repitiéndolo hasta que lo vuelva a oprimir.
Aprovechando la situación si alguien sabe como hacer para conectar varios leds de 1w y 3v a cada salida(como la fuente es la batería de un vehículo se que seria armando una resistencia de 330Hm y 4 leds en serie uniéndolos en paralelo a otros grupos) Agradezco de antemano cualquier aporte ya que es lo que me falta para armar las balizas. Desde ya muchas gracias y espero que les sirva.
Título: Re:Destellador de Leds con PIC
Publicado por: KILLERJC en 17 de Julio de 2017, 12:25:34
Aca una pequeña mejora.

Código: C
  1. #include <16F84A.H>
  2. #use DELAY (clock= 4000000)
  3. #fuses NOWDT, XT
  4. #USE standard_io(b)
  5.  
  6. int1 activo=false;        //Este bit me va a indicar si debo o no ejecutar el programa
  7.  
  8. void main()
  9. {
  10.    output_b(0b00000000);
  11.    while(true)
  12.    {
  13.      if(input(pin_b0)==1)     //Tecla presionada?
  14.      {
  15.        delay_ms(100);          //Espero y Reviso de nuevo
  16.        if(input(pin_b0)==1)   // Sigue presionada?
  17.        {
  18.          activo ^= 1;         // Cambio el estado del bit activo.
  19.        }
  20.        while(input(pin_b0)==1);   //Espero que se suelte el boton, sino estaria activandose y desactivandose
  21.      }
  22.  
  23.      if(activo == true)
  24.        {
  25.          int i
  26.          for (i=0; i<10; i++)
  27.           {
  28.           output_b(0b00000000);
  29.           delay_ms(100);
  30.           output_b(0b01111110);
  31.           delay_ms(50);
  32.           }
  33.           for (i=0; i<10; i++)
  34.           {
  35.           output_b(0b00001110);
  36.           delay_ms(150);
  37.           output_b(0b01110000);
  38.           delay_ms(150);
  39.           output_b(0b00000000);
  40.           delay_ms(50);
  41.           }
  42.           for (i=0; i<5; i++)
  43.           {
  44.           output_b(0b00000000);
  45.           delay_ms(50);
  46.           output_b(0b00011000);
  47.           delay_ms(50);
  48.           output_b(0b00111100);
  49.           delay_ms(50);
  50.           output_b(0b01111110);
  51.           delay_ms(50);
  52.           output_b(0b00111100);
  53.           delay_ms(50);
  54.           output_b(0b00011000);
  55.           delay_ms(50);
  56.           output_b(0b00000000);
  57.           delay_ms(50);
  58.           }
  59.           for (i=0; i<5; i++)
  60.           {
  61.           output_b(0b00000000);
  62.           delay_ms(50);
  63.           output_b(0b01000010);
  64.           delay_ms(50);
  65.           output_b(0b00100100);
  66.           delay_ms(50);
  67.           output_b(0b00011000);
  68.           delay_ms(50);
  69.           output_b(0b00000000);
  70.           delay_ms(50);
  71.           output_b(0b00011000);
  72.           delay_ms(50);
  73.           output_b(0b00100100);
  74.           delay_ms(50);
  75.           output_b(0b01000010);
  76.           delay_ms(50);
  77.           output_b(0b00000000);
  78.           delay_ms(50);
  79.           output_b(0b01111110);
  80.           delay_ms(50);
  81.           output_b(0b00000000);
  82.           delay_ms(50);
  83.           }
  84.           for (i=0; i<5; i++)
  85.           {
  86.           output_b(0b00000000);
  87.           delay_ms(50);
  88.           output_b(0b01000010);
  89.           delay_ms(50);
  90.           output_b(0b01100110);
  91.           delay_ms(50);
  92.           output_b(0b01111110);
  93.           delay_ms(50);
  94.           output_b(0b00000000);
  95.           delay_ms(50);
  96.           }
  97.        }
  98.    }
  99. }

Los cambios son:
- no use una variable para cada uno de los for, con una sola variable es suficiente.
- Cree una nueva variable para indicar cuando es que debe ejecutarse la sirena, si observas bien, hay un if que es del boton y un if que es de la sirena, es decir estan totalmente separados, si necesitas cambiar el codigo del boton solo tocas el primer if, y no TODO el codigo. Esa fue la idea tras de esto.
- Borre algunos output_b y delays sin sentido, ya que tenian el mismo valor que antes, simplemente le agrande el delay, ejemplo si repetias 3 veces lo mismo, en ves de ponerle delay 50 y le puse 150.
- El boton tiene un antirebote realizado con delays, y recien actua cuando lo soltas. ya que el micro es demasiado rapido y sino estariamos teniendo suerte cuando es que queda en activo = true

Cosas a mejorar:
- Hay secuencias que se pueden mejorar
- Existe un problema incluso en mi codigo, y es que si queres parar la sirena tenes que tener presionado el boton en el momento que termina toda la secuencia. La solucion a esto seria usar interrupciones (por flanco ya que usas el RB0) de esa forma sea donde sea que este el programa procede a usar la interrupcion y cambiar el estado del flag activo.
- Cambiar, la forma en se hace la secuencia, tal ves usando tablas y arrays, asi te permite en cualquier momento salir de secuencia al detectarse que se desactivo el flag.
Título: Re:Destellador de Leds con PIC
Publicado por: goico en 19 de Julio de 2017, 02:58:43
muchas gracias por la mejora la voy a estar probando... respecto a la coneccion de los leds como puedo hacer para tirar muchos leds con ese mismo pic?
Título: Re:Destellador de Leds con PIC
Publicado por: KILLERJC en 19 de Julio de 2017, 10:43:25
Un PIC o cualquier integrado no manejan demasiada corriente, y si pones varios leds tampoco maneja mas que 5V, asi que lo que lo mas comun es utilizar un transistor NPN, por ejemplo esto es para un rele, que normalmente se maneja a 12V y tiene su consumo mas grande

(https://img.webme.com/pic/p/picmind/rele_pic.jpg)

En ves del rele podrias poner tus diodos leds.

Otra forma que es mas compacta, pero depende de la cantidad de corriente que pase por los mismos es utilizar un integrado que es el ULN2003A. Lo bueno es que no necesitas componentes externos ya que lo posee todo el integrado:

http://www.ti.com/lit/ds/symlink/ulq2003a.pdf

(https://i.stack.imgur.com/9gkWg.png)
Supone que el de la izquierda es tu PIC.

Lo malo es que necesitas un poco mas de tension de alimentacion.

Hilando un poco mas fino

El procedimiento es igual para ambos en la seccion de salida.

En la entrada, solo para cuando usas un transistor conectado de la forma que mostre, debes preocuparte por simplemente saturar el transistor, ya que estamos tratando de utilizarlo como un switch

Si usas una resitencia de 4.7K el PIC solo pondria 1mA sobre ese pin.

El ULN2003A ya posee resistencia interna asi que no te preocuparias.

Salida

Esta parte es la involucra la carga ( resistencia + led ). Y lo que mas hay que tener en cuenta es la caida minima de tension que puede dar el transistor, esto esta dado por Vce saturacion en los datasheet.
Siguiendo el ejemplo de antes. Deberia poder cumplirse que:

Código: [Seleccionar]
Valimentacion = Vled + Vtransistor + Vresistencia
//Igual a
Valimentacion = Vled + VceSat + Iled * R

Ejemplo : Si el led tiene 3V, y lo alimentamos con 5V el transistor deberia tener un Vce menor a 2V ( suponiendo nula la resistencia), el BC548A mirando su datasheet dice que su VceSat pra una Ic de 100mA es de 200mV a 600mV ( 0.2 a 0.6V ) lo cual este transistor va a servir. Ahora deberiamos calcular la resistencia. Suponemos una corriente de 120mA

Código: [Seleccionar]
Valimentacion = Vled + VceSat + I * R
5V = 3V + 0.2V + 120mA * R
R = 15ohms

Ahora si Usamos el ULN2003A como es un par de transistores ( conectados en darlington ) va a tener una mayor tension de VceSat.
Mirando el datasheet si observas el VceSat para 100mA es de 0.9 a 1.2V. Si hacemos el mismo ejemplo que antes

Código: [Seleccionar]
Valimentacion = Vled + VceSat + I * R
5V = 3V + 0.9V + 120mA * R
R = 9.16ohms

Utilizo el valor tipico y no el maximo, de esa forma si en ves de 0.9 ofrece 1.1V la corriente nunca es superior al limite que le dimos. Para proteger al led.

Si tenes otra tension de alimentacion, la resistencia sera distinta.

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

Si usas la interrupcion, esto te podria servir:

Código: C
  1. #include <stdint.h>
  2.  
  3.  
  4. struct DestelloLed
  5. {
  6.   uint8_t Cantidad;
  7.   uint8_t RepetirVeces;
  8.   const uint8_t * patron;
  9.   const uint8_t * delaypatron;
  10. };
  11.  
  12. // Patrones, todos
  13.  
  14. const uint8_t patron1[] = {0b00000000,0b01111110};   //10
  15. const uint8_t dpatron1[] = {100,50};   //10
  16. const uint8_t patron2[] = {0b00001110,0b01110000,0b00000000};   //10
  17. const uint8_t dpatron2[] = {150,150,50};   //10
  18. const uint8_t patron3[] = {0b00000000,0b00011000,0b00111100,0b01111110,0b00111100,0b00011000,0b00000000}; //5
  19. const uint8_t dpatron3[] = {50,50,50,50,50,50,50};   //5
  20. const uint8_t patron4[] = {0b00000000,0b01000010,0b00100100,0b00011000,0b00000000,0b00011000,0b00100100,0b01000010,0b00000000,0b01111110,0b00000000}; //5
  21. const uint8_t dpatron4[] = {50,50,50,50,50,50,50,50,50,50,50};   //5
  22. const uint8_t patron5[] = {0b00000000,0b01000010,0b01100110,0b01111110,0b00000000}; //5
  23. const uint8_t dpatron5[] = {50,50,50,50,50};   //5
  24.  
  25. // Estructuras con los patrones
  26.  
  27. const struct DestelloLed Spatron1 = {sizeof patron1,10,patron1,dpatron1};
  28. const struct DestelloLed Spatron2 = {sizeof patron2,10,patron2,dpatron2};
  29. const struct DestelloLed Spatron3 = {sizeof patron3,5,patron3,dpatron3};
  30. const struct DestelloLed Spatron4 = {sizeof patron4,5,patron4,dpatron4};
  31. const struct DestelloLed Spatron5 = {sizeof patron5,5,patron5,dpatron5};
  32.  
  33. const struct DestelloLed * Patrones[] =  {&Spatron1,&Spatron2,&Spatron3,&Spatron4,&Spatron5};
  34.  
  35. volatile int1 activo=1;
  36.  
  37. void main()
  38. {
  39.    while(1)
  40.    {
  41.        if(activo)
  42.        {
  43.            unsigned int i,j,k;
  44.             for(i=0;i < (sizeof Patrones/sizeof Patrones[0]);i++)
  45.             {
  46.                 for(j=0;j < Patrones[i]->RepetirVeces;j++)
  47.                 {
  48.                     for(k=0;k < Patrones[i]->Cantidad;k++)
  49.                     {
  50.                         if(!activo) break;
  51.                         output_b(Patrones[i]->patron[k]);
  52.                         delay_ms(Patrones[i]->delaypatron[k]);
  53.                     }
  54.                 }
  55.             }
  56.        }
  57.    }
  58. }

Solo decirte que te falta configurar la interrupcion, y crear la funcion de interrupcion que lo unico que haga es :

activo ^= 1;

Y listo.
En este codigo, Si queres modificar los patrones simplemente tenes que cambiar estos:

Código: C
  1. const uint8_t patron1[] = {0b00000000,0b01111110};   //10
  2. const uint8_t dpatron1[] = {100,50};   //10

Ejemplo, si quiero cambiar el delay del 0b00000000 a 70 quedaria asi:

Código: C
  1. const uint8_t patron1[] = {0b00000000,0b01111110};   //10
  2. const uint8_t dpatron1[] = {70,50};   //10

Si quiero agregarle 1 forma mas, agrego en ambos, el valor del puerto y ademas el delay:

Código: C
  1. const uint8_t patron1[] = {0b00000000,0b01111110,0b00011000};   //10
  2. const uint8_t dpatron1[] = {100,50,50};   //10


Si quiero agregar un patron totalmente nuevo, creo uno que se llame patron6 por ejemplo respetando que siempre dpatron6 tenga la misma cantidad de elementos.
Creo la estructura y finalmente lo agrego. La estructura se forma con la cantidad de elementos ( eso lo ahce solo el sizeof), las veces a repetirse y las direcciones del patron y su delay
Ejemplo, patron6 que se repita 7 veces:

Código: C
  1. const uint8_t patron6[] = {0b10101010,0b01010101};
  2. const uint8_t dpatron6[] = {50,50};
  3.  
  4. const struct DestelloLed Spatron6 = {sizeof patron6,7,patron6,dpatron6};
  5.  
  6. // Finalmente lo agrego al ultimo:
  7. const struct DestelloLed * Patrones[] =  {&Spatron1,&Spatron2,&Spatron3,&Spatron4,&Spatron5,&Spatron6};

Si queres cambiar solo el orden de los patrones, podes hacerlo simplemente modificando lo ultimo, ejemplo, que haga en este orden 4, 3, 1, 2 y 5

Código: C
  1. const struct DestelloLed * Patrones[] =  {&Spatron4,&Spatron3,&Spatron1,&Spatron2,&Spatron5};

PD: Este programa ocupa 20% del PIC16F84A
Me olvide decirte que si vas a usar un PIC, busques otro, porque el PIC16F84A es muy viejo y CARO, hay micros mucho mas baratos y mejores. Busca el que tenga los suficientes pines como para que puedas manejarte con esto donde sea que lo compres y de ahi empeza. Ya que tu proyecto no requiere demasiado micro
Título: Re:Destellador de Leds con PIC
Publicado por: goico en 21 de Julio de 2017, 20:55:50
Muchisimas Gracias por toda la info y enseñarle a un novato. El motivo de usar ese pic es que en todos los tutoriales para hacer balizas encontré ese y al ser nuevo en la electrónica tengo que tener un soporte teórico por así decirlo para poder lograr hacerlo. Si sabes de algún otro pic que se pueda utilizar para lograr esto mismo agradecería el aporte. Desde ya muchas gracias por tu tiempo invertido en aclarar dudas de este novato.
Título: Re:Destellador de Leds con PIC
Publicado por: KILLERJC en 21 de Julio de 2017, 21:55:10
Hay muchos modelos de PICs, cuando elegis un PIC empezas definiendo que modulos vas a necesitar y luego buscas uno acorde a lo que buscas, es decir buscas el micro respecto a tu proyecto, en este caso, solo necesitas que tenga pines. No hay requerimientos grandes de memoria, ni de datos ni de programa, tampoco hay requerimientos grandes de velocidad, ni tener varios modulos especificos.

Por eso mismo al final en negrita, te dije que consiguieras el mas barato posible ( con los suficientes pines ) que pudieras conseguir donde lo vayas a comprar. Tambien lo mas nuevos traen osciladores internos, lo cual no vas a necesitar de un cristal externo, y te va a simplificar la cantidad de cosas a poner.
Ejemplo si necesitas 2 entradas y 8 salidas, vas a tener 10 pines que son entrada/salida, por lo cual vas a buscar algun micro de 16 pines o mas que posea al menos 10 I/O.

Si queres micros para "probar" podrias comprar luego algun micro de 40 pines, asi (casi)nunca te vas a quedar sin pines con estos.

Solo para darte una idea..
Aca en Argentina, mirando el precio me encuentro con ( los clasicos ):
PIC16F84A-04/P 1.75KB Flash, 68 RAM, 13 I/O 18PDIP 3.32 dolares
PIC16F628A-I/P 3.5KB Flash, 224 RAM, 16 I/O 18PDIP 2.66 dolares Este posee el doble de memoria flash, mas RAM, mas modulos, oscilador interno y es mas barato

Algunos mas nuevos:
PIC16F1826-I/P 3.5KB Flash, 256 bytes RAM, 16 I/O 18PDIP 1.61 dolares

Como ves lo mas viejitos estan mucho mas caro, los precios estan sujetos a donde los compres mas que nada. Pero la diferencia es notable, no tiene sentido pagar casi el doble o triple por algo viejo y con menos prestaciones. Todos son de 18 pines