[nextpage title=»Introducción»]
Grove Starter Kit es un sistema modular enfocado principalmente para la creación de prototipos de forma rápida, que no implique soldadura o el uso de un protoboard. Sólo se requiere conectar los módulos del Grove Starter Kit en el Grove Shield y aprovechar varios de los códigos de ejemplos ya implementados para cada módulo Grove. El Grove Starter Kit incluye sensores y actuadores, así que con este sorprendente kit modular para Arduino puedes comenzar con tu aprendizaje dentro de cualquier proyecto.
Haciendo una comparativa al desarrollar prototipos con los componentes electrónicos por separado utilizando un protoboard, Grove Starter Kit simplifica todo el proceso de manera significativa. El Grove Starter Kit consiste en un Shield (La placa que va montada encima del Arduino) y varios módulos con conectores estandarizados. El Shield permite una fácil conexión de cualquier entrada o salida al microcontrolador, y cada módulo Grove realiza una sola función, como un botón o un sensor.
Con estos conectores incluidos el trabajo será mucho mas sencillo.
[nextpage title=»Contenido del Grove Starter Kit»]
Los componentes que contiene el kit son los siguientes:
- 1 Base Grove Shield
- 1 Grove – LCD RGB
- 1 Grove – Rele 5v
- 1 Grove – Buzzer
- 1 Grove – Sensor de sonido
- 1 Grove – Sensor tactil
- 1 Grove – Sensor rotatorio de angulo
- 1 Grove – Sensor de temperatura
- 1 Grove – LED
- 1 Grove – Sensor de luz
- 1 Grove – Boton
- 3 LEDS azul, verde y rojo
- 1 Mini Servo
- 10 Cables Grove
- 1 Broche para pilas de 9v
- 1 Manual de Grove starter kit
- 1 Caja de plastico verde
Grove Starter Kit
Arduino UNO
Cada elemento viene con su respectivo conector. También incluye un broche para batería de 9V con el que es posible alimentar el Arduino de manera autónoma. Contiene lo suficiente para cualquier proyecto básico-intermedio.
[nextpage title=»Características y partes del Grove Shield»]
Para montar el Grove Shield es sencillo, solo se incrusta sobre el Arduino UNO, colocando cada pin en su respectivo orificio de la tira de pines Azul. La placa base Grove Shield es compatible la placa Arduino UNO y Leonardo. El Grove Shield contiene 16 puertos, que se pueden dividir en tres diferentes áreas funcionales: los puertos digitales (8), puertos analógicos (4), y los puertos con protocolo I2C (4).
- Puertos digitales (verde).
La imagen muestra 8 puertos digitales, que son equivalentes a los pines digitales del 0 al 9 de la tarjeta Arduino Uno. Normalmente se utilizan para lecturas digitales que sólo entregue señales de 0 y 1, o también como salidas por ejmplo para encender o apagar un actuador.
- Los puertos I2C (amarillo).
Abajo se de los puertos digitales se localizan cuatro puertos Grove I2C. Este es un protocolo de comunicación que transfiere datos a través de dos vías: SCL y SDA.
- Puertos analógicos (rojo).
En el lado izquierdo hay cuatro puertos Grove para hacer lecturas analógicas. Los sensores analógicos pueden generar señales que van de 0 a 1023 dentro de un programa Arduino. Comparados con los sensores digitales que sólo devuelven 0 ó 1, las lecturas analógicas son más detalladas y precisas.
Cada conector Grove tiene cuatro cables, uno de los cuales es Vcc. Sin embargo, no todos los componentes en la placa necesitan un voltaje de alimentación de 5v, a veces requieren solo de 3.3v. Es por eso que se añade un interruptor. De esta manera, se puede ajustar la tensión de Vcc a través de este interruptor, asegurándose de que el voltaje de Vcc es el mismo que la fuente de alimentación de la placa principal.
Grove LCD.
Este Grove LCD permite establecer el color deseado a través de la interfaz Grove. Se requiere del protocolo I2C como método de comunicación con el microcontrolador. Así el número de pines requeridos para el intercambio de datos y control de luz de fondo se reduce a 2. Además, el Grove LCD es compatible con caracteres definidos por el usuario.
Grove Buzzer.
Este es un simple Grove Buzzer (o Zumbador) pero divertido al usar. Es posible conectarlo a las salidas digitales, y emite un tono cuando la salida es alta. Como alternativa se puede conectar a una salida analógica, y utilizando la modulación por ancho de pulsos (PWM) se pueden generar diferentes sonidos y efectos.
Grove Relevador.
El Relevador (o Relé) es una herramienta útil para ampliar la capacidad de control de voltajes. La tensión del circuito externo puede soportar hasta 220 usado este módulo.
Grove Sensor de Sonido.
El módulo Grove Sensor de Sonido es un micrófono. Basado en el amplificador LM358 y el Micrófono Electret, que puede ser utilizado para medir la intensidad del sonido en el medio ambiente.
Grove Sensor Táctil (TOUCH).
Este Sensor Táctil es capaz de detectar el cambio en la capacitancia cuando un dedo está tocando su superficie. Eso significa que no importa si el dedo toca directamente la placa o simplemente se mantiene cerca de la placa.
Grove Sensor de Temperatura.
Este Sensor de Temperatura utiliza un termistor que devuelve la temperatura del ambiente. Se encarga de convertir un valor de voltaje leído por un pin de entrada de tipo analógica y entrega un valor en temperatura. El rango de operación de este módulo es de -40°C a 125°C (Grados Celsius).
Grove Sensor de Luz (LDR).
El sensor de luz, también conocido como Resistencia Dependiente de la Luz (LDR por sus siglas en inglés). Por lo general, la resistencia del Sensor de Luz disminuye cuando en el ambiente se incrementa la intensidad de luz, y viceversa.
Grove Servo.
Este es un actuador cuya posición puede ser controlada con precisión y facilita su uso debido al conector Grove.
Grove Potenciómetro.
El Grove Potenciómetro produce una salida analógica. El rango angular es de 360 grados con un cambio lineal en su valor. El valor de la resistencia es de 10k ohms, ideal para el uso de Arduino.
Grove Led.
El Grove LED está diseñado para los que están iniciando en Arduino. Puede ser montado y se utiliza como indicador luminoso de alguna señal.
Grove Botón (Push).
Este modulo Grove contiene un botón independiente, el cual está configurado con resistencia pull-down listo para su uso con microcontroladores como una entrada digital.
[nextpage title=»Uso de los módulos LCD, buzzer, Relé y botón»]
Módulo LCD.
Como mencionamos anteriormente el LCD necesita de comunicacion I2C por lo que debemos ocupar un puerto I2C de la Grove Shield.
Para comenzar necesitamos una librería especial para el LCD y así aprovechar los beneficios de este modulo. Descargamos la librería aquí. Una vez descargada debemos importarla desde el IDE, para ello nos dirigimos a Programa>incluir librería>añadir librería zip.
Una vez añadidas las librerías nos vamos a la sección de Archivo>Ejemplos>Grove_LCD_RGB donde ya estarán los ejemplos para iniciar las pruebas del módulo LCD. Además de que la pantalla puede variar a cualquier color por medio de combinaciones entre los colores verde, rojo y azul (RGB).
NOTA: Puedes cambiar el color de la LCD en la sección de variación de color en pantalla, los números pueden variar de o a 255.
Ahora se muestran algunos ejemplos.
[code language=»java»]
//Librerías
#include <Wire.h>
#include «rgb_lcd.h»
//Variables
rgb_lcd lcd;
//Variación de color en pantalla
const int colorR = 255;
const int colorG = 0;
const int colorB = 0;
// Creacion de caracteres especiales
byte corazon[8] = { //corazon
0b00000,
0b01010,
0b11111,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000
};
byte sonrisa[8] = { // Sonrisa.Creada por el usuario.
0b00000,
0b00000,
0b01010,
0b00000,
0b10001,
0b01110,
0b00000,
0b00000
};
//Configuración inicial
void setup(){
lcd.begin(16, 2);
lcd.setRGB(colorR, colorG, colorB); //colores
// creacion de un nuevo carácter
lcd.createChar(1, corazon);
lcd.createChar(2, sonrisa);
lcd.setCursor(2,0); //Posicionamiento
lcd.print(«Tutoriales «); //Mensaje
lcd.write(1); //Escribe el carácter especial
lcd.setCursor(0,1); //Posicionamiento
lcd.print(«Teslabem «); //Mensaje
lcd.write(2); //Escribe el carácter especial
}
void loop(){
}
[/code]
Los caracteres especiales como el corazón los puedes crear tú mismo aquí. Solo da clic en los pixeles que se van a encender en tu caracter y al terminar de crear el carácter se copia el nuevo código, tienes oportunidad de meter hasta 8X5 Pixeles dentro de la matríz del caracter del LCD.
En el siguiente ejemplo se cambió el color de la pantalla y los mensajes cada cierto tiempo.
[code language=»java»]
//Librerías
#include <Wire.h>
#include «rgb_lcd.h»
//Variables
rgb_lcd lcd;
//Variación de color en pantalla
const int colorR = 0;
const int colorG = 0;
const int colorB = 255;
//Configuración inicial
void setup() {
lcd.begin(16,2); //Dimensiones de LCD
lcd.setRGB(colorR, colorG, colorB);
}
//Ciclo infinito
void loop() {
lcd.print(» Visita»); //Mensaje en pantalla
delay(1000); //Por un segundo
lcd.setCursor(0,1); //Nos colocamos en columna 0 fila 1
lcd.print(» TESLABEM.com»); //Mensaje en fila 1
delay(3000); //Por un tiempo nde 3 segundos
lcd.clear(); //Limpiamos pantalla
delay(1000);
}
[/code]
Módulo Buzzer.
A este módulo no es necesario agregarle nada, funciona de la misma manera que un Buzzer común, sólo que sin el conector Grove. Para ver el funcionamiento de este módulo como ejemplo pondremos el código de una famosa canción conocida por todos. Descubre cuál es cargando el código en tu Arduino.
[code language=»java»]
//Definicion de notas
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
#define melodyPin 3
//Mario main theme melody
int melody[] = {
NOTE_E7, NOTE_E7, 0, NOTE_E7,
0, NOTE_C7, NOTE_E7, 0,
NOTE_G7, 0, 0, 0,
NOTE_G6, 0, 0, 0,
NOTE_C7, 0, 0, NOTE_G6,
0, 0, NOTE_E6, 0,
0, NOTE_A6, 0, NOTE_B6,
0, NOTE_AS6, NOTE_A6, 0,
NOTE_G6, NOTE_E7, NOTE_G7,
NOTE_A7, 0, NOTE_F7, NOTE_G7,
0, NOTE_E7, 0, NOTE_C7,
NOTE_D7, NOTE_B6, 0, 0,
NOTE_C7, 0, 0, NOTE_G6,
0, 0, NOTE_E6, 0,
0, NOTE_A6, 0, NOTE_B6,
0, NOTE_AS6, NOTE_A6, 0,
NOTE_G6, NOTE_E7, NOTE_G7,
NOTE_A7, 0, NOTE_F7, NOTE_G7,
0, NOTE_E7, 0, NOTE_C7,
NOTE_D7, NOTE_B6, 0, 0
};
//Mario main them tempo
int tempo[] = {
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
9, 9, 9,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
9, 9, 9,
12, 12, 12, 12,
12, 12, 12, 12,
12, 12, 12, 12,
};
//Underworld melody
int underworld_melody[] = {
NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
NOTE_AS3, NOTE_AS4, 0,
0,
NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
NOTE_AS3, NOTE_AS4, 0,
0,
NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
NOTE_DS3, NOTE_DS4, 0,
0,
NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
NOTE_DS3, NOTE_DS4, 0,
0, NOTE_DS4, NOTE_CS4, NOTE_D4,
NOTE_CS4, NOTE_DS4,
NOTE_DS4, NOTE_GS3,
NOTE_G3, NOTE_CS4,
NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4,
NOTE_GS4, NOTE_DS4, NOTE_B3,
NOTE_AS3, NOTE_A3, NOTE_GS3,
0, 0, 0
};
//Underwolrd tempo
int underworld_tempo[] = {
12, 12, 12, 12,
12, 12, 6,
3,
12, 12, 12, 12,
12, 12, 6,
3,
12, 12, 12, 12,
12, 12, 6,
3,
12, 12, 12, 12,
12, 12, 6,
6, 18, 18, 18,
6, 6,
6, 6,
6, 6,
18, 18, 18, 18, 18, 18,
10, 10, 10,
10, 10, 10,
3, 3, 3
};
void setup(void)
{
pinMode(3, OUTPUT);//buzzer
pinMode(2, OUTPUT);//led indicator when singing a note
}
void loop()
{
//sing the tunes
sing(1);
sing(1);
sing(2);
}
int song = 0;
void sing(int s) {
// iterate over the notes of the melody:
song = s;
if (song == 2) {
Serial.println(» ‘Underworld Theme'»);
int size = sizeof(underworld_melody) / sizeof(int);
for (int thisNote = 0; thisNote < size; thisNote++) {
// to calculate the note duration, take one second
// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / underworld_tempo[thisNote];
buzz(melodyPin, underworld_melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note’s duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
buzz(melodyPin, 0, noteDuration);
}
} else {
Serial.println(» ‘Mario Theme'»);
int size = sizeof(melody) / sizeof(int);
for (int thisNote = 0; thisNote < size; thisNote++) {
// to calculate the note duration, take one second
// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / tempo[thisNote];
buzz(melodyPin, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note’s duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
buzz(melodyPin, 0, noteDuration);
}
}
}
void buzz(int targetPin, long frequency, long length) {
digitalWrite(2, HIGH);
long delayValue = 1000000 / frequency / 2; // calculate the delay value between transitions
//// 1 second’s worth of microseconds, divided by the frequency, then split in half since
//// there are two phases to each cycle
long numCycles = frequency * length / 1000; // calculate the number of cycles for proper timing
//// multiply frequency, which is really cycles per second, by the number of seconds to
//// get the total number of cycles to produce
for (long i = 0; i < numCycles; i++) { // for the calculated length of time…
digitalWrite(targetPin, HIGH); // write the buzzer pin high to push out the diaphram
delayMicroseconds(delayValue); // wait for the calculated delay value
digitalWrite(targetPin, LOW); // write the buzzer pin low to pull back the diaphram
delayMicroseconds(delayValue); // wait again or the calculated delay value
}
digitalWrite(2, LOW);
}
// by: Dipto Pratyaksa
[/code]
Módulo Relé.
El Relé es un interruptor mecánico controlado electrónicamente. Básicamente sirve para poder trabajar con Voltajes elevados. Si se trabaja con tensiones altas se debe tener mucha precaución.
A continuación el ejemplo del interruptor mecánico con Relé.
[code language=»java»]
//Constantes y variables
const int pinboton = 3; //Boton pin digital 3
const int pinrele = 8; // Relé pin digital 8
int estadoboton = 0;
//Configuración inicial
void setup()
{
pinMode(pinrele, OUTPUT); //Relé definido como salida
pinMode(pinboton, INPUT); //Botón definido como entrada
}
//Ciclo infinito
void loop()
{
//Lee el estado del botón
estadoboton = digitalRead(pinboton);
if (estadoboton == 1) //Si el estado del botón es alto
{
digitalWrite(pinrele, HIGH); //El rele se acciona durante 2 segundos
delay(2000);
}
else
{
digitalWrite(pinrele, LOW); //si no es así el rele no acciona
}
delay(10);
}
[/code]
Al momento de pulsar el botón el interruptor operado magneticamente se activa durante 2 segundos y después vuelve a su estado normal.
[nextpage title=»Uso de los módulos de luz, temperatura y sonido»]
Módulo Sensor de Luz.
En el ejemplo que veremos a continuación se encenderá un Led cuando la luz esté por debajo del limite establecido. La salida del sensor de luz en la entrada analógica va desde 0 hasta 1023, pero la salida no es lineal con respecto a la intensidad de la luz ambiental.
En el código de aquí abajo se puede cambiar el limite dependiendo en qué momento se desea encender el Led, para este ejemplo se activa el Led en 400.
[code language=»java»]
//Constantes
const int sensorluz = A0;
const int pinLed = 7;
//Variables
int limite=400; //Limite para encender o apagar el led
void setup(){
pinMode(pinLed, OUTPUT); //Definicion de led como salida
}
void loop(){
int lecturasensor = analogRead(sensorluz); //Lee estado de sensor
//Si es menor a la variable limite
if(lecturasensor < limite)
{
digitalWrite(pinLed, HIGH); //Enciende led
}
else
{
digitalWrite(pinLed, LOW); //Si no el led estara apagado
}
}
[/code]
Módulo Sensor de Sonido.
En esta práctica el Módulo Sensor de Sonido será utilizado para controlar un Led, el cual se iluminara con el sonido ambiental que esté detectando al momento.
[code language=»java»]
//Constantes
const int sensorsonido = A0; //Definicion de pin del sensor
const int pinLed = 5; //Pin del led
//Variables
int limite = 500; //Limite para encener el led
void setup(){
pinMode(pinLed, OUTPUT); //Definicion de led como salida
}
void loop(){
int sensorValue = analogRead(sensorsonido); //Lectura del sensor de sonido
//Si es mayor al limite
if(sensorValue < limite)
//led se enciende
digitalWrite(pinLed,HIGH);
delay(500);
//Si no es asi se mantiene apagado
digitalWrite(pinLed,LOW);
}
[/code]
Módulo Sensor de temperatura.
Ahora utilizaremos el módulo de Temperatura, los datos serán mostrados en grados centígrados (°C) a través del monitor serial del IDE de Arduino y el módulo Buzzer se activará cuando sobrepase los 28°C. Es posible cambiar esta opción en la sección de condiciones.
[code language=»java»]
//Constantes
const int pinsensor = A0; //Pin A0 temperatura
//Variables
float temperature;
int B=3975; //Valor del termistor
float resistance;
int buzzer=7; //Definicion pin led
void setup()
{
Serial.begin(9600); //Comunicacion serial
pinMode(buzzer,OUTPUT); //Definicion de led como salida
}
void loop()
{
int val = analogRead(pinsensor); //Obtencion del valor leido
resistance=(float)(1023-val)*10000/val; //Obtencion del valor de la resistencia
temperature=1/(log(resistance/10000)/B+1/298.15)-273.15; //Calculo de la temperatura
Serial.print(temperature); //Temperatura en pantalla
Serial.println(» Centigrados»);
delay(1000); //Tiempo de lectura cada segundo
//Condiciones
if(temperature > 28){ //Si temperatura es mayor a 28 el led se enciende
digitalWrite(buzzer, HIGH);
}
else{
digitalWrite(buzzer, LOW); //Si no se mantiene apagado
}
}
[/code]
[nextpage title=»Uso de los módulos con sensores táctil, rotatorio y servomomotor con conector Grove»]
Módulo Sensor Táctil (TOUCH).
Esta es una alternativa al botón usado comúnmente. Este módulo Sensor Táctil detecta la variación de la capacitancia en la región circular; mientras más cerca esté el dedo en la región, mayor es el cambio de este valor. Incluso si hay papel entre el dedo y el sensor, todavía funcionará. Este sensor básicamente es igual a un botón.
El siguiente código muestra cómo funciona el sensor haciendo funcionar un Led y Buzzer, guardando el valor cuando se presiona el Sensor Touch, de manera que en cada contacto las salidas serán altas o bajas.
[code language=»java»]
//Constantes
const int sensortactil=8;
const int led=2;
const int buzzer=3;
//Variables
int encender=0;
int estadoanterior=0;
//Configuración inicial
void setup() {
pinMode(sensortactil, INPUT); //Definimos como entrada al sensor
pinMode(led,OUTPUT); //Definimos el led como salida
pinMode(buzzer,OUTPUT); //Definimos el buzzer como salida
}
void loop() {
int lectura = digitalRead(sensortactil); //Letura del sensor
if(lectura && estadoanterior == LOW){ //Si el estado anterior esta en estado bajo
encender = HIGH – encender; //Cambiara el estado de las salidas
}
estadoanterior = lectura;
//Condiciones
if (encender){
digitalWrite(led, HIGH);
digitalWrite(buzzer, HIGH);
}
else
digitalWrite(led, LOW);
digitalWrite(buzzer, LOW);
}
[/code]
Módulo Sensor Rotatorio con Servomotor.
Primero empezaremos utilizando el Sensor Rotatorio (Potenciómetro) para comprender mejor su funcionamiento, el siguiente código hace lo siguiente: Al girar el Sensor Rotatorio se va incrementando su valor hasta llegar a 1023, que es el valor máximo de las entradas analógicas en Arduino. Los valores los vamos a observar a través del monitor serial.
[code language=»java»]
//Constantes
const int potenciometro = A0; //Definicion de pin A0
//Configuración
void setup(){
Serial.begin(9600); //Comunicacion serial
pinMode(potenciometro, INPUT); //Definicion de potenciometro como entrada
}
//Ciclo infinito
void loop(){
int valor = analogRead(potenciometro); //Lectura del sensor
Serial.println(valor); //Imprime le valor del sensor en el monitor serial
delay(100); //muestra el valor cada 100 milisegundos
}
[/code]
Ahora utilizaremos este mismo módulo con el Servomotor, de manera que moveremos el Servomotor conforme giramos el sensor Rotatorio.
[code language=»java»]
//Libreria servo
#include <Servo.h>
Servo servo; //Creación del servo
//Variables
int potenciometro = A0; //Definicion pin potenciometro
int posicion;
//Configuración
void setup()
{
servo.attach(3); //Definición de pin del servo
pinMode(potenciometro, INPUT); //Definimos el potenciómetro como entrada
}
//Ciclo
void loop()
{
posicion = analogRead(potenciometro); //Lectura del potenciómetro
posicion = map(posicion, 0, 1023, 0, 179); //Hacemos un mapaeo ajustando el valor de 0 a 1023
//y lo cambiamos de 0 a 180 que es lo que gira el servomotor
servo.write(posicion); //El servo gira de acuerdo al pot ya con el valor ajustado 0 a 180
delay(15);
}
[/code]
Como vimos en las prácticas anteriores si utilizamos los módulos del Sistema Grove Starter Kit es mucho más sencillo aprender, evitando elaborar muchas conexiones de componentes, además se reduce espacio al no utilizar el famoso protoboard, gracias a los conectores estandar con los que cuenta cada uno de los accesorios del Grove Starter Kit.
La ventaja más importante y que vale la pena señalar en este sistema, es que el usuario va a enfocar sus esfuerzos para aprender a desarrollar programas, entender los conceptos de electrónica y microconotroladores, y principalmente adquirir habilidades en la integración de proyectos invirtiendo el menor tiempo en la elaboración de circuitos, para mejor aprovecharlo en la elaboración de muchas prácticas. Recuerda, la práctica hace al maestro.
El Grove Starter Kit es muy sencillo de usar y ampliamente recomendado. Puedes adquirirlo ahora haciendo clic aquí.
