El servo es un motor paso a paso. Nos permite mantener una posición que indiquemos, y nos permite controlar la velocidad de giro. Se puede hacer

Características técnicas de un servomotor;

Características:

Peso: 9 g

Dimensiones: 22.2 x 11.8 x 31 mm aprox.

Par de torque: 1.8 kgf·cm

Velocidad de movimiento: 0.1 s/60º

Voltaje de funcionamiento: 4.8 V (~5V)

Temperatura de funcionamiento: 0 ºC – 55 ºC

Todos tienen un funcionamiento muy parecido y la programación puede variar muy poco.

Hay que tener en cuenta:

• El angulo de giro, permite hacer un barrido entre -90º y 90º. Lo que viene a ser un ángulo de giro de 180º.
• Tiene una precisión de un grado es decir, podemos mover de grado en grado.
• Funcionan con una señal PWM, con un pulso de trabajo entre 1 ms y 2 ms y con un periodo de 20 ms (50 Hz). Indica que la velocidad máxima a la que podemos mover el servomotor con Arduino. Solo podremos cambiar de posición cada 20 ms.

• Las conexiones dependerán del tipo de servomotor, Tienen tres cables, uno irá a tierra, otro a la alimentación de 5 Voltios y el tercero a un pin PWM.

¿Cómo programar un servo?

El código para girar el motor de 0º a 180º

Comprobamos que tenemos instalada la librería servo.h, en caso contrario la instalaremos.

En los ejemplos hay uno, que hace girar el servo de 0º a 180º y después hacer el giro inverso.

Lo pongo a continuación pero traducido al español.

/* Sweep

by BARRAGAN <http://barraganstudio.com>
This example code is in the public domain. modified 8 Nov 2013
by Scott Fitzgerald
http://www.arduino.cc/en/Tutorial/Sweep
Traducido por Manuel EA7TB
*/

#include <Servo.h> // Incluímos la librería para poder controlar el servo
Servo myservo; // // Declaramos la variable para controlar el servo
int pos = 0; // Declaramos la variable para determinar la posicion.

void setup() {
     myservo.attach(9); // Iniciamos el servo para que empiece a trabajar con el pin 9
}

void loop() {
     // movemos de 0º a 180º, de grado en grado
     for (pos = 0; pos <= 180; pos += 1) {
         myservo.write(pos); // Indicamos la posicion al servo, con la variable pos.
         delay(15); // esperamos 15ms para indicarle al servo su nueva posicion,
      }
      delay(1000); // retardo para que gire en direccion contraria
      // movemos de 180º a 0º, de grado en grado
      for (pos = 180; pos >= 0; pos -= 1) {
           myservo.write(pos); // Indicamos la posicion al servo, con la variable pos.
          delay(15); // esperamos 15ms para indicarle al servo su nueva posicion,
      }
      delay(1000); // retardo para que vuelva a empezar.
}

De la librería Servo.h hemos declarado un objeto o variable servoMotor y hacemos uso de dos métodos:

• myservo.attach, que nos permite indicar en que pin tenemos conectado el servo
• myservo.write, donde le indicamos a qué ángulo se debe posicionar.

Fácil, no?.

Para posicionarlo en un punto determinado, solo hay que poner.

myservo.write(pos);

el valor de pos debe estar entre 0 y 180

Sensor de temperatura y humedad

Por eso se desarrollaron los sensores de la familia DHT. Nos proporcionan de forma digital la temperatura y la humedad, con diferente precisión según el modelo.

Básicamente hay dos variantes DHT11

Las características del DHT11 son:

• Muy barato, sobre 2€
• Funciona con 3,3 y 5V de alimentación
• Rango de temperatura: de 0º a 50º con 5% de precisión (pero solo mide por grados, no fracciones)
• Rango de humedad: de 20% al 80% con 5% de precisión
• 1 Muestra por segundo (No es el más rápido del oeste)
• Bajo consumo
• Devuelva la medida en ºC

Destacar que el chip incorpora electrónica para hacer internamente la conversión de temperatura y humedad y nos da un valor de medida de forma digital, es decir, que no necesitamos un pin analógico.

El Programa de lectura del DHT11

En primer lugar, tenemos que descargar una librería para manejarlos cómodamente, DX11.zip e importarla. Aquí teneís la librería DHT11.zip

Hacemos el importar la librería DHT11 que nos pondrá:

#include <DHT11.h>

Y definimos una instancia del sensor donde declaramos el pin al que esta conectado.

int pin=2; 

DHT11 dht11(pin);

Leerlo ahora es muy sencillo:

int error ; 

float temp, humi; 

error = dht11.read(humi, temp)

Basta con hacer dht11.read pasandole las variables donde queremos el resultado, y comprobamos que no haya errors (Siempre es buena idea comprobar que no hay error cuando hacemos una llamda).

Código:

#include <DHT11.h> 
int pin=2; 
DHT11 dht11(pin); 

void setup() 
   { 
       Serial.begin(9600); 
   } 

void loop() 
   { 
       int err; 
       float temp, hum; 
       if((err = dht11.read(hum, temp)) == 0) // Si devuelve 0 es que ha leido bien 
          { 
             Serial.print("Temperatura: "); 
             Serial.print(temp); 
             Serial.print(" Humedad: "); 
             Serial.print(hum); 
             Serial.println(); 
          } 
       else 
          { 
             Serial.println(); 
             Serial.print("Error Num :"); 
             Serial.print(err); 
             Serial.println(); 
          } 
       delay(1000); // lee una vez por segundo 
   }

El resultado se envía a la consola.

Para hacer variar los valores, de humedad y temperatura y comprobar que todo funciona correctamente, podeis, sencillamente, enviar vuestro aliento al sensor, subirá tanto la temperatura como la humedad.

Libreria:

La librería que viene en nuestra ayuda se llama keypad.h. Esta librería no viene de forma estándar con la distribución del compilador de Arduino. Así que tenemos que descargarla desde la web. http://playground.arduino.cc/code/Keypad 

Conexiones

Código

//* Teclado4x3.ino 

 *  Comprobacion de que el numero pulsado, se muestra en el monitor seria. 

 *  Libreria: Keypad.h 

 *  Definimos dos constantes, para las filas (Fila) y columnas (Colu) 

 *  y una matriz con los caracteres del teclado. 

 */ 

#include <Keypad.h> //libreria. 

const byte Fila = 4;   // numero de filas 

const byte Colu = 3;  // numero de columnas 

char keys[Fila][Colu] = { 
  {'1', '2', '3'}, 
  {'4', '5', '6'}, 
  {'7', '8', '9'}, 
  {'*', '0', '#'} 
}; 

byte PinFilas[Fila] = {8, 9, 10, 11};  // indicamos a que pines estan conectados las Filas 
byte PinColum[Colu] = {12, 13, 14};  // indicamos a que pines estan conectados las columnas 

//creamos un objeto de la libreria keypad para usar sus funciones 

Keypad keypad = Keypad( makeKeymap(keys), PinFilas, PinColum, Fila, Colu ); 

void setup() { 
  Serial.begin(9600); // Definimos la velocidad del puerto serial. 
} 

void loop() { 
  //cuando se pulse una tecla, se guardará en una variable llamada key 
  char key = keypad.getKey(); 
  //Si se ha pulsado una tecla, se envia por serial 
  if (key != NO_KEY) { 
    Serial.println(key); 
  } 
}

Explicación

El primer paso es incluir la librería y las constantes que vamos a utilizar:

const byte Fila = 4;   // numero de filas 

const byte Colu = 3;  // numero de columnas

Reservamos memoria en bytes, para los valores de los pulsadores y la asignación del pin que se corresponde con los de Arduino. Sin embargo, hay que observar que, vamos a necesitar un número alto de pines en este y los siguientes ejemplos.

byte PinFilas[Fila] = {8, 9, 10, 11};  // indicamos a que pines estan conectados las Filas 

byte PinColum[Colu] = {12, 13, 14};  // indicamos a que pines estan conectados las columnas

Este es el momento de ‘crear’ el teclado propiamente dicho, es decir, con esta sentencia, el programa generará una matriz que verá como un teclado, al que se remitirá, cuando tenga que representar un dígito. Esto se consigue con la siguiente línea:

Keypad keypad = Keypad( makeKeymap(keys), PinFilas, PinColum, Fila, Colu );

Arduino Zumbador

Si conectamos un piezo con una señal digital, vibran a una frecuencia sigue bastante fielmente la variación eléctrica con que los excita, y si vibran a la frecuencia audible, oiremos el sonido que producen. A un componente que hace esto, le llamamos Buzzer o zumbador.

Naturalmente, la calidad del sonido que producen dista bastante de lo que podríamos denominar alta fidelidad. Pero es suficiente para generar tonos audibles (como la típica alarma de los despertadores digitales) e incluso tonos musicales reconocibles que podemos secuenciar.

En esta sesión, montaremos un circuito muy sencillo con un zumbador

La conexión es tan simple como conectar negativo a GND y positivo al pin 9. De todas maneras hay que tener cuidado. Los piezos tienen polaridad y hay que asegurarse de conectarlos correctamente.

• Si los conectáis al revés, simplemente no sonará, y tendréis que dar la vuelta.
• Además para este primer montaje, necesitamos usar un pin PWM (como el 9) porque es la alternancia entre HIGH y LOW lo que produce el efecto piezoeléctrico (recordad que una señal PWM envía un tren de ondas cuadradas de amplitud variable), por lo que lo más cómodo es usar un pin PWM en lugar de programar un efecto equivalente en un pin normal.

El Programa

Vamos a empezar creando una función, Beep(), que haga ruido simplemente:

void beep(unsigned char pausa)

        { 

            analogWrite(9, 20); 

            delay(pausa);            // Espera 

            analogWrite(9, 0);         // Apaga 

            delay(pausa);              // Espera 

        }

Y ahora prueba

     void setup() 

        { 

            pinMode(9, OUTPUT); 

            beep(50); 

            beep(50); 

            beep(50); 

            delay(1000); 

        } 

     void loop() 

       {    beep(200); 

       }

Lo único que beep () hace es poner una señal PWM en el pin 9 de 20 sobre 255. Podéis varias el valor, pero el tono de audio no cambiará gran cosa porque está controlado por la señal de base. Esto es suficiente para generar una de las molestas señales acústicas de un despertador barato.

¿Qué pasa si quiero generar señales de tono variable para hacer una melodía? Bueno pues Arduino dispone de la función tone() que genera una señal de la frecuencia indicada, y notone() que la corta:

     void setup() 

        { 

            int pinOut = 8; 

            int freq = 440; 

            int duracion = 1000; 

            tono(pinOut, freq, duracion); 
         }

La función tone() genera un audio de la frecuencia y duración definidas.

Podemos definir una matriz con las frecuencias de las notas a utilizar  y lee las correspondencias con las notas musicales. Veamos cómo generar una escala con un zumbador:

     int speakerPin = 9; 

     int numTonos = 10; 

     int tonos[ ] = {261, 277, 294, 311, 330, 349, 370, 392, 415, 440,466, 494}; 
     // mid C C# D D# E F F# G G# A 
    void setup() 
         { }
    void loop() 
         { 
             for (int i = 0; i < numTonos; i++) 
                 { 
                    tone(speakerPin, tonos[i]); 
                    delay(500); 
                 } 
            noTone(speakerPin); 
       }