Hiparco

Recetas y trucos de GNU/Linux e informática en general

Alojado en http://guimi.net

Un robot con Arduino por menos de 70 euros

Hace unos días participé en el Olympic Robotic Challenge 2.14 con mi primer robot, basado en Arduino, y con un coste inferior a 70 euros y un peso de unos 320 gramos.
El robot quedó tercero en la prueba de velocidad (sigue-lineas).

Hay un monton de información de robots económicos realizados con Arduino.
Si quieres puedes ver cómo hice el mio paso a paso, incluyendo la lista de componentes y el programa final en: Un robot con Arduino

Arduino: Sensores de linea

El circuito (realizado con Fritzing):

Utiliza la libreria TocaMelodia, pero puede eliminarse fácilmente comentado las lineas correspondientes.

/*
 * Este programa lee dos sensores de seguimiento (tracking sensor)
 * e indica la ruta a seguir
 *
 * 2014 - Guimi (http://guimi.net)
 */

#include <TocaMelodia.h>

// VARIABLES
//----------
const byte sensorIzq=3; // Constante que indica el pin del sensor Izquierdo
const byte sensorDer=2; // Constante que indica el pin del sensor Derecho
const byte altavoz=4; // Constante que indica el pin del altavoz

byte valorIzq=0; // Variable para guardar el valor del sensor Izquierdo [0 Negro; 1 Blanco]
byte valorDer=0; // Variable para guardar el valor del sensor Derecho [0 Negro; 1 Blanco]

byte estado=0; // 0 en marcha; 1 finalizado
byte direccion=0; // Variable que indica la direccion a seguir
                  // 0 - Quieto
                  // 1 - Izquierda
                  // 2 - Delante
                  // 3 - Derecha
                  // 9 - Final

TocaMelodia tocaMelodia(altavoz);

// FUNCION SETUP
//--------------
void setup(){
  // Definimos cada pin como entrada o salida
  pinMode(sensorIzq,INPUT);
  pinMode(sensorDer,INPUT);

  // Preparamos la comunicacion mediante el puerto serie
  Serial.begin(9600);

  tocaMelodia.toca(MELODIA_FANFARRIA);
}

// FUNCION LOOP
//-------------
void loop(){
  // Mientras el estado sea funcionando
  while (estado = 0) {
    // Leemos el valor de los sensores [0-1]
    valorIzq=digitalRead(sensorIzq);
    valorDer=digitalRead(sensorDer);

    // Mostramos informacion
    Serial.print("Izquierda:");
    Serial.print(valorIzq);
    Serial.print("; Derecha:");
    Serial.print(valorDer);

    // Establecemos direccion en base a las lecturas
    if (valorIzq && valorDer) { movimiento(2); } // Delante
    else if (valorIzq && !valorDer) { movimiento(3); } // Derecha
    else if (!valorIzq && valorDer) { movimiento(1); } // Izquierda
    else {movimiento(0);} // Quieto

    // Esperamos un tiempo de reaccion para los componentes
    delay(50);
  }

  //while(1); // Bucle infinito para parar el programa
}

void movimiento(byte direccion) {
  Serial.print("; Direccion:");
  switch(direccion){
    case 0:
      Serial.println("Quieto");
      tocaMelodia.toca(MELODIA_PODER_PERRUNO);
      delay(2000);
      estado=1;
      break;
    case 1:
      Serial.println("Izquierda");
      break;
    case 2:
      Serial.println("Delante");
      break;
    case 3:
      Serial.println("Derecha");
      break;
  }
}

Arduino: Libreria TocaMelodia para tocar melodias predeterminadas

Vamos a crear a modo de ejemplo una libreria para tocar melodías predeterminadas con un piezo-electrico o un altavoz (Tutorial de Arduino de creación de librerías).

Las librerías que queramos usar en nuestros programas deben estar en la ruta del IDE o en la carpeta sketchbook del usuario [configurable]:
/usr/share/arduino/libraries
~/sketchbook/libraries

Dentro de la carpeta de librerias se genera una carpeta con el nombre la nueva librería, en este caso TocaMelodia.
A su vez, dentro de esa carpeta se crea una carpeta “examples”, un archivo keywords.txt, un archivo TocaMelodia.cpp y un archivo TocaMelodia.h (los dos primeros son opcionales).

Dentro de la carpeta “examples” se pueden incluir códigos de ejemplo, en la forma habitual de arduino, es decir, dentro de su propia carpeta con el mismo nombre.
El archivo keywords.txt contiene palabras que queremos que el editor resalte.
El archivo .h contiene las cabeceras y el archivo .cpp contiene el código de la librería.

Descargar la libreria completa (código).

Archivo TocaMelodia.h:

/*
  TocaMelodia.h - Libreria para tocar melodias pre-establecidas.
  Guimi (http://guimi.net)
  Released into the public domain.

  Based on ToneMelody by Tom Igoe
*/

// Para evitar que se incluya la libreria dos veces, solo incluyo la libreria si
// no está definida la variable TocaMelodia_h
#ifndef TocaMelodia_h
// defino la variable TocaMelodia_h
#define TocaMelodia_h

#include "Arduino.h"

// List of tones by Brett Hagman
#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 NOTA_CORCHEA 125
#define NOTA_CORCHEA_PAUSA 175
#define NOTA_NEGRA 250
#define NOTA_NEGRA_PAUSA 330
#define NOTA_BLANCA 500
#define NOTA_BLANCA_PAUSA 660
#define NOTA_REDONDA 1000
#define NOTA_REDONDA_PAUSA 1320

#define MELODIA_FANFARRIA 0
#define MELODIA_PODER_PERRUNO 1
#define MELODIA_ENCUENTROS_3A_FASE 2
#define MELODIA_R2D2 3
#define MELODIA_OHHH 4
#define MELODIA_UHOH 5

// Definimos la clase TocaMelodia
class TocaMelodia {
	public:
		// Constructor
		TocaMelodia(int pin);
		// Las funciones a utilizar
		void melodia(int melodia);
	private:
		// Variable interna para guardar el pin del altavoz
		int _pin; // Pin del altavoz
		void Glis(int note1, int note2, int rate); // Glissando
		void Trem(int note1, int note2, int rate); // Tremolo
		// Las funciones a utilizar
		void melodia0(); // MELODIA_FANFARRIA 0
		void melodia1(); // MELODIA_PODER_PERRUNO
		void melodia2(); // MELODIA_ENCUENTROS_3A_FASE
		void melodia3(); // MELODIA_R2D2
		void melodia4(); // MELODIA_R2D2
		void melodia5(); // MELODIA_R2D2
};

// Finalizo la opcion de compilacion
#endif

Archivo TocaMelodia.cpp:

/*
  TocaMelodia.cpp - Libreria para tocar melodias pre-establecidas.
  Guimi (http://guimi.net)
  Released into the public domain.

  Based on work by Brett Hagman (pitches.h), Tom Igoe (ToneMelody), Erik Kringen and Dave Tucker
*/

#include "Arduino.h"
#include "TocaMelodia.h"

// Constructor
TocaMelodia::TocaMelodia(int pin) {
  // Definimos el pin como de salida
  pinMode(pin, OUTPUT);
  // Guardamos el pin indicado en la variable de la clase
  _pin = pin;
}

void TocaMelodia::melodia(int melodia) {
  switch(melodia){
    case 0:
      melodia0();
      break;
    case 1:
      melodia1();
      break;
    case 2:
      melodia2();
      break;
    case 3:
      melodia3();
      break;
    case 4:
      melodia4();
      break;
    case 5:
      melodia5();
      break;
  }
}

void TocaMelodia::melodia0() { // MELODIA_FANFARRIA 0
  tone(_pin, NOTE_C4, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_G3, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_G3, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_A3, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_G3, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, 0, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_B3, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C4, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  delay(10);
}

void TocaMelodia::melodia1() { // MELODIA_PODER_PERRUNO
  tone(_pin, NOTE_B4, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_B4, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_B4, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS5, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_B4, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS5, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  delay(10);
}

void TocaMelodia::melodia2() { // MELODIA_ENCUENTROS_3A_FASE
  // Based on work by Erik Kringen
  //http://www.mycontraption.com/sound-effects-with-and-arduino/
  tone(_pin, NOTE_AS5, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C6, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS4, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS3, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_DS5, NOTA_BLANCA); delay (NOTA_BLANCA_PAUSA); noTone(_pin);
  delay (500);

  tone(_pin, NOTE_AS4, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C5, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS3, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS2, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_DS4, NOTA_BLANCA); delay (NOTA_BLANCA_PAUSA); noTone(_pin);
  delay (500);

  tone(_pin, NOTE_AS3, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C4, NOTA_NEGRA); delay (NOTA_NEGRA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS2, NOTA_BLANCA); delay (NOTA_BLANCA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_GS1, NOTA_BLANCA); delay (NOTA_BLANCA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_DS3, NOTA_REDONDA); delay (NOTA_REDONDA_PAUSA); noTone(_pin);
  delay(10);
}

void TocaMelodia::melodia3() { // MELODIA_R2D2
  // Based on work by Erik Kringen and Dave Tucker
  //http://www.mycontraption.com/sound-effects-with-and-arduino/
  //http://dtucker.co.uk/make/arduino-using-my-melodyutils-library-for-r2-d2-style-chirps.html
  tone(_pin, NOTE_A7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_G7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_E7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_D7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_B7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_F7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C8, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_A7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_G7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_E7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_D7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_B7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_F7, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  tone(_pin, NOTE_C8, NOTA_CORCHEA); delay (NOTA_CORCHEA_PAUSA); noTone(_pin);
  delay(10);
}

void TocaMelodia::melodia4() { // MELODIA_OHHH
  Glis(NOTE_C6, NOTE_C7, 6);
  Glis(NOTE_C7, NOTE_C6, 5);
  //for (int i=1000; i<2000; i=i*1.02) { tone(_pin,i,10); };
  //for (int i=2000; i>1000; i=i*.98) { tone(_pin,i,10); delay(10);};
}

void TocaMelodia::melodia5() { // MELODIA_UHOH
  Glis(NOTE_C6, NOTE_DS6, 6);
  delay(200);
  Glis(NOTE_DS6, NOTE_CS6, 5);
  //for (int i=1000; i<1244; i=i*1.01) { tone(_pin,i,30); };
  //delay(200);
  //for (int i=1244; i>1108; i=i*.99) { tone(_pin,i,30);  delay(30);};

}

void TocaMelodia::Glis(int nota1, int nota2, int tasa) {
  // By Dave Tucker
  //http://dtucker.co.uk/make/arduino-using-my-melodyutils-library-for-r2-d2-style-chirps.html
  // Glissando = Slide
  // Slides up or down from note1 to note2
  // rate = 0 is fast and can be increased to slow the effect down

  if (nota1 < nota2) { //Slide up
    for (int nota = nota1; nota < nota2; nota++) {
      tone(_pin, nota, tasa); delay (tasa); noTone(_pin);
    }
  } else { //Slide down
    for (int nota = nota1; nota > nota2; nota--) {
      tone(_pin, nota, tasa); delay (tasa); noTone(_pin);
    }
  }
  noTone(_pin);
}

void TocaMelodia::Trem(int note, int length, int rate) {
  // By Dave Tucker
  //http://dtucker.co.uk/make/arduino-using-my-melodyutils-library-for-r2-d2-style-chirps.html
  // Tremolo = Fast repetition of a note
  // note = the note (from pitches.h)
  // length = duration of the effect in msec
  // rate = number of repetitions

  int note_duration = length/rate;
  int pauseBetweenNotes = rate * (1 + rate/length);

  for (int i = 0; i <= rate; i++) {
    tone(_pin, note, note_duration);
    delay(pauseBetweenNotes);
    noTone(_pin);
  }
}

Archivo keywords.txt:

TocaMelodia	KEYWORD1
melodia	KEYWORD2

Arduino: Motor DC con potenciómetro y conmutadores

El circuito (realizado con Fritzing):

/*
 * Este programa mueve un motor de corriente continua usando un H-Bridge.
 * Con dos pulsadores se controla encendido/apagado y sentido de giro.
 * Con un potenciometro se controla la velocidad de giro.
 *
 * 2014 - Guimi (http://guimi.net)
 */

// VARIABLES
//----------
const byte pin1Motor1=5; // Variable que indica el pin 1 del motor 1
const byte pin2Motor1=9; // Variable que indica el pin 2 del motor 1
const byte pinVelocidadMotor1=10; // Variable que indica el pin de la señal de velocidad del motor 1
const byte pinSwitchEncendido=11; // Variable que indica el pin del boton de encendido/apagado
const byte pinSwitchSentido=12; // Variable que indica el pin del boton de sentido de giro
const byte pinLed=13; //Variable que indica el pin del LED
const byte pinPotenciometro=A0; // Variable que indica el pin del potenciometro

byte valorSwitchEncendido=0; // Variable para leer el switch
byte valorSwitchSentido=0; // Variable para leer el switch
byte valorSwitchEncendidoAnterior=0; // Como entre bucles el periodo es muy corto, cada pulsacin podra leerse muchas veces...
byte valorSwitchSentidoAnterior=0; // ...por ello guardamos un estado anterior
int valorPotenciometro=0; // Variable para guardar el valor del potenciometro [0-1023]

byte estaEncendido=0; // Variable para guardar el estado encendido/apagado
byte sentidoGiro=0; // Variable para guardar el sentido de giro
byte motorVelocidad=0; // Variable para guardar la velocidad segn el potenciometro

// FUNCION SETUP
//--------------
void setup(){
  // Definimos cada pin como entrada o salida
  pinMode(pin1Motor1,OUTPUT);
  pinMode(pin2Motor1,OUTPUT);
  pinMode(pinVelocidadMotor1,OUTPUT);
  pinMode(pinSwitchEncendido,INPUT);
  pinMode(pinSwitchSentido,INPUT);
  pinMode(pinLed,OUTPUT);

  // Paramos el motor 1
  digitalWrite(pinVelocidadMotor1, 0);

  // Indicamos con el LED si estaEncendido
  digitalWrite(pinLed, estaEncendido);

  // Preparamos la comunicacion mediante el puerto serie
  //Serial.begin(9600);
}

// FUNCION LOOP
//-------------
void loop(){
  // Leemos el switch de encendido/apagado
  valorSwitchEncendido=digitalRead(pinSwitchEncendido);
  delay(1);

  // Leemos el switch de sentido de giro
  valorSwitchSentido=digitalRead(pinSwitchSentido);
  delay(1);

  // Leemos el valor del potenciometro [0-1023]
  valorPotenciometro=analogRead(pinPotenciometro);
  motorVelocidad = valorPotenciometro/4;

  // Si se pulsa el boton de encendido/apagado se cambia el estado
  if ((valorSwitchEncendido == HIGH) && (valorSwitchEncendidoAnterior == LOW)) {
    estaEncendido = !estaEncendido;

     // Indicamos con el LED si estaEncendido
    digitalWrite(pinLed, estaEncendido);
  }
  // Obligamos a pasar por una fase LOW antes de volver a leer un HIGH
  // para no leer una sola pulsacion varias veces
  valorSwitchEncendidoAnterior = valorSwitchEncendido;

  // Si se pulsa el boton de sentido de giro se cambia el sentido
  if ((valorSwitchSentido == HIGH) && (valorSwitchSentidoAnterior == LOW)) {
    // Para evitar dañar el motor, solo permitimos cambiar el sentido de giro con el motor parado
    if (!estaEncendido) sentidoGiro = !sentidoGiro;
  }
  // Obligamos a pasar por una fase LOW antes de volver a leer un HIGH
  // para no leer una sola pulsacion varias veces
  valorSwitchSentidoAnterior = valorSwitchSentido;

  /*
  // Mostramos informacion por el puerto serie
  //Serial.print(valorSwitchEncendido);
  //Serial.print(" - ");
  //Serial.print(valorSwitchEncendidoAnterior);
  //Serial.print(" - ");
  Serial.print(estaEncendido);
  Serial.print(" | ");
  //Serial.print(valorSwitchSentido);
  //Serial.print(" , ");
  //Serial.print(valorSwitchSentidoAnterior);
  //Serial.print(" , ");
  Serial.print(sentidoGiro);
  Serial.print(" | ");
  Serial.print(valorPotenciometro);
  Serial.print(" | ");
  Serial.println();
  */

  if (sentidoGiro == 1) {
    digitalWrite(pin1Motor1, LOW);
    digitalWrite(pin2Motor1, HIGH);
  } else {
    digitalWrite(pin1Motor1, HIGH);
    digitalWrite(pin2Motor1, LOW);
  }

  if (estaEncendido == 1) {
    analogWrite(pinVelocidadMotor1, motorVelocidad);
  } else {
    analogWrite(pinVelocidadMotor1, 0);
  }

  // Esperamos un tiempo de reaccion para los componentes
  //delay(5);
}

Arduino: Theremin de luz

El circuito (realizado con Fritzing):

/*
 * Este programa lee el valor de un sensor (fotoresistencia o sensor de luz) y vuelca una frecuencia
 * en un vibrador piezo-electrico, que emite distinto sonido segn la luz recibida.
 * Ademas al inicio del programa se realiza una calibracion del sensor.
 *
 * Basado en Arduino Projects Book
 *
 * 2014 - Guimi (http://guimi.net)
 */

// VARIABLES
//----------
const byte led=13; // Usamos el LED de la placa para indicar el periodo de calibracion.
const byte sensor=0; // Variable que indica el pin del sensor (fotoresistencia, LDR o sensor de luz)
const byte altavoz=12; // Constante que indica el pin del altavoz

int valorSensor=0; // Variable para guardar el valor del sensor [0-1023]
int valorMax=0;    // Variable que guarda el valor maximo, para calibracion.
int valorMin=1023; // Variable que guarda el valor maximo, para calibracion.

const byte duracion=10; // Variable que almacena la duracion del sonido, y marca la pausa entre iteraciones del bucle
int frecuencia=50; // Variable que guarda el valor de frecuencia que debe emitir el piezo-electrico.

// FUNCION SETUP
//--------------
void setup(){
  // Definimos cada pin como entrada o salida
  pinMode(led,OUTPUT);
  pinMode(sensor,INPUT);

  // Encendemos el LED para indicar que estamos calibrando
  digitalWrite(led, HIGH);

  // En un bucle, durante 5 segundos guardamos el valor mas alto y el valor mas bajo leidos
  // El usuario, durante la calibracion, deja que el sensor reciba la maxima y la minima luz posible
  while (millis()<5000) {
    // Leemos el valor del sensor
    valorSensor=analogRead(sensor);

    // Guardamos el valor maximo leido
    if (valorSensor>valorMax) {
      valorMax=valorSensor;
    }

    // Guardamos el valor minimo leido
    if (valorSensor<valorMin) {
      valorMin=valorSensor;
    }

  }

  // Apagamos el LED para indicar que ya no estamos calibrando
  digitalWrite(led, LOW);

  // Preparamos la comunicacion mediante el puerto serie
  //Serial.begin(9600);
}

// FUNCION LOOP
//-------------
void loop(){
  // Cuanta mas luz recibe, menor es la resistencia y el valor leido
  // Valores leidos: 550-750 muy iluminado; 885-895 luz normal; >990 tapado con el dedo

  // Si invertimos la polaridad, cuanta mas luz recibe, mayor es el valor leido
  // <30 tapado con el dedo; unos 150 con luz normal y unos 300 muy iluminado

  // Leemos el valor del sensor [0-1023]
  valorSensor = analogRead(sensor);
  // Mostramos informacion por el puerto serie
  //Serial.println(valorSensor);
  // Convertimos el valor leido a la frecuencia a emitir, teniendo en cuenta los datos de calibracion
  frecuencia = map(valorSensor, valorMin, valorMax, 50, 4000);
  // Enviamos la senal al piezo para que emita sonido
  tone(altavoz,frecuencia,duracion*2);

  // Esperamos un tiempo de reaccion para los componentes
  delay(duracion);
}
 

Arduino: Motor servo con potenciómetro

El circuito (realizado con Fritzing):

/*
 * Este programa mueve un servomotor en relacion a la lectura de un sensor (potenciometro).
 *
 * 2014 - Guimi (http://guimi.net)
 */

// LIBRERIAS
//----------
#include <Servo.h> // Libreria de Arduino para Servomotores

// VARIABLES
//----------
Servo servo1; // Nuestro servo 1
const byte sensor=0; // Variable que indica el pin del sensor (potenciometro)
int valorSensor=0; // Variable para guardar el valor del sensor [0-1023]

// FUNCION SETUP
//--------------
void setup(){
  // Definimos cada pin como entrada o salida
  pinMode(sensor,INPUT);

  servo1.attach(9); // Indicamos el pin utilizado para el servo

  // Preparamos la comunicacion mediante el puerto serie
  Serial.begin(9600);
}

// FUNCION LOOP
//-------------
void loop(){
  // Leemos el valor del sensor [0-1023]
  valorSensor=analogRead(sensor);
  // El servo solo gira entre 0 y 180 grados
  valorSensor=map(valorSensor,0,1023,0,179);
  Serial.println(valorSensor);

  servo1.write(valorSensor); // Indicamos los grados en el servo

  // Esperamos un tiempo de reaccion para los componentes
  delay(200);
}

Arduino: Lectura de un sensor de luz (fotoresistencia)

El circuito (realizado con Fritzing):

/*
 * Este programa lee el valor de un sensor (fotoresistencia o sensor de luz).
 *
 * 2014 - Guimi (http://guimi.net)
 */

// VARIABLES
//----------
const byte sensor=0; // Variable que indica el pin del sensor (fotoresistencia, LDR o sensor de luz)
int valorSensor=0; // Variable para guardar el valor del sensor [0-1023]

// FUNCION SETUP
//--------------
void setup(){
  // Definimos cada pin como entrada o salida
  pinMode(sensor,INPUT);

  // Preparamos la comunicacion mediante el puerto serie
  Serial.begin(9600);
}

// FUNCION LOOP
//-------------
void loop(){
  // Cuanta mas luz recibe, menor es la resistencia y el valor leido
  // Valores leidos: 550-750 muy iluminado; 885-895 luz normal; >990 tapado con el dedo

  // Si invertimos la polaridad, cuanta mas luz recibe, mayor es el valor leido
  // <30 tapado con el dedo; unos 150 con luz normal y unos 300 muy iluminado

  // Leemos el valor del sensor [0-1023]
  valorSensor = analogRead(sensor);
  // Mostramos informacion por el puerto serie
  Serial.println(valorSensor);

  // Esperamos un tiempo de reaccion para los componentes
  delay(100);
}

Arduino: Sensor Eco y pantalla LCD

El circuito (realizado con Fritzing):

/*
 * Este programa lee el valor de un sensor (Utiliza eco por ultrasonido para medir distancias)
 * y lo muestra por un LCD de 16x2.
 *
 * 2014 - Guimi (http://guimi.net)
 */

// LIBRERIAS
//----------
// Para compilar, la libreria debe copiarse a /usr/share/arduino/libraries
// o -segun la version del IDE- <sketchbook>/libraries
#include <Ultrasonic.h> // http://www.ardublog.com/library-for-arduino-ultrasonic-ranging-hc-sr04/
#include <LiquidCrystal.h> // Libreria de arduino para LCD

// VARIABLES
//----------
Ultrasonic ultrasonic(9,8); // (Trig PIN,Echo PIN)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Iniciamos la libreria con los numeros de los pins
int valorSensor=0; // Variable para guardar el valor del sensor [0-1023]

// FUNCION SETUP
//--------------
void setup() {
  lcd.begin(16, 2); // 16 caracteres * 2 lineas
}

// FUNCION LOOP
//-------------
void loop(){
  // Leemos el valor del sensor que tiene un angulo de 30 grados.
  // Para esta libreria el rango es entre 1 y 51 centimetros (espera maxima entre Trig y Eco 30 ms).
  lectura=ultrasonic.Ranging(CM); // CM or INC
  // Mostramos informacion por el LCD
  lcd.clear(); // Limpiamos el LCD
  lcd.setCursor(0, 0); // Nos situamos en el primer caracter de la primera linea
  lcd.print(lectura); // Escribimos
  lcd.print("cm"); // Escribimos
  lcd.setCursor(0, 1); // Nos situamos en el primer caracter de la segunda linea
  lcd.print(millis()/1000); // Escribimos el numero de segundos desde reset de la placa. Se reinicia cada 50 dias.

  // Esperamos un tiempo de reaccion para los componentes
  delay(100);
}

Arduino: LED con potenciómetro

El circuito (realizado con Fritzing):

/*
 * Este programa cambia la intensidad de un LED en base al valor de un potenciometro.
 *
 * 2014 - Guimi (http://guimi.net)
 */

// VARIABLES
//----------
const byte led=5; // Variable que indica el pin del led
const byte sensor=0; // Variable que indica el pin del sensor (potenciometro)
int valorSensor=0; // Variable para guardar el valor del sensor [0-1023]

// FUNCION SETUP
//--------------
void setup() {
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
  pinMode(sensor, INPUT);     

  // Preparamos la comunicacion mediante el puerto serie
  //Serial.begin(9600);
}

// FUNCION LOOP
//-------------
void loop() {
  // Leemos el valor del sensor [0-1023]
  valorSensor=analogRead(sensor);
  // Mostramos informacion por el puerto serie
  //Serial.print("sensor = " );
  //Serial.println(sensorValue);      

  // La lectura analogica es de 0-1023
  // La escritura PWM es de 0-255
  valorSensor=map(valorSensor,0,1023,0,255); // Este comando hace una regla de 3 (mapea) entre ambos rangos

  // Escribimos en el LED el valor correspondiente [0-255]
  analogWrite(led,valorSensor);

  // Esperamos un tiempo de reaccion para el LED
  delay(3);
}

Puertos de Arduino

Arduino UNO es una placa impresa con un microcontrolador ATmega3281.

Los pines digitales 0-13 son de entrada y salida (digitalRead(HIGH/LOW); digitalWrite(pin, HIGH/LOW)).
Los puertos PWM (Pulse-Width Modulation) permiten simular una salida analógica (analogWrite(pin, valor)) escribiendo valores entre [0-255].
El puerto 13 incluye una resistencia de 220 Ω y está conectado al único actuador programable de la placa, el LED ‘L’.
Los puertos 0 y 1 se usan para comunicaciones RX (recepción) y TX (transmisión) -actividad indicada por los correspondientes LEDs- por lo que no se recomienda su uso para nada más. Cuando se usan los puertos 0 y 1 para comunicaciones se recomienda desconectar el USB -que se usa para lo mismo- para evitar problemas.

Los puertos con particularidades son: 0 y 1 (Rx,Tx); 2 y 3 (interrupciones); 3, 5, 6, 9, 10 y 11 (PWM); 10, 11, 12 y 13** (SPI); A4 y A5 / SDA* y SCL* (TWI); AREF (Voltaje de referencia); Reset; IOREF (V. referencia IC); No conectado*.
(*) Puertos aparecidos en UNO R3, y que no están etiquetados en la placa.
(**) Incluye una resistencia de 220 Ω.

Los pines analógicos 0-5 son de entrada (analogRead()) y leen valores entre [0-1023].
El voltaje de entrada es de 5V (USB) o 7V-12V (pin Vin y conector jack). El GND de arriba es digital (DGND). Generalmente se usan un GND analógico (AGND) para la BreadBoard.