Mostrando entradas con la etiqueta programar. Mostrar todas las entradas

3/08/2013

Montar entorno de programación para Android con Eclipse en Windows 8

Cómo montar un entorno de desarrollo de aplicaciones para dispositivos smartphones y tables con Android usando el IDE de desarrollo Eclipse sobre un equipo con el sistema operativo Microsoft Windows 8 x64. Explicamos en este tutorial cómo preparar un entorno de programación de aplicaciones de forma muy rápida, descargando el Android SDK ADT Bundle for Windows, un kit con Eclipse y todo lo necesario para hacer aplicaciones para Android.

Requisitos para programar aplicaciones para Android en Windows 8

Equipo con Microsoft Windows 8

En primer lugar necesitaremos un equipo físico (o máquina virtual) con el sistema operativo Microsoft Windows 8 (válido para otros sistemas operativos de Microsoft). En los siguientes enlaces mostramos varios tutoriales para instalar Windows en equipos físicos y en equipos virtuales:

Java Runtime Environment (JRE)

Para que el IDE de desarrollo Eclipse funcione correctamente necesitaremos disponer en el equipo de JRE (Java Runtime Environment). Podremos descargar dicho componente gratuitamente desde la URL:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Elegiremos el instalable que se ajuste a la arquitectura de nuestro equipo y al sistema operativo, en nuestro caso, puesto que estamos instalando todo para 64 bits (x64) elegiremos Windows x64 (jdk-7u17-windows-x64.exe), instalaremos Java SE Developmen Kit que incluye Java Development Kit (JDK) y Java Runtime Environmen (JRE):

Java Development Kit (JDK) y Java Runtime Environment (JRE)

Ejecutaremos el fichero descargado para iniciar la instalación de JDK y JRE:

Si tenemos activado el UAC (Control de cuentas de usuario) en Windows 8 pulsaremos "Sï" a la pregunta de seguridad:

Se iniciará el asistente para instalar Java SE Deveolopment Kit, pulsaremos "Next":

Elegiremos los componentes a instalar (Developmen Tools, Source Code, Public JRE), la ubicación de los ficheros de instalación y pulsaremos "Next":

Elegiremos la carpeta donde se instalará JRE y pulsaremos "Next":

Una vez instalado JDK y JRE pulsaremos "Close" en el asistente de instalación:

En el caso de iniciar Eclipse sin tener instalado JRE mostrará este mensaje de error:

---------------------------
Eclipse
---------------------------
A Java Runtime Environment (JRE) or Java Development Kit (JDK)
must be available in order to run Eclipse. No Java virtual machine
was found after searching the following locations:
C:UsersajpdsoftDesktopadt-bundle-windows-x86_64-20130219adt-bundle-windows-x86_64-20130219eclipsejrebinjavaw.exe
javaw.exe in your current PATH
---------------------------
Aceptar
---------------------------

IDE de desarrollo Eclipse y Android SDK ADT Bundle

Para montar el entorno de desarrollo de forma rápida y sin tener que instalar prácticamente nada en nuestro equipo Windows 8 podremos descargar el Android SDK ADT Bundle for Windows desde el sitio web oficial:

http://developer.android.com/sdk/index.html

IDE de desarrollo Eclipse y Android SDK ADT Bundle

Dicho paquete contiene:

Eclipse.
ADT plugin para Eclipse.
Android SDK Tools.
Android Platform-tools.
Android platform.
Android system image for the emulator.

Leeremos los términos de licencia, si estamos de acuerdo marcaremos "I have read and agree with the adove terms and condicions, seleccionaremos "64-bit" en nuestro caso y pulsaremos "Download the SDK ADT Bundle for Windows":

Una vez descargado el fichero adt-bundle-windows-x86_64-20130219.zip lo descomprimiremos (en Windows 8 pulsando con el botón derecho del ratón sobre él y seleccionando "Extraer todo":

Copiaremos la carpeta extraída a la ubicación donde queramos que resida la aplicación, por ejemplo a C:/Eclipse. Ahora ya podremos ejecutar el IDE Eclipse con todo lo necesario para desarrollar aplicaciones para Android, ejecutando el fichero "eclipse.exe":

Si el JRE está correctamente instalado se iniciará el IDE Eclipse con Android Developer Tools:

En el primer inicio nos solicitará la carpeta para el espacio de trabajo (Workspace). Indicaremos la carpeta y pulsaremos "OK":

Si queremos enviar estadísticas de uso anónimas a Google pulsaremos "Yes", en caso contrario pulsaremos "No":

Es recomendable actualizar el IDE Eclipse a la última versión, para ello pulsaremos en el menú "Help" - "Check for Updates":

Para actualizar Android SDK y para instalar nuevos componentes pulsaremos en el menú "Windows" - "Android SDK Manager":

Elegiremos los componentes a instalar y los que queramos actualizar y pulsaremos "Install packages":

Si algún paquete requiere de aceptación de términos de licencia nos lo indicará, en nuestro caso hemos instalado "Samples for SDK API 17, revision 1", "Google AdMob Ads SDK, revision 9", "Google USB Driver, revision 7" y "Google Web Driver, revision 2". Marcaremos "Accept License" y pulsaremos "Install":

Agregar dispositivo virtual Android Virtual Device en Eclipse

Agregaremos también un dispositivo virtual (Android Virtual Device) que será el que usemos para ejecutar las aplicaciones en desarrollo y ver cómo quedan y cómo funcionan. De esta forma no necesitaremos estar pasando la aplicación contínuamente a un dispositivo smartphone físico con Android, podremos realizar las compilaciones que queramos en el dispositivo virtual que, a todos los efectos, es similar al físico. Para agregar un nuevo dispositivo virtual pulsaremos en el menú "Window" - "Android Virtual Device Manager":

En la pestaña "Android Virtual Device" pulsaremos en "New":

Elegiremos las características del dispositivo virtual (nombre, device, tipo de CPU, teclado, memoria RAM, tarjeta de memoria, etc.:

Ya tendremos creado el dispositivo virtual que podremos usar para probar nuestras aplicaciones las veces que necesitemos.

Mi primera aplicación para Android desde Windows 8 con Eclipse

Una vez descargado e instalado Eclipse y los componentes que necesita podremos crear aplicaciones para dispositivos Android. Para crear la aplicación "Hola mundo" abriremos Eclipse, pulsaremos en el menú "File" - "New" - "Android Application Project":

Introduciremos los datos para la nueva aplicación Android, en nuestro caso crearemos la típica aplicación "Hola mundo":

Indicaremos si queremos crear un icono personalizado y la activity:

Indicaremos las propiedades del icono (o el texto) y fondo de nuestra aplicación Android:

Si queremos que el asistente nos cree una activity inicial para nuestra aplicación marcaremos "Create Activity" e indicaremos el tipo de activity (Blan Activity, Fullscreen Activity, Master/Detail Flow"). En nuestro caso puesto que estamos simplificando al máximo el proceso de creación de una aplicación Android dejaremos "Blank Activity" y pulsaremos "Next":

Indicaremos el nombre para la activity, el nombre del Layout y el tipo de navegación (dejaremos "None"):

El asistente nos creará toda la estructura base de nuestra aplicación Android (activity, Layout, ficheros .java, etc.). Ahora podremos compilarla directamente y mostrarla en nuestro dispositivo virtual. Para ello seleccionaremos la carpeta de nuestra aplicación en el árbol de exploración de la izquierda y pulsaremos en el menú "Run" - "Run As" - "Android Application":

Una vez arrancado el dispotivo Eclipse instalará la aplicación en él de forma automática y podremos testearla como si de un dispositivo Android físico se tratase:

Créditos

Artículo realizado íntegramente por Alonsojpd miembro fundador del Proyecto AjpdSoft.

Artículo en inglés.

2/26/2013

Programación del Bootloader a Arduino

Programación de Bootloader para Arduino Uno, Mega, Nano, Micro y cualquier modelo. En nuestro caso hemos usado para realizar el tutorial Arduino Nano.

¿Por qué programar el bootloader de Arduino?

El motivo de la programación del Bootloader es que realizaremos un pedido de Arduino Nano nos llegó sin el bootloader programado. Tras buscar por multitud de sitios web hemos comprobado que existe información al respecto pero muy poca en castellano y prácticamente ninguna en modo tutorial y ninguna para nuestro programador.

Así pues a continuación explicamos paso a paso y con capturas de pantalla cómo programar el bootloader de Arduino.

Requisitos para programar el bootloader de Arduino

Arduino

Necesitaremos obviamente disponer de un Arduino, en nuestro caso usaremos Arduino Nano:

Programador ISP con cable de 10 pines

El programador ISP para el Atmel Atmega328 que lleva nuestro Arduino Nano es un “USBASP ISP Programmer”:

Que incorpora un cable de 10 pines y que pedimos por eBay por menos de 5€:

El programador se conecta al Arduino a través de el conector ICSP, que en nuestro caso no lleva los pines del ICSP soldados como mostramos en las imágenes anteriores. A continuación mostramos los esquemas de conexiones del conector ICSP tanto del Arduino:

Como la del conector de 10 pines de nuestro programador:

Puesto que el conector del programador no coincide con el conector ICSP del Arduino deberemos hacer las siguientes conexiones:

Para ello lo más cómodo es hacer uso de cables de placa de prototipos también conocidos con el termino en inglés cables Breadboard:

A continuación mostramos algunas imágenes de como se queda la conexión, en ellas se pueden ver como el no tener los pines soldados en el conector ICSP nos ha simplificado la tarea, en caso contrario hubiésemos necesitado otro conector o siendo más drásticos habríamos tenido que cortar el cable del programador y unir de nuevo los cables de modo que ya coincidan con el conector de nuestro Arduino:

IDE de desarrollo para Arduino

Además del Arduino y del programador con los conectores necesitaremos también disponer de un PC con el IDE de Arduino. En el siguiente tutorial explicamos cómo instalarlo paso a paso:

Instalación software IDE de desarrollo y controladores para conectar Arduino con un PC con Windows 7.

En este tutorial explicamos cómo programar el bootloader de Arduino desde un PC con sistema operativo Linux, aunque el proceso es muy similar para el caso de un equipo con Windows.

Programar el bootloader de Arduino

Una vez realizadas las conexiones como hemos indicado anteriormente conectaremos el programador ISP al PC y arrancaremos el IDE del Arduino, con el superusuario “root” en caso de utilizar el sistema operativo Linux, para la programación del bootloader (que es nuestro caso), para ello utilizaremos el comando Linux “gksu” que arranca aplicaciones como superusuario. A continuación mostramos como quedaría el acceso directo (o lanzador) del IDE del Arduino:

Si no abrimos el IDE de Arduino como superusuario root puede que muestre este error al intentar transferir el bootloader:

Con el texto:

Error al grabar la secuencia de inicio.
avrdude: error: could not find USB device "USBasp" with vid=0x16c0 pid=0x5dc.

Para Linux (que es nuestro caso) y Mac OS no es necesaria la instalación de drivers, para Windows es posible que requiera la instalación de drivers.

Puesto que el IDE de Arduino incorpora la herramienta para la programación del bootloader, simplemente le indicaremos qué placa es la que queremos programar, desde el menú "Herramientas"- "Tarjeta" - "Arduino Nano w/ATmega328" (en nuestro caso) :

Indicaremos también cual es el programador que estamos usando desde el menú "Herramientas" - "Programador" - "USBasp" (en nuestro caso):

Una vez seleccionada la tarjeta y el programador pulsaremos en el menú "Herramientas" - "Grabar Secuencia de Inicio":

Si los conectores y el programador son correctos el IDE de Arduino nos indicará que se está grabando la secuencia de inicio en la Tarjeta I/O:

Tras finalizar el proceso de transferencia del bootloader a Arduino, el IDE nos lo indicará:

Nota: puede que muestre algún warning, suelen ser normales, el IDE mostrará este texto tras finalizar el proceso de carga del bootloader:

Finalizada la grabación de la secuencia de inicio
avrdude: warning: cannot set sck period. please check for usbasp
firmware update.

Tras haber programado el Arduino Nano con su Bootloader, ya podemos desconectar el programador del PC y los cables del Arduino.

Por último, para comprobar que el bootloader se ha programado correctamente podemos simplemente conectar el Arduino a nuestro PC y descargarle cualquier programa, como por ejemplo el que hace parpadear el LED y ver que efectivamente parpadea correctamente. En el siguiente tutorial explicamos paso a paso cómo conectar un LED a Arduino y cómo hacerlo parpadear:

Primer proyecto hardware con Arduino, encender un LED.

Créditos

Artículo realizado íntegramente por Antonio RN de RS miembro del Proyecto AjpdSoft.

Artículo en inglés.

1/02/2013

Programar reinicio automático Windows Server 2003

10/13/2011

Obtener temperatura y humedad con Arduino

Explicamos en este proyecto hardware cómo conectar un sensor de temperatura y humedad a Arduino UNO. Indicamos cómo visualizar los valores en el propio IDE de desarrollo de Arduino (usando la ventana de Serial Monitor). Mostramos también cómo guardar los valores obtenidos en la memoria EEPROM de Arduino.

Requisitos para proyecto hardware con Arduino y sensor de temperatura y humedad

Para realizar un proyecto hardware para obtener la temperatura y humedad usando Arduino UNO necesitaremos los siguientes componentes:

Arduino UNO:

Requisitos para proyecto hardware con Arduino y sensor de temperatura y humedad

Sensor de temperatura y humedad, en nuestro caso usaremos un Twig Temp&Humi Sensor SEN11301P.

Cable para conectar sensor con Arduino, en nuestro caso, este cable lo hemos obtenido de un clabe del audio de un lector de CD. El sensor de temperatura y humedad requiere de un cable de cuatro hilos: GND, VCC, NC y SIG. Aunque el hilo del NC no se usa:

En el siguiente artículo explicamos cómo conectar Arduino a un PC, cómo compilar un programa y cómo enviarlo al Arduino. Explicamos también cómo instalar el IDE de desarrollo de Arduino:

Primer proyecto hardware con Arduino, encender un LED

Conexión de sensor de temperatura y humedad con Arduino UNO

Para realizar la conexión del sensor de temperatura y humedad con el Arduino UNO, en primer lugar insertaremos el conector hembra del cable al zócalo a tal efecto del sensor, como mostramos en la siguiente imagen:

En la parte del sensor de temperatura, para conectarlo al Arduino, en nuestro caso hemos usado un cable que contiene tres hilos: uno rojo que va al SIG (datos), otro blanco que va al VCC (alimentación) y otro negro que va al GND (masa). El conector NC no se usa por lo que no necesita cable. Es importante tener bien identificado cada hilo para conectarlo en su pin correspondiente del Arduino:

En la parte del Arduino UNO conectaremos el cable rojo (SIG) al pin A0 analógico, como se muestra en la imagen:

El cable blanco (VCC) lo conectaremos al ping 5V, el de alimentación, como se muestra en la imagen:

Y el cable negro (GND) lo conectaremos a cualquier de los pines GND del Arduino (en la imagen el cable del medio, que en su origen era negro y en este extremo está "pelado"):

El sensor de temperatura y humedad conectado al Arduino UNO quedará como mostramos en la imagen:

Por supuesto, podríamos haber usado un cable específico y una placa prototipo para realizar la conexión del sensor con Arduino, aunque para el ejemplo que nos ocupa no es necesario.

Enviar programa para obtener temperatura y humedad a Arduino y testear resultado

Una vez conectado el sensor de temperatura y humedad a Arduino UNO, el siguiente paso será realizar un programa que obtenga los valores de temperatura y humedad y los muestre por el puerto serie, de esta forma podremos testear y verificar que el hardware (sensor y Arduino) funcionan correctamente.

Instalaremos los drivers necesarios, instalaremos el IDE de desarrollo de Arduino y conectaremos Arduino al PC por el puerto USB, como indicamos aquí:

Instalación software IDE de desarrollo y controladores para conectar Arduino con un PC con Windows 7

A continuación escribiremos el siguiente programa:

#define DHT11_PIN 0      // ADC0

byte read_dht11_dat()
{
  byte i = 0;
  byte result=0;
  for(i=0; i< 8; i++)
  {
    while(!(PINC & _BV(DHT11_PIN)));  // wait for 50us
    delayMicroseconds(30);

    if(PINC & _BV(DHT11_PIN)) 
      result |=(1<<(7-i));
    while((PINC & _BV(DHT11_PIN)));  // wait '1' finish
  }
  return result;
}

void setup()
{
  DDRC |= _BV(DHT11_PIN);
  PORTC |= _BV(DHT11_PIN);

  Serial.begin(9600);
  Serial.println("Ready");
}

void loop()
{
  byte dht11_dat[5];
  byte dht11_in;
  byte i;
  // start condition
  // 1. pull-down i/o pin from 18ms
  PORTC &= ~_BV(DHT11_PIN);
  delay(18);
  PORTC |= _BV(DHT11_PIN);
  delayMicroseconds(40);

  DDRC &= ~_BV(DHT11_PIN);
  delayMicroseconds(40);

  dht11_in = PINC & _BV(DHT11_PIN);

  if(dht11_in)
  {
    Serial.println("dht11 start condition 1 not met");
    return;
  }
  delayMicroseconds(80);

  dht11_in = PINC & _BV(DHT11_PIN);

  if(!dht11_in)
  {
    Serial.println("dht11 start condition 2 not met");
    return;
  }
  delayMicroseconds(80);
  // now ready for data reception
  for (i=0; i<5; i++)
    dht11_dat[i] = read_dht11_dat();

  DDRC |= _BV(DHT11_PIN);
  PORTC |= _BV(DHT11_PIN);

  byte dht11_check_sum = dht11_dat[0]+dht11_dat[1]+dht11_dat[2]+dht11_dat[3];
  // check check_sum
  if(dht11_dat[4]!= dht11_check_sum)
  {
    Serial.println("DHT11 checksum error");
  }

  Serial.print("Humedad = ");
  Serial.print(dht11_dat[0], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[1], DEC);
  Serial.print("%  ");
  Serial.print("Temperatura = ");
  Serial.print(dht11_dat[2], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[3], DEC);
  Serial.println("C  ");

  delay(2000);
}

Lo compilaremos para verificar que la sintaxis del código C++ es correcta, para ello pulsaremos el botón "Verify". Si el código es correcto devolverá "Done compiling", si hay algún error en el código lo indicará:

Enviar programa para obtener temperatura y humedad a Arduino y testear resultado

Una vez verificado el código pulsaremos en el botón "Upload" para enviar el programa a Arduino UNO. Si Arduino está correctamente conectado al PC por el puerto USB, el programa será subido y el IDE de Arduino mostrará "Done uploading"

Para testear el programa que hemos enviado a Arduino, abriremos la ventana de Serial Monitor del IDE de Arduino, pulsando en el botón "Serial Monitor":

Si tenemos correctamente conectado el sensor de temperatura y humedad a Arduino y si el programa enviado es correcto, nos devolverá la humedad y temperatura actuales a la ventana de puerto serie:

Guardar resultados de temperatura y humedad en EPROM de Arduino

En Arduino el EEPROM es un espacio de memoria que puede ser utilizada por los programadores para almacenar información a largo plazo. Esta memoria es no volátil, por lo tanto aunque dejemos de alimentar eléctricamente Arduino los valores de esta memoria seguirán estando almacenados. En el siguiente artículo mostramos más información sobre el tipo de memorias del chip de Arduino y sobre para qué sirven y cómo usarlas:

Tipos de memoria en el microcontrolador de Arduino, Flash, SRAM y EEPROM

Modificaremos el programa anterior que obtiene la temperatura y humedad usando el sensor Twig Temp&Humi Sensor SEN11301P para guardar los valores obtenidos en la memoria EEPROM interna de Arduino UNO (con capacidad para 1024 valores):

#define DHT11_PIN 0      // ADC0

//Para EEPROM
#include  
int addr = 0;

int repeticiones = 0;

byte read_dht11_dat()
{
  byte i = 0;
  byte result=0;
  for(i=0; i< 8; i++)
  {
    while(!(PINC & _BV(DHT11_PIN)));  // wait for 50us
    delayMicroseconds(30);

    if(PINC & _BV(DHT11_PIN)) 
      result |=(1<<(7-i));
    while((PINC & _BV(DHT11_PIN)));  // wait '1' finish
  }
  return result;
}

void setup()
{
  //para encender el LED de Arduino
  pinMode(13, OUTPUT);
  
  //para el sensor de temperatura y humedad
  DDRC |= _BV(DHT11_PIN);
  PORTC |= _BV(DHT11_PIN);

  //para iniciar el puerto serie, para las comunicaciones
  Serial.begin(9600);
  Serial.println("Iniciando lectura de datos...");
}

void loop()
{
  byte dht11_dat[5];
  byte dht11_in;
  byte i;
  int val = analogRead(0) / 4; //para EEPROM
  
  // start condition
  // 1. pull-down i/o pin from 18ms
  PORTC &= ~_BV(DHT11_PIN);
  delay(18);
  PORTC |= _BV(DHT11_PIN);
  delayMicroseconds(40);

  DDRC &= ~_BV(DHT11_PIN);
  delayMicroseconds(40);

  dht11_in = PINC & _BV(DHT11_PIN);

  if(dht11_in)
  {
    Serial.println("dht11 start condition 1 not met");
    return;
  }
  delayMicroseconds(80);

  dht11_in = PINC & _BV(DHT11_PIN);

  if(!dht11_in)
  {
    Serial.println("dht11 start condition 2 not met");
    return;
  }
  delayMicroseconds(80);
  // now ready for data reception
  for (i=0; i<5; i++)
    dht11_dat[i] = read_dht11_dat();

  DDRC |= _BV(DHT11_PIN);
  PORTC |= _BV(DHT11_PIN);

  byte dht11_check_sum = dht11_dat[0]+dht11_dat[1]+dht11_dat[2]+dht11_dat[3];
  // check check_sum
  if(dht11_dat[4]!= dht11_check_sum)
  {
    Serial.println("DHT11 checksum error");
  }

  //guardaremos los valores de humedad y temperatura
  //cada 10 minutos aproximadamente
  //Si tenemos 1024 valores y usamos dos por cada captura
  //uno para la humedad y otro para la temperatura
  //tendremos espacio en memoria EEPROM para dos días aproximadamente
  repeticiones = repeticiones + 1;
    
  if (repeticiones == 10)
  {
    //guardar valores en EEPROM
    Serial.print("Guardando valores en EEPROM");
    Serial.println(" ");
    EEPROM.write(addr, dht11_dat[0]); //humedad
    addr = addr + 1;
    EEPROM.write(addr, dht11_dat[2]); //temperatura
    addr = addr + 1;
    repeticiones = 0;
    if (addr == 1024)
    {
      addr = 0;
      Serial.print("EEPROM llena, se reescribirá...");
      Serial.println(" ");
      digitalWrite(13, HIGH);   // encendemos el LED para avisar
      delay(3000);              // esperamos tres segundos
      digitalWrite(13, LOW);    // apagamos el LED
    }  
  }
  
  //enviar valores a puerto serie para depuración
  Serial.print("Humedad = ");
  Serial.print(dht11_dat[0], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[1], DEC);
  Serial.print("%  ");
  Serial.print("Temperatura = ");
  Serial.print(dht11_dat[2], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[3], DEC);
  Serial.println("  ");

  //esperamos un minuto
  delay(60000);
}

Créditos

Artículo realizado íntegramente por Alonsojpd miembro fundador del Proyecto AjpdSoft.

Artículo en inglés.

3/08/2013

Montar entorno de programación para Android con Eclipse en Windows 8

Requisitos para programar aplicaciones para Android en Windows 8

Equipo con Microsoft Windows 8

Java Runtime Environment (JRE)

IDE de desarrollo Eclipse y Android SDK ADT Bundle

Agregar dispositivo virtual Android Virtual Device en Eclipse

Mi primera aplicación para Android desde Windows 8 con Eclipse

Artículos relacionados

Créditos

2/26/2013

Programación del Bootloader a Arduino

¿Por qué programar el bootloader de Arduino?

Requisitos para programar el bootloader de Arduino

Arduino

Programador ISP con cable de 10 pines

IDE de desarrollo para Arduino

Programar el bootloader de Arduino

Artículos relacionados

Créditos

1/02/2013

Programar reinicio automático Windows Server 2003

10/13/2011

Obtener temperatura y humedad con Arduino

Requisitos para proyecto hardware con Arduino y sensor de temperatura y humedad

Conexión de sensor de temperatura y humedad con Arduino UNO

Enviar programa para obtener temperatura y humedad a Arduino y testear resultado

Guardar resultados de temperatura y humedad en EPROM de Arduino

Artículos relacionados

Créditos

Etiquetas