Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Seguir
DATOS PERSONALES
TutorialesFjp
Ver todo mi perfil
1.2.- Desde el Administrador crearemos un nuevo proyecto, para ello haremos clic en el icono nuevo.
En la ventana nueva que nos aparece rellenaremos el nombre del proyecto, también podemos crear
una ubicación para nuestro proyecto o dejar la ruta por defecto.
1.3.- Una vez creada la carpeta curso nos situaremos encima y con el botón derecho seleccionaremos
"insertar nuevo objeto" > "SIMATIC 300"
1.4.- Una vez creado el sistema haremos doble clic en el Hardware.
En la configuración del hardware se determinan la CPU y todos los módulos contenidos en su sistema
de automatización, utilizando para ello un catálogo de hardware.
1.5.- Una vez dentro del Configurador de Hardware procederemos a montar nuestro PLC, para ello lo
primero que tenemos que insertar es un bastidor.
Un bastidor 300 es un perfil standard, que utiliza Siemens para sujetar sus tarjetas de Simatic 300
1.6.- Después de configurar el bastidor tenemos que empezar a definir las tarjetas que queremos
montar en el.
La primera tarjeta que insertaremos será una fuente de alimentación. Nos desplazamos por el árbol de
la librería y buscaremos un módulo PS-300
1.7.- Configuración de la CPU.
Nos desplazamos por el árbol de la librería y buscaremos un módulo CPU-300, nosotros para las
pruebas insertaremos en el módulo 2 una CPU 315-2 DP.
En cuanto arrastremos la CPU al chasis nos aparecerá un menú donde nos permitirá elegir varias
opciones pero nosotros las dejaremos por defecto aceptándolo.
1.8.- Seguimos definiendo tarjetas, ahora vamos a insertar una tarjeta de entrada digitales, estas
tarjetas las encontraremos en la carpeta DI-300.
1.9.- Para nuestras pruebas de esta curso vamos a utilizar salidas digitales para ello insertaremos una
tarjeta, la buscamos en la carpeta DO-300.
1.10.- Una vez añadidas las tarjetas de entras y salidas cambiaremos las direcciones que por defecto
nos ha puesto. Para ello haremos doble clic sobre las direcciones para abrir el menú propiedades,
seleccionado la pestaña "direcciones" y quitando la pestaña estándar podremos cambiar la dirección.
El configurador nos generara una estructura con unas carpetas de fuentes y bloques, dentro de estas
carpetas nosotros programaremos nuestros bloques.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 2
2.2.- Bloques de organización. Los bloques de organización (OB) constituyen un enlace entre el sistema
operativo y el programa de usuario. Son llamados por el sistema operativo y controlan el procesamiento
cíclico y controlado por alarmas del programa, el comportamiento de arranque del sistema de
automatización y el tratamiento de los errores. Programando los bloques de organización se define el
comportamiento de la CPU.
Insertaremos varios bloques (p.ej.OB32,OB82 y OB121), estos bloques están establecidos por el
sistema con lo que no hace falta ponerles ni símbolo ni comentario, ya que lo define el sistema.
Los bloques de función son bloques programables. Un FB es un bloque "con memoria". Dispone de un
bloque de datos asignado como memoria (bloque de datos de instancia). Los parámetros que se
transfieren al FB, así como las variables estáticas, se memorizan en el DB de instancia. Las variables
temporales se memorizan en la pila de datos locales. Los datos memorizados en el DB de instancia no
se pierden al concluir el tratamiento del FB. Los datos memorizados en la pila de datos locales se
pierden al concluir el tratamiento del FB.
En estos bloques si definiremos el símbolo y el comentario, ya que nos ayudara a la búsqueda posterior
de nuestro programa.
En todos los bloques menos en los OBs mencionados en el apartado anterior, deberíamos rellenar su
símbolo y comentario.
2.6.- Los tipos de datos de usuario (UDT) son estructuras de datos creadas por usted mismo y que, una
vez definidas, pueden utilizarse en todo el programa de usuario S7 de dos formas:
2.8.- Después de crear los bloques definidos en los apartados anteriores deberíamos tener en la
ventada derecha del configurador lo siguiente.
2.8.- Editor de símbolos
Con el editor de símbolos se gestionan todas las variables globales. Se definen los nombres simbólicos
y comentarios para las señales del proceso (entradas y salidas), las marcas y los bloques.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 3.1
1. - Introducción
Las operaciones lógicas con bits operan con dos dígitos, 1 y 0. Estos dos dígitos crean un sistema
numérico denominado sistema binario.
En el entorno de los contactos y bobinas, un 1 significa activado (conduce) y un 0 significa desactivado
("no conduce").
Símbolos habituales
Las CPUs de Siemens trabajan en byte, con lo cual cada dirección podra definirse de 0 a 7 bits.
• Activación de bobina
En este ejemplo trabajaremos con un interruptor, un interruptor se mantiene enclavado una vez
presionado.
Lo que quiere decir que la salida quedara activada mientras no se vuelva a presionar en el otro sentido.
Un interruptor es como los que tenemos en casa, que tiene dos posiciones que se quedan enclavadas
manteniendo la luz apagada o encendida según la posición
Ingeniería
Ingeniería
Función OR (O)
Activando cualquiera de las entradas a 1 la salida se active.
Ingeniería
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 3.2
Símbolos habituales
3. Ejemplos
Ingeniería
• Activación de bobina
En este ejemplo se activara la bobina cuando se pulsa S1 y se deja sin pulsar el S2.
Si pulsamos también el S2, la bobina no se activará ya que hemos abierto el circuito.
Cuando la bobina se activa a través del Set permanece memorizada hasta que se ejecute un 1 en el
Reset.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 4.1
1. - Introducción
Las comparaciones comparar entre dos valores numéricos, según las operaciones siguientes:
x == y ( x es igual a y )
x <> y ( x no es igual a y )
x < y ( x es menor que y )
x > y ( x es mayor que y )
x <= y ( x es menor o igual que y )
x >= y ( x es mayor o igual que y )
5. Para las entradas de las comparaciones podemos utilizar los siguientes tipos de datos byte, Word,
doble Word y Reales y el resultado da la comparación es un digito binario (Bool).
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 4.2
1. - Introducción
El nivel analógico lo leemos en la dirección EW20, esta entrada hay que convertirla de unidades
internas a %, pero como todavía no hemos visto las conversiones analógicas, trabajaremos
directamente en %.
Marcha bomba
No dejaremos arrancar la bomba mientras el nivel no supere el 20%
Paro bomba
Pararemos la bomba si el nivel baja por debajo del 5%
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 5
• S5TIME#xH_xM_xS_xMS
Ejemplos:
2. – Diferentes tipos
3. – Parámetros
4. – Descripción y ejemplos
La salida del temporizado se activa en cuando se activa la entrada de arranque S, la salida estará activa
mientras transcurra el tiempo predeterminado.
La salida del temporizado se activa transcurrido el tiempo predeterminado cuando hay un flanco de
activación de la entrada de arranque S, aunque el estado de señal en la entrada S se ponga a "0" el
temporizador continúa en marcha durante el tiempo predeterminado.
• Temporizado retardo conexión
La salida del temporizado se activa transcurrido el tiempo predeterminado cuando permanece activa la
entrada de arranque S.
La salida del temporizado se activa transcurrido el tiempo predeterminado cuando hay un flanco de
activación de la entrada de arranque S. La salida permanecerá memorizada hasta que se active la
entrada R.
La salida del temporizado se activa cuando hay un flanco de activación de la entrada de arranque S. La
salida permanecerá memorizada hasta que transcurra el tiempo predeterminado..
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 6
TRABAJAR CON BLOQUES DE DATOS (DBs)
Los bloques de datos, también llamados DB’s, son áreas donde se almacenan datos. Un DB no
contiene instrucciones S7.
Hay dos tipos de bloques de datos:
• Bloques de datos globales: A sus datos pueden acceder todos los bloques.
• Bloques de datos de instancia: Asociados a un bloque de función FB.
Dirección:
Indica la dirección que STEP 7 asigna automáticamente a la variable al terminar de introducir
una declaración.
Nombre:
Se asigna el nombre a cada variable.
Tipo:
Introduzca el tipo de datos de la variable (BOOL, INT, WORD, ARRAY, etc.). Las variables
pueden pertenecer a los tipos de datos simples, a los tipos de datos compuestos, o bien, a los
tipos de datos de usuario.
Valor inicial:
Indique el valor inicial, en caso de que el software no deba tomar el valor predeterminado del
tipo de datos introducido. Todos los valores introducidos deben ser compatibles con los tipos de
datos.
Cuando guarde por primera vez el bloque de datos, el valor inicial será adoptado como valor
actual de la variable, a menos que defina expresamente su valor actual.
Recuerde que los valores iniciales no pueden cargarse en la CPU.
Comentario:
En este campo puede introducir un comentario para documentar la variable. El comentario no
debe tener más de 80 caracteres.
Datos Simples
Datos compuestos:
6.4- Ejemplo de Bloques de datos
Prepararemos una serie de bloques de datos para comunicar con el WinCC Flexible
• En esta primera tabla una serie de bits de tipo booleanos, para las solicitudes que dibujemos en las
pantallas (DB1)
• Para las indicaciones analógicas de valores con decimales, se prepara esta tabla con variables de tipo
real.
• Lo mismo hacemos con las consignas que vamos a dibujar para introducir datos desde HMI(Wincc
Flexible) al PLC.
• Por ultimo vamos a preparar esta tabla con variables de tipo enteros(INT).
Estas variables las utilizaremos para las condiciones de diferentes sistemas.(Bombas, electroválvulas,
secuencias, etc)
DB1.DBX0.0
Con esta consulta accedemos a DB1 a la dirección 0.0, que corresponde a la marcha alimentación
bomba 1.
DB2.DBX0.0
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 7
7.1.1.- Introducción
7.1.2.- Pantallas
Pantalla Hidráulico
Pantalla Condiciones
7.1.3.- Desarrollo del PLC
Lo primero que tenemos que hacer es rellenar la tabla de símbolos y las DBs de comunicaciones con el
WinCC Flexible.
Tabla de símbolos:
Nota: pinchar en las tablas para agrandarlas
Tabla de datos:
En la DB1 rellenaremos todas las solicitudes para arrancar y parar las bombas.
En la DB2 rellenaremos todas las indicaciones que vamos a poner en la pantalla del hidráulico.
En esta parte no rellenaremos las indicaciones de las condiciones ya que vamos a preparar otra DB
para esta labor.
En la DB3 la utilizaremos para las dos indicaciones de forma analógica, que son la temperatura y el
nivel.
En la DB5 rellenaremos todas las indicaciones que vamos a poner en la pantalla de condiciones.
La vamos a tratar como un integer para desglosar bit a bit cada condición
Crearemos una función (FC10), donde prepararemos el programa para el control de la bomba 1 de
alimentación
Las condiciones tienen que estar a 1, solo con perder cualquiera de ellas perderemos el resumen e
inmediatamente pararemos la bomba
1.- Si el nivel del tanque es muy bajo, para que la condición sea 1, compararemos el nivel para que sea
mayor de 5%
2.- La temperatura del aceite tiene que ser menor de 90ºC.
3.- Que no tengamos fallo del automático.
4.- Que no perdamos la presión.
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 7.2
7.2.Desarrollo del PLC Parte II
7.2.1.- Introducción
En esta segunda parte prepararemos el control de las otras dos bombas.
Para realizar las otras dos bombas copiaremos FC10, renombrándolo con otra función
Una vez creada la copia, le cambiaremos el nombre del símbolo, seleccionando con el botón derecho
las propiedades.
Después hay que entrar en la funciones FC11 y FC12 y modificar las variables.
La bomba 2 es idéntica a la bomba 1 en condiciones marcha y paro, pero las indicaciones son menos
ya que en la primera bomba hemos indicado variables comunes como niveles, temperaturas, etc y no
hay que volverlas a repetir.
La bomba 3, cambia las condiciones ya que esta bomba es de recirculación las condiciones son las
indicadas en estos cuadros.
• Las condiciones de la bomba 3 de recirculación son las siguientes.
Condiciones iniciales:
1.- El tanque tiene que estar lleno, según el nivel hemos establecido un 20%
2.- La temperatura del aceite tiene que tener una temperatura mínima (5ºC) para que el aceite no este
espesa.
• Condiciones permanentes:
1.- El tanque tiene que estar lleno, según el nivel hemos establecido un 20%
2.- La temperatura del aceite tiene que tener una temperatura mínima (5ºC) para que el aceite no este
espesa.
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 7.3
7.3. Desarrollo del Wincc Flexible
7.3.2.- Simbológica
7.3.3.- Pantalla esquema hidráulico
• Definición de bomba
Para indicación de las bombas utilizaremos las variables de tipo booleanos proveniente de la DB2.
La lógica que utilizaremos es:
Valor 0 color rojo, representa bomba parada.
Valor 1 color verde, representa bomba roja.
• Definición Nivel
Para indicación del nivel utilizaremos las variables de tipo real proveniente de la DB3.
Los valores se han establecido en tanto por cien.
• Definición Temperatura
Para indicación de valores numéricos utilizaremos variables de tipo real.
Para el pulsador de listo utilizaremos los eventos para hacer una llamada a otra pantalla.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 8
8.1.- Introducción
Estas tablas sirven para observar y forzar variables, este tipo de bloques no se cargan en la CPU.
• Hay muchas variables que nos interesara verlas en diferentes formatos, para ello podemos cambiar el
formato situándonos encima del cuadro formato de visualización y pulsando el botón derecho nos dejara
elegir diferentes formatos.
• Para poder observar el estado de las variables, hay seleccionar Variables -> Observar, también
pulsando el icono de las gafas observaremos las variables.
• Símbolos no utilizados
Con esta vista podemos ver todos los símbolos no utilizados en programa.
Nota: Las dos primeras vistas son las importantes, no hay que olvidar que hay que utilizarlas muy a
menudo en la realización de nuestros programas.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 9
En Step 7 se pueden realizar operaciones aritméticas con funciones estándar que dispone el software.
Existen varias funciones con números enteros y números con coma flotante.
• Suma enteros
• Resta enteros
Parámetro Tipo de datos Area de memoria Descripción
IN1 INT E, A, M, L, D o constante Sustraendo
IN2 INT E, A, M, L, D o constante Minuendo
OUT INT E, A, M, L, D Resultado de la sustracción
• Multiplicar enteros
• Dividir enteros
• Valor absoluto
Parámetro Tipo de datos Área de memoria Descripción
IN REAL E, A, M, L, D Número en coma flotante
OUT REAL E, A, M, L, D Valor absoluto del número en coma flotante
• Raíz cuadrada
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 10
10.- Conversiones
10.1.- Introducción
Hay varias funciones internas de conversión, estas funciones nos ayudaran a convertir diferentes tipos
de datos.
Lista de operaciones de conversión
También existe la conversión contraria, de entero a BCD. Y conversiones de BCD a doble entero, doble
entero a BCD.
• Complemento a 1 de un entero
Pará
metro Tipo de datos Área de memoria Descripción
IN INT E, A, M, L, D Valor entero (de 16 bits) de entrada
OUT INT E, A, M, L, D Complemento a 1 del entero (de 16 bits)
• Complemento a 2 de un entero
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 17.1
17.-TRATAMIENTO DE ALARMAS
17.1- Desarrollo Plc
Para el desarrollo de las alarmas vamos a generar un nuevo bloque de datos (DB7 AL_HMI)
El tipo que vamos a utilizar es entero (INT), con lo cual con este tag podemos tener 32 alarmas.
Las alarmas se pueden generar de muchas maneras, muchas de ellas suelen ser muy sencillas.
Por ejemplo las dos primeras que vamos a generar, solo vamos a igualar la entrada digital a una
dirección de la DB7.
Recordar que Siemens trabaja con los bytes cambiados, para ello nosotros tenemos que hacer el
swapeo, esto significa cruzar los bytes.
El bit 0 tiene a dirección DB7.DBX1.0, y el bit 8 su dirección es DB7.DBX0.0.
El fallo de la bomba y el fallo filtro la programaremos igualando la dirección a la alarma, pero para el
fallo de presión lo vamos a generar un tiempo.
Para elaborar este último, aplicaremos un temporizado, si cualquiera de las bombas de alimentación
esté en marcha, si el presostato no da señal a de 20 segundo activaremos una memoria que nos
indicara que hay una fuga de aceite.
También vamos a sustituir la entrada digital E10.7 (Baja presión línea hco.) por el fallo que hemos
generado, en todos los sitios del programa menos en la indicación.
Unas de las más importantes son las condiciones permanentes, ya que nada más arrancar las bombas
no va a coger presión, como teníamos antes las condiciones se pararía las bombas nada más arrancar.
Como podéis comprobar hemos utilizado un SET para activar esta alarma, es recomendable utilizar
memoria ya que cuando se active la alarma se apagara la bomba.
Si hubiéramos utilizado una bobina (=) en muchas ocasiones no se vería en el Wincc está alarma, ya
que en el siguiente ciclo la bobina se pone a 0.
Vamos a preparar un acuse de alarmas desde Wincc, este solicitud la utilizaremos para todas las
alarmas que vayamos generando a lo largo del curso.
Capitulo 17.2
17.2- Desarrollo WinCC Flexible
Lo primero que tenemos que hacer es rellenar la variable nueva AL_HMI_00 en la tabla de variables.
Una vez hemos rellenado la variable hay que abrir la carpeta Gestión de avisos y hacer doble clic en
Avisos de bit, aquí en esta tabla hay que rellenar los textos de la alarma.
Para empezar añadimos la variable AL_HMI_00 en “Variables de trigger”, por defecto nos añade el
número 0 y la dirección DB7.DBX1.0.
Una vez rellenada la primera, seleccionamos un cuadro y pinchamos en el punto negro y desplazamos
hacia abajo para crear los otros 15 bits
Hay que agregar una nueva imagen, donde añadiremos el cuadro de alarmas.
-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 18
18.1- Introducción
El STRING es una cadena de caracteres, con un máximo de 254 caracteres, cada carácter utiliza un
byte.
Un STRING consta de un cuerpo 254 Bytes y una cabecera de 2 Bytes (Byte 0 y Byte 1). El Byte 0
define la longitud máxima y el Byte 1 define la longitud real del STRING.
Ejemplo;
Tipo de dato: Ejemplo Formato:
STRING[2] ‘ED’
18.2- Ejemplo
Crearemos una nueva tabla de datos (DB8), donde definiremos unas variables de tipo STRING.
El valor inicial puede ser un carácter o un espacio en blanco, como en el ejemplo.
Vamos a definir una tabla de variables donde definiremos los dos primeros string.
Para ello definiremos 20 bytes, los 10 primeros corresponde al STRING_00 de 0 a 9 y los 10 siguientes
corresponde al STRING_01 de 10 a 19 bytes.
En la tabla de variables del WinCC, insertaremos dos campos nuevos definidos como String.
En la dirección de cada string rellenaremos el inicio de cada string.
Después de definir las variables, insertaremos dos campos ES, el primero lo vamos a definir como
modo “Entrada”, lo utilizaremos para introducir caracteres.
La variable que elegiremos es STRING_00 y seleccionaremos el formato “Secuencia de caracteres”, la
longitud del campo será 8, que son los máximos caracteres que queremos reflejar en el campo.
Para el segundo, utilizaremos el STRING_01, colocando las mismas propiedades menos el modo que
será de “Salida”.
-----------------------------------------------------------------------------------------------------------------------------------------
EJERCICIOS DE REPASO
Ejercicio 1
En este ejercicio sencillo intentaremos aplicar varias cosas aprendidas en este temario.
La idea es definir una remota donde conectaremos el panel que controlara el motor.
Definiremos unas tarjetas de entradas digitales con dirección E300 y unas salidas digitales con
dirección A300.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Ejercicio 1.1
Para empezar con el desarrollo de este ejercicio, vamos a definir una red de profibus donde
insertaremos la remota ET200s
Definimos una función nueva (FC14), en esta función programaremos las condiciones iniciales,
permanentes, la marcha delante, marcha atrás, el paro y indicaciones.
• Condiciones
Vamos a definir un segmento para cada condición.
Aunque no tenemos ninguna condición inicial la preparamos por defecto, para tenerlo preparado.
La única condición permanente que tenemos que añadir el contacto del automático o guardamotor.
Las marcas que vamos a utilizar la rellenaremos en la tabla de símbolos según vallamos necesitando.
• Marcha adelante
Ejecutaremos la marcha adelante una vez tengo las condiciones iniciales (que en esta caso siempre a
1) y pulsemos a solicitud de adelante, en este caso daremos marcha a través de la salida A300.0
dejándola memorizada con un SET y reseteando (RESET) la orden contraria.
Esto es muy importante ya que si activaríamos las dos a la vez haríamos un corto 400V.
Existen en el mercado contactores en clavados para que no puedan meterse a la vez, pero este
contactor es más caro que dos normales. Lo normal es encontrarse con contactores normales.
• Marcha atrás
En la marcha atrás hacemos lo mismo que la anterior.
Normalmente nos interesaría tener condiciones de adelante y condiciones de atrás, en este ejemplo he
utilizado solo una condición inicial y una permanente.
• Indicaciones panel
Con las confirmaciones de los contactores indicaremos cuando está en marcha adelante o marcha
atrás.
Como podéis comprobar me gusta poner el uno permanente para utilizar varias cosas en el mismo
segmento, es una forma de no utilizar tantos segmentos.
Ir a página: Temario
-----------------------------------------------------------------------------------------------------------------------------------------
Ejercicio 1.2
Vamos a preparar las subrutinas, para la subrutina accionamiento dos sentidos de giro utilizaremos la
que disponemos (FB10 SUB_ACCTO_2S).
Pero en este ejercicio vamos a preparar una que se encargué de las condiciones.
Insertamos un bloque de función nuevo (FB11 SUB_COND_8).
El valor inicial de todas estas variables la vamos a poner a TRUE, para si no rellenamos nada en la
entrada que por defecto tenga un 1.
• Preparación de programa
Para la realización de la lógica, solo tenemos que poner en serie todas las entras de cada condición
inicial y si todas están a 1 activaremos la bobina (RES_CI).
Igual con las condiciones permanentes.
Arrastraremos de los elementos de proyecto las dos subrutinas (FB11 SUB_COND y FB10
SUB_ACCTO_2S)
Para convertirla la subrutina en multiinstancia seleccionaremos la subrutina y haremos clic con el botón
derecho, nos aparecerá un tabla donde seleccionaremos “Convertir en llamada multiinstancia”.
Esta acción nos rellenara en la parte de STAT, el tipo de dato necesario para trabajar.
• Condiciones
Solo vamos a rellenar las condiciones necesarias ya que si dejamos sin rellenar nada en las patas de
entrada, por defecto estarán a 1, necesario para tener el resumen a 1 para funcionar.
Como para este ejemplo solo tenemos el automatico, solo rellenaremos una condición permanente.
En la parte de salida la misma marca que hemos utilizados en el ejemplo anterior.
Nota: A la hora de probar hay que quitar el FC14 del bloque de organización para que no se machaquen
las marchas.
Gracias
Responder
Gracias
Responder
Respuestas
Responder
Respuestas
Responder
Tengo una duda, que debo hacer si al momento de revsar las referencias cruzadas, aparece una ventana,
me dice si debo actualizar o regenerar los datos. El step7 esta corriendo, SE ACTUALIZA O SE
REGENERA, corro algún riesgo ?
Saludos atte.
Andres Herrera V. (hherreravidal@gmail.com)
Responder
Introduce tu comentario...
Página principal
Fjp. Tema Picture Window. Imágenes del tema: enot-poloskun. Con la tecnología de Blogger.