VMA209
TARJETA DE EXPANSIÓN SHIELD MULTIFUNCIÓN PARA ARDUINO®
Manual de usuario
Introducción
A todos los residentes de la Unión Europea
Información medioambiental importante sobre este producto
Este símbolo en el dispositivo o en el paquete indica que la eliminación del dispositivo después de su ciclo de vida podría dañar el medio ambiente. No deseche la unidad (o las baterías) como residuos municipales sin clasificar; debe ser llevado a una empresa especializada para su reciclaje. Este dispositivo debe devolverse a su distribuidor o a un servicio de reciclaje local. Respete las normas ambientales locales.
En caso de duda, póngase en contacto con las autoridades locales de eliminación de residuos.
¡Gracias por elegir Velleman®! Lea el manual detenidamente antes de poner en servicio este dispositivo.
Si el dispositivo se dañó durante el transporte, no lo instale ni lo utilice y póngase en contacto con su distribuidor.
Instrucciones de seguridad
Este dispositivo puede ser utilizado por niños mayores de 8 años y personas con capacidades físicas, sensoriales o mentales reducidas o que carezcan de experiencia y conocimientos, siempre que estén bajo supervisión o hayan recibido instrucciones sobre el uso seguro del dispositivo y comprendan los riesgos que conlleva. Los niños no deben jugar con el dispositivo. La limpieza y el mantenimiento del dispositivo no deben ser realizados por niños sin supervisión.
Sólo para uso en interiores.
Mantener alejado de la lluvia, humedad, salpicaduras y goteo de líquidos.
Directrices generales
- Consulte la garantía de calidad y servicio de Velleman® en las últimas páginas de este manual.
- Familiarícese con las funciones del dispositivo antes de utilizarlo.
- Por razones de seguridad, está prohibido realizar modificaciones en el dispositivo. La garantía no cubre los daños causados por modificaciones realizadas por el usuario al dispositivo.
- Utilice el dispositivo únicamente para el fin previsto. El uso no autorizado del dispositivo anulará la garantía.
- Los daños causados por el incumplimiento de ciertas pautas de este manual no están cubiertos por la garantía y el distribuidor no aceptará responsabilidad por los defectos o
Problemas. 
Ni Velleman nv ni sus distribuidores serán responsables de ningún daño (extraordinario, incidental o indirecto) de ningún tipo (financiero, físico...) que surja de la posesión, uso o fallo de este producto.- Debido a las constantes mejoras del producto, la apariencia real del producto puede diferir de las imágenes mostradas.
- Las imágenes del producto son sólo para fines ilustrativos.
- No encienda el dispositivo inmediatamente después de haber estado expuesto a cambios de temperatura. Proteja el dispositivo contra daños dejándolo apagado hasta que haya
alcanzó la temperatura ambiente. - Conserve este manual para futuras consultas.
¿Qué es Arduino®?
Arduino® es una plataforma de creación de prototipos de código abierto basada en hardware y software fáciles de usar. Las placas Arduino ® pueden leer entradas (sensor de luz encendida, un dedo en un botón o un mensaje de Twitter) y convertirlas en una salida (activar un motor, encender un LED, publicar algo en línea). Puede decirle a su placa qué hacer enviando un conjunto de instrucciones al microcontrolador en la placa. Para ello, utiliza el lenguaje de programación Arduino (basado en Wiring) y el software IDE de Arduino® (basado en Processing).
Navegar a www.arduino.cc y www.arduino.org Para más información.
| V.01 - 12/04/2018 | 2 | © Velleman nv |
Encimaview
dimensiones …………………………………………… 69 x 54 x 11 mm
peso …………………………………………………………………. 27 g
Conexión
| VMA209 | Arduino® |
| 10, 11, 12, 13 | LED rojos 4 |
| A1, A2, A3 | 3 botones + botón de reinicio |
| A0 | potenciómetro (10 kΩ) |
| pestillo 4, reloj 7, datos 8 | Tubo LED de 4 segmentos y 7 dígitos accionado por 74HC595 |
| 3 (encendido-apagado digital) | zumbador |
| 2 | toma para receptor IR (mando a distancia) |
| A4 | enchufe para sensor de temperatura LM35 o DS18B20 (¡polaridad!) |
| TIERRA, +5 V, 0, 1 (RX/TX) | cabezal para escudo APC220 |
| 5, 6, 9, A5 | pines libres (PWM |
ExampLos
7.1 LED parpadeantes
//**************************************************** ************//LED parpadeantes en el Velleman VMA209
//Programado por: Arduino IDE
//Compatible con: Arduino Leonardo, Arduino UNO, MEGA
// ********************************************** ************
char ledPin = 10; //pin digital 10 -> LED1 (D4)
char ledPin1 = 11; // pin digital 11 -> LED2 (D3)
char ledPin2 = 12; // pin digital 12 -> LED2 (D2)
char ledPin3 = 13; // pin digital 13 -> LED2 (D1)
configuración vacía()
{
pinMode(ledPin, OUTPUT);//declarar LedPin como salida
pinMode(ledPin1, SALIDA);
pinMode(ledPin2, SALIDA);
pinMode(ledPin3, SALIDA);
}
bucle vacío()
{
escritura digital (pin led, ALTO); //Enciende este LED
escritura digital (ledPin1, ALTO);
escritura digital (ledPin2, ALTO);
escritura digital (ledPin3, ALTO);
retraso (1000); //Espera 1 segundo
digitalWrite(ledPin, BAJO); //Apaga este LED
escritura digital (ledPin1, BAJO);
escritura digital (ledPin2, BAJO);
escritura digital (ledPin3, BAJO);
retraso (1000); // Espera 1 segundo
}
7.2 LED de funcionamiento
//**************************************************** *******************************
//VMA209 LED EN FUNCIONAMIENTO EXAMPLE
//Escrito en: Arduino IDE
//Compatible con: Arduino Leonardo, Arduino UNO, Mega
//**************************************************** *******************************/
int BASE = 10 ; // Base de pin digital = 10, 10 = correspondiente a D10
número entero = 4; // 4 líneas digitales se utilizan para 4 LED
configuración vacía()
{
para (int i = BASE; i < BASE + NUM; i ++)
{
pinMode(i, SALIDA); //declarar los pines digitales 10 a 13 como salida
}
}
7.3 Prueba de pulsadores y LED
// ************************************************** *****
// VMA209 Pulsador y test de LED
// escrito por Patrick De Coninck / Velleman NV.
// VMA209 contiene 3 pulsadores, están conectados a las entradas analógicas Arduino A1, A2, A3
// en este ejemploampLe encenderemos el LED1 al presionar el botón 3. Siéntase libre de elegir diferentes
botones o LED
//**************************************************** ****
pin led int=13; //Definir ledpin entero con un valor de 13
pin de entrada int=A3; //Definir integer inpin = línea analógica A3
valor int; // definir variable VAL
configuración vacía()
{
pinMode(ledpin,OUTPUT);//Declarar ledpin (que tiene un valor de 13) como SALIDA pinMode(inpin,INPUT);//Declarar inpin (que es la entrada analógica A3) como ENTRADA
}
bucle vacío()
{
val=digitalRead(inpin);//Lee el valor de la línea analógica 13 (pulsador)
if(val==LOW) //Si este valor es BAJO:
{ digitalWrite(ledpin,LOW);} // entonces ledpin (el led en la línea digital 13) también está en BAJO (apagado) de lo contrario
{ digitalWrite(ledpin,HIGH);} // en el otro caso (ledpin no es bajo) enciende el LED en D13
}
bucle vacío()
{
para (int i = BASE; i < BASE + NUM; i ++)
{
escritura digital (i, BAJO); //Apague las líneas digitales 10 a 13 una por una
retraso (200); // espera 0,2 segundos
}
para (int i = BASE; i < BASE + NUM; i ++)
{
escritura digital (i, ALTO); //Encienda las líneas digitales 10 a 13 una por una
retraso (200); //esperar 0,2 segundos
}
}
7.4 LED Arranque-Parada
//**************************************************** *******************************
// VMA209 – LED START-STOP POR PULSADOR EXAMPLE
// función: presione S1, el LED D1 se encenderá — presione S1 nuevamente, el LED D1 se apagará
// programado en:Arduino IDE—————————————–
// compatible con Arduino UNO, MEGA
//**************************************************** *******************************
#define LED 13 // El LED está en el digital 13, ¡se puede elegir otro valor entre las líneas 10 y 13! ¡Solo pruébalo!
#define KEY A1 // elegimos uno de los pulsadores disponibles que están en A1, A2 o A3. En este caso elegimos A1 pero puedes probar con otro int KEY_NUM = 0;
configuración vacía()
{
pinMode(LED, SALIDA);
// inicializa el LED (D13) como salida pinMode(KEY,INPUT_PULLUP);
//inicializar KEY (pin analógico A1) como una entrada con la resistencia pull-up interna habilitada
}
bucle vacío()
{
Escanear tecla();
// comprueba si hay una tecla presionada (ver void ScanKey) if(KEY_NUM == 1) // tecla 1 presionada
{
digitalWrite(LED,!digitalRead(LED));// Invertir el estado del LED
}
}
void ScanKey() // Rutina ScanKey
{
CLAVE_NUM = 0; si (lectura digital (CLAVE) == BAJO)
{
retraso(20);
// retardo anti-rebote, este es el tiempo mínimo Tienes que pulsar el botón if(digitalRead(KEY) == LOW)
{
CLAVE_NUM = 1; while(lectura digital(CLAVE) == BAJO);
}
}
}
7.5 potenciómetro
//**************************************************** *******************************
// VMA209 – Medidor de potenciómetro example
// El VMA209 contiene un potenciómetro azul (trimmer) que está conectado a Analog 0
// En este ejemploample mostramos cómo medir el voltage entre 0 y 5V, y como visualizarlo mediante
el monitor de serie
// Programado :Arduino IDE
// Tablero: Arduino Leonardo, UNO, MEGA
//**************************************************** *******************************/
#define Bote A0
//declara la línea analógica 0 como Potint PotBuffer = 0;
// inicializa la variable PotBuffer como configuración de vacío entero ()
{
Serie.begin(9600);
//Establecer puerto serie a 9600 Baud
}
bucle vacío()
{
PotBuffer = analogRead(Pot); // Leer el valor de Pot (A0) y guardarlo en PotBuffer Serial.print(“Pot = “);// Escribir “Pot =” en el monitor serie
Serial.println(PotBuffer); // Ahora imprima el valor real medido por A0 (Pot o PotBuffer), GIRE el pequeño tornillo en la parte superior del recortador azul y verá un valor entre 0 y aproximadamente 1000//
// Esto significa que tienes que dividir PotBuffer por 200 para tener el volumen realtage en A0 (Serial.println(PotBuffer/200)), la variable Potbuffer , que se declara como Integer (int) debería
// luego se declara como variable de punto flotante o: float PotBuffer = 0;delay(500);
// espera 0,5 seg. entre cada ciclo de medición
}
7.6 Potenciómetro PWM
//**************************************************** *******************************
// VMA209 – Medidor de potenciómetro + PWM example
// El VMA209 contiene un potenciómetro azul (trimmer) que está conectado a Analog 0
// En este ejemploample mostramos cómo medir el voltage entre 0 y 5V, como visualizarlo por el
monitor serie y cómo ajustar la intensidad de 2 LED usando PWM
// Programado :Arduino IDE
// Tablero: Arduino Leonardo, UNO,
//**************************************************** *******************************/
int potpin=A0; // Inicializar potpin entero como Analógico 0
int ledpin1=11;//Definir la interfaz digital 11 (salida PWM)
int ledpin2=10;//Definir la interfaz digital 10 (salida PWM)
int val=0; // inicializa val como un entero con valor 0
configuración vacía()
{
Serial.begin(9600);//Establecer la tasa de baudios de comunicaciones a 9600 Baud
}
bucle vacío()
{
val=analogRead(potpin);// Lee el valor analógico del sensor y asígnalo a val Serial.println(val);// Imprime este valor en el monitor serial
analogWrite(ledpin1,val/4); // escribe este valor en el LED y establece su brillo por PWM (valor entre 0 y 255, por eso se divide en 4)
analogWrite(ledpin2,val/4); // escribe este valor en el LED y establece su brillo por PWM (valor entre 0 y 255, por eso se divide en 4)
delay(100);//esperar 0,1 segundos para la próxima medición
}
7.7 Prueba del zumbador
//**************************************************** *******************************
// VMA209 Zumbador example
// El zumbador en el VMA209 está conectado al pin digital 3
// con este pequeño example, le mostramos cómo crear una sirena
// compatible con: Arduino Leonardo o Arduino UNO R3
//**************************************************** *******************************/
zumbador int=3; //Establece la variable zumbador como un número entero y asigna el valor 3 void setup()
{
pinMode(buzzer,OUTPUT);// Inicializar Pin3 (buzzer) como salida
}
bucle vacío()
{
unsigned char i,j;// Definir variables while(1)
{
para (i = 0; i <80; i ++)
{
digitalWrite(zumbador, ALTO);//Sonido en retardo(1);// Espera 1ms
digitalWrite (zumbador, BAJO);//Retardo de apagado de sonido (1);//Espere 1ms
}
for(i=0;i<100;i++)//segundo sonido
{
escritura digital (zumbador, ALTO);//Sonido activado
retardo(2);//Esperar 2ms
escritura digital (zumbador, BAJO);//Sonido desactivado
retardo(2);//Esperar 2ms
}
}
}
7.8 Contador arriba-abajo
//**************************************************** *******************************
//—————-VMA209 Contador ARRIBA-ABAJO example———–
//**************************************************** *******************************/
int pasador de cierre = 4;
pin de reloj int = 7;
pin de datos int = 8; //Definir pines de pestillo, reloj y datos para la pantalla
int KEY_ADD =A1; //Definir el interruptor 1 como cuenta ARRIBA
int CLAVE_DEC=A2; //Definir el interruptor 2 como cuenta ABAJO
unsigned char Dis_table[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0X80,0X90};
//Estado LED
mostrar variables
carácter sin signo Dis_buf[] = {0xF1,0xF2,0xF4,0xF8};
disbuff de caracteres sin firmar [] = {0, 0, 0, 0};
int SUMA = 0;
int Bandera_arriba = 1;
int Bandera_arriba1 = 1;
configuración vacía ()
{
pinMode(latchPin, SALIDA);
pinMode(relojPin, SALIDA);
pinMode(datosPin, SALIDA); //definir los pines 4,7,8 como SALIDA
}
visualización vacía ()
{
para(caracter i=0; i<=3; i++)
{
escritura digital (Pin de pestillo, BAJO);
shiftOut(dataPin,clockPin,MSBFIRST,Dis_table[disbuff[i]]); //Enviar valor a las 4 pantallas
shiftOut(dataPin,clockPin,MSBFIRST,Dis_buf[i]);
escritura digital (Pin de pestillo, ALTO);
retraso(2);
mostrar();
si( ScanKey() == 1)
// si se presiona un pulsador
{
SUMA++;
//Añadir 1
si(SUMA>9999)
//El valor máximo del contador es 9999 (pruebe con otro valor
!! )
{
SUMA = 9999; // permanece en 9999
}
anulación[0]=SUMA/1000;
//Llene los 4 búferes de visualización con el nuevo valor
anulación[1]=SUM%1000/100;
anulación[2]=SUM%100/10;
anulación[3]=SUM%10;
}
si( EscanearTecla1() == 1)
// ¿Botón 2 presionado?
{
SUMA-;
//Cuenta atrás un valor
si (SUMA <= 0)
// ¿El valor es cero? que permanecer en 0
{
SUMA = 0;
}
anulación[0]=SUMA/1000;
//Llene los 4 búferes de visualización con el nuevo valor
anulación[1]=SUM%1000/100;
anulación[2]=SUM%100/10;
anulación[3]=SUM%10;
}
}
// espere 2 ms antes de acceder a la siguiente pantalla, intente con otro valor
(por ejemploample 100 ) para ver cómo funciona la multiplexación
}
}
carácter sin firmar ScanKey()
//Escanear pulsador 1 (S1)
{
if(Flag_up && digitalRead(KEY_ADD) == BAJO)
{
Bandera_arriba = 0;
mostrar();
mostrar();
si (lectura digital (KEY_ADD) == BAJO)
{
devuelve 1;
}
}
si (lectura digital (KEY_ADD) == ALTO)
{
Bandera_arriba = 1;
}
devuelve 0;
}
carácter sin firmar ScanKey1()
//Escanear pulsador 2 (S2)
{
if(Flag_up1 && digitalRead(KEY_DEC) == BAJO)
{
Bandera_arriba1 = 0;
mostrar();
mostrar();
si (lectura digital (KEY_DEC) == BAJO)
{
devuelve 1;
}
}
si (lectura digital (KEY_DEC) == ALTO)
{
Bandera_arriba1 = 1;
}
devuelve 0;
}
bucle vacío()
{
7.9 Prueba de temperatura
//**************************************************** ***********************************/
//—————- VMA209 midiendo temperatura usando la entrada A4 ——————————————–/
//— ATENCIÓN — ¡El símbolo en el PCB es para el sensor 18B20! ¡Si usa LM35 tiene que estar al revés! —///—————-
¡¡¡COMPROBAR PRIMERO LA POLARIDAD!!!
————————————————————–/
//**************************************************** ***********************************/
#definir LM35 A4
valor int= 0;
// inicializando la variable val con valor 0
temperatura de flotación = 0;
// inicializando la variable temp como punto flotante void setup()
{
Serial.begin(9600); // establecer la tasa de baudios a 9600
}
bucle vacío()
{
val = lectura analógica (LM35);
// lee el valor de A4
temperatura = valor * 0.48876;
// eventual factor de corrección
Serial.imprimir(“LM35 = “);
Serial.println(temp);//imprime el valor en el monitor serie
retraso (1000); // esperar un segundo para la próxima medición
}
7.10 Voltímetro
//**************************************************** ************************************ *********
//– VMA209 Voltímetro example
//– Este example lee el valor del potenciómetro azul en el VMA209 y lo muestra en la pantalla
//**************************************************** ************************************ *********/
int potpin=A0; // declara potpin variable como conectado a la entrada analógica A0
int pasador de cierre = 4;
pin de reloj int = 7;
pin de datos int = 8; //declarar latchPin, clockpin y datapin para la pantalla (pines de datos 4,7 y 8)
char sin signo Dis_table[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0X80,0X90}; // Esta tabla define los 7 segmentos de la pantalla, 0x no se usa aquí. 00 = todos los segmentos encendidos, FF = todos los segmentos apagados, 0x7F se usa para el punto decimal
carácter sin signo Dis_buf[] = {0xF1,0xF2,0xF4,0xF8}; // esta tabla establece un "selector" para qué dígito se selecciona unsigned char disbuff[] = {0, 0, 0, 0}; // establece el búfer de visualización en 0
int SUMA = 0;
configuración vacía ()
{
pinMode(latchPin, SALIDA);
pinMode(relojPin, SALIDA);
pinMode(datosPin, SALIDA); // establecer los 3 pines de datos como salida
}
visualización vacía ()
{
for(char i=0; i<=3; i++)// Esta rutina escribirá información en los 4 dígitos de la pantalla, la variable i contará de 0 a 3
{
escritura digital (Pin de pestillo, BAJO); //Active el Latch Pin, el Latch Pin permite escribir datos en los registros de desplazamiento del VMA209
shiftOut(dataPin,clockPin,MSBFIRST,Dis_table[disbuff[i]]); // salida Dis_table dependiendo del valor de i , shiftOut(dataPin,clockPin,MSBFIRST,Dis_buf[i] ); //salir Dis_buf dependiendo del valor de i digitalWrite(latchPin,HIGH); //Desactivar el pasador de pestillo, la información para digit(i) ha sido escrita delay(2); // toma un descanso por 2mS
}
}
Más información
Consulte la página del producto VMA209 en www.velleman.eu Para más información.
Utilice este dispositivo únicamente con los accesorios originales. Velleman nv no se hace responsable en caso de daños o lesiones resultantes del uso (incorrecto) de este dispositivo. Para obtener más información sobre este producto y la versión más reciente de este manual, visite nuestra página web. websitio www.velleman.eu. La información contenida en este manual está sujeta a cambios sin previo aviso.
© AVISO DE COPYRIGHT
Los derechos de autor de este manual pertenecen a Velleman nv. Todos los derechos reservados a nivel mundial. No se puede copiar, reproducir, traducir ni reducir ninguna parte de este manual a ningún medio electrónico ni de ningún otro modo sin el consentimiento previo por escrito del titular de los derechos de autor.
Garantía de calidad y servicio Velleman®
Desde su fundación en 1972, Velleman® adquirió una amplia experiencia en el mundo de la electrónica y actualmente distribuye sus productos en más de 85 países.
Todos nuestros productos cumplen con los estrictos requisitos de calidad y las estipulaciones legales de la UE. Para garantizar la calidad, nuestros productos pasan periódicamente por un control de calidad adicional, tanto por parte de un departamento de calidad interno como de organizaciones externas especializadas. Si, a pesar de todas las medidas de precaución, se produjeran problemas, por favor, recurra a nuestra garantía (consulte las condiciones de garantía).
Condiciones generales de garantía de productos de consumo (para la UE):
- Todos los productos de consumo están sujetos a una garantía de 24 meses contra defectos de producción y materiales a partir de la fecha original de compra.
- Velleman® puede decidir reemplazar un artículo por otro equivalente, o reembolsar total o parcialmente el valor de venta al público cuando la reclamación sea válida y la reparación o sustitución gratuita del artículo sea imposible, o si los gastos sean desproporcionados.
Se le entregará un artículo de reemplazo o un reembolso por un valor del 100% del precio de compra en caso de que se produzca un defecto durante el primer año después de la fecha de compra y entrega, o un artículo de reemplazo por un valor del 50% del precio de compra o un reembolso por un valor del 50% del valor de venta al público en caso de que se produzca un defecto durante el segundo año después de la fecha de compra y entrega. - No cubierto por la garantía:
- todos los daños directos o indirectos causados después de la entrega del artículo (por ejemplo, por oxidación, golpes, caídas, polvo, suciedad, humedad ...), y por el artículo, así como su contenido (por ejemplo, pérdida de datos), compensación por lucro cesante;
- bienes consumibles, piezas o accesorios que están sujetos a un proceso de envejecimiento durante el uso normal, como baterías (recargables, no recargables, integradas o reemplazables), lamps, piezas de goma, correas de transmisión… (lista ilimitada);
- defectos resultantes de incendios, daños por agua, rayos, accidentes, desastres naturales, etc.…;
- defectos causados deliberadamente, por negligencia o como resultado de un manejo inadecuado, mantenimiento negligente, uso abusivo o uso contrario a las instrucciones del fabricante;
- daños causados por un uso comercial, profesional o colectivo del artículo (la vigencia de la garantía se reducirá a seis (6) meses cuando el artículo se utilice profesionalmente);
- daños resultantes de un embalaje y envío inadecuado del artículo;
- cualquier daño causado por modificación, reparación o alteración realizada por un tercero sin el permiso por escrito de Velleman®.
- Los artículos a reparar deben entregarse a su distribuidor Velleman® bien embalados (preferiblemente en el embalaje original) y deben acompañarse del recibo de compra original y de una descripción clara del defecto.
- Consejo: Para ahorrar tiempo y dinero, vuelva a leer el manual y compruebe si el defecto se debe a causas obvias antes de presentar el artículo para su reparación. Tenga en cuenta que la devolución de un artículo que no presente defectos también puede implicar gastos de manipulación.
- Las reparaciones que se realicen después del vencimiento de la garantía están sujetas a costos de envío.
- Las condiciones anteriores se entienden sin perjuicio de todas las garantías comerciales.
La enumeración anterior está sujeta a modificaciones según el artículo (ver manual del artículo).
Fabricado en la República Popular China
Importado por Velleman nv
Legen Heirweg 33, 9890 Gavere, Bélgica
www.velleman.eu
Documentos / Recursos
 |
velleman VMA209 Multi Function Shield Expansion Board para Arduino [pdf] Manual del usuario Placa de expansión de protección multifunción VMA209 para Arduino, VMA209, placa VMA209, placa de expansión de protección multifunción, placa de expansión de protección, placa de expansión, placa de expansión de protección multifunción para Arduino, placa |
