Autor Tema: Destellador de Leds con PIC  (Leído 8329 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado firepic

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1130
    • JC Servicios
Re: Destellador de Leds con PIC
« Respuesta #15 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:
"Por la presunción solo se ocasiona una lucha, pero con los que consultan juntos hay sabiduría" (Proverbios 13:10).
Visita Mi Sitio Web

Desconectado arenita

  • PIC10
  • *
  • Mensajes: 1
Re: Destellador de Leds con PIC
« Respuesta #16 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

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1339
Re: Destellador de Leds con PIC
« Respuesta #17 en: 07 de Mayo de 2013, 02:26:30 »
No se si reírme o llorar =D

Desconectado pucara

  • PIC10
  • *
  • Mensajes: 8
Re: Destellador de Leds con PIC
« Respuesta #18 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.

Desconectado pucara

  • PIC10
  • *
  • Mensajes: 8
Re: Destellador de Leds con PIC
« Respuesta #19 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
  26.  
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.



Desconectado goico

  • PIC10
  • *
  • Mensajes: 3
Re:Destellador de Leds con PIC
« Respuesta #20 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.

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 6116
Re:Destellador de Leds con PIC
« Respuesta #21 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.

Desconectado goico

  • PIC10
  • *
  • Mensajes: 3
Re:Destellador de Leds con PIC
« Respuesta #22 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?

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 6116
Re:Destellador de Leds con PIC
« Respuesta #23 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



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


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
« Última modificación: 19 de Julio de 2017, 12:00:02 por KILLERJC »

Desconectado goico

  • PIC10
  • *
  • Mensajes: 3
Re:Destellador de Leds con PIC
« Respuesta #24 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.

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 6116
Re:Destellador de Leds con PIC
« Respuesta #25 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
« Última modificación: 21 de Julio de 2017, 22:09:12 por KILLERJC »


 

anything