Introducción

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos de entrada/salida. Los microcontroladores más usados son el Atmega168, Atmega328, Atmega1280, ATmega8 por su sencillez y bajo coste que permiten el desarrollo de múltiples diseños. Por otro lado el software consiste en un entorno de desarrollo que implementa el lenguaje de programación Processing/Wiring y el cargador de arranque (boot loader) que corre en la placa.

Desde octubre de 2012, Arduino se usa también con microcontroladoras CortexM3 de ARM de 32 bits5 , que coexistirán con las más limitadas, pero también económicas AVR de 8 bits. ARM y AVR no son plataformas compatibles a nivel binario, pero se pueden programar con el mismo IDE de Arduino y hacerse programas que compilen sin cambios en las dos plataformas. Eso sí, las microcontroladoras CortexM3 usan 3.3V, a diferencia de la mayoría de las placas con AVR que usan mayoriamente 5V. Sin embargo ya anteriormente se lanzaron placas Arduino con Atmel AVR a 3.3V como la Arduino Fio y existen clónicos de Arduino Nano y Pro como Meduino en que se puede conmutar el voltaje.

Arduino se puede utilizar para desarrollar objetos interactivos autónomos o puede ser conectado a software del ordenador (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). Las placas se pueden montar a mano o adquirirse. El entorno de desarrollo integrado libre se puede descargar gratuitamente.

Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, puede utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.
El proyecto Arduino recibió una mención honorífica en la categoría de Comunidades Digital en el Prix Ars Electrónica de 2006.

Historia

Arduino nació como un proyecto educativo allá por el año 2005 sin pensar que algunos años más tarde se convertiría en  lider del mundo DIY (Do It Yourself).

Su nombre viene del nombre del bar Bar di Re Arduino donde Massimo Banzi pasaba algunas horas, el cual a su vez viene del nombre de un antiguo rey europeo allá por el año 1002.
Banzi dice que nunca surgió como una idea de negocio, es más nació por una necesidad de subsistir ante el eminente cierre del Instituto de diseño Interactivo IVREA en Italia.  Es decir, al crear un producto open hardware (de uso público) no podría ser embargado.  Es más hoy en día Arduino tiene la difícil tarea de subsistir comercialmente y continuar en continuo crecimiento.

A la fecha se han vendido más de 250 mil placas en todo el mundo sin contar las versiones clones y compatibles.
Para su creación participaron alumnos que desarrollaban sus tesis como Hernando Barragan (Colombia) quien desarrollo la plataforma de programación Wiring con la cual se programa el microcontrolador.
Hoy en día con Arduino se pueden fabricar infinidad de prototipos y cada ves su uso se viene expandiendo más.  Desde cubos de leds, sistemas de automatización en casa (domotica), integración con el Internet, displays Twitter, kit analizadores de ADN.

Google ha apostado por el proyecto y ha colaborado en el Android ADK (Accesory Development Kit), una placa Arduino capaz de comunicarse directamente con spmartphones Android para obtener las funcionalidades del teléfono (GPS, acelerómetros, GSM, abases de datos) y viceversa para que el teléfono controle luces, motores y sensores conectados de Arduino.

El primer prototipo fue desarrollado en el instituto IVRAE pero aún no se llamaba Arduino.  Vea la foto del mismo.
Para la producción en serie de la primera versi[on se tomaron en cuenta algunas consideraciones: Economía (no > a 30 Euros), debía ser Plug and Play, utilizaron el color azul para marcar una diferencia con las placas convencionales, trabajar en todas las plataformas (Mac, Windows y Linux).

La primera producción fue de 300 unidades y se las dieron a los alumnos del Instituto IVRAE, (las ganacias fueron de sólo 1 dollar por placa), con el fin de que las probaran y empezaran a diseñar sus primeros prototipos.
Uno de los primeros proyecto fue un reloj alarma, el cual no se apagaría hasta que no te pararas de la cama.
Tom Igoe, profesor y padre de la computación física se unió al proyecto luego que se enterara del mismo a través de la web.  El ofreció su apoyo para desarrollar el proyecto a grandes escalas.

Hoy por hoy Arduino te permite crear cosas por ti mismo.
Varias universidades como Standford y Carnegie Mellon y el MIT usan Arduino en sus campus.
En la feria Maker Fair del 2011 se presentó la primera placa Arduino 32 Bit para trbajar tareas más pesadas.  Entre ellas se presentó la  impresora en 3D de MakerBot capaz de de imprimir en resina cualquier modelo en 3D.


 
Arduino The Documentary (2010) Spanish HD from gnd on Vimeo.

Instalación

Descargar
http://arduino.cc/en/Main/Software


Windows
Para la instalación de la placa Arduino en el sistema operativo Windows conviene seguir los siguientes pasos: Con la placa desconectada:

Descargar e instalar el Java Runtime Enviroment (J2RE).
Descargar la última versión del IDE Arduino.
http://arduino.googlecode.com/files/arduino-1.0.3-windows.zip
Nota: Es recomendable descomprimir el fichero en el directorio raíz (c:\) manteniendo la estructura original.
Entre todas las carpetas creadas en el directorio Arduino conviene destacar las siguientes:
 c:\arduino-0012\hardware\bootloader:
Ésta contiene el software necesario para cargar el firmware en el chip Atmega168, para trabajar con Arduino. Sólo se utiliza si os habéis montado vosotros mismos la placa, o en el caso que se haya estropeado el chip y hayáis comprado uno nuevo.
 c:\arduino-0012\drivers:
Contiene los drivers necesarios para el funcionamiento de la placa Arduino con el PC con S.O. Windows: FTDI USB Drivers.
Instalar FTDI USB Drivers
Ahora sí, conectar la placa USB. Se abrirá automáticamente el asistente de Windows para nuevo hardware encontrado:
1. Seleccionar "No por el momento" y presionar "Siguiente".
2. Seleccionar "Instalar desde una lista o ubicación específica (avanzado)" y presionar "Siguiente".
3. "Buscar el controlador más adecuado en estas ubicaciones" presiona "Examinar".Seleccionar la carpeta donde hayas descomprimido el driver y presiona “Siguiente”.
Si no habido ningún problema el driver de la placa estará instalado.
Abrir el IDE Arduino
Ejecutamos el fichero Arduino.exe para abrir la interficie. Aquí configuramos el puerto USB donde tenemos conectada la placa para empezar a trabajar.



GNU/Linux

Para instalar Arduino en un sistema GNU/Linux necesitamos los siguientes programas para resolver las dependencias:
Sun java runtime, jre.
avr-gcc, compilador para la familia de microcontroladores avr de atmel.
avr-libc, libc del compilador avr-gcc.
Para instalarlos, podemos utilizar el gestor de paquetes o el terminal de comandos:
 apt-get install sun-java5-jre gcc-avr avr-libc
En algunas distribuciones conviene desinstalar, si no es necesario, el programa "brltty". Éste se encarga de permitir el acceso al terminal para personas ciegas a través de un dispositivo especial en braille.
 killall brltty
 apt-get remove brltty
Los dos síntomas de este problema son:
No aparece la opción /dev/tty/USB0 en el menú Tools, Serial Port.
Si se observa el LED Rx de la placa Arduino, éste se ilumina de 3 a 5 veces cada 5 ó 6 segundos.
Por último, descargamos el framework de arduino. Lo descomprimimos en la carpeta deseada y lo ejecutamos:
http://arduino.googlecode.com/files/arduino-1.0.3-windows.zip
 ./arduino
Si todo ha ido bien ya lo tendremos en funcionamiento.

Parpadeo de un led

En la mayoría de los lenguajes de programación, el primer programa que tu escribes imprime en la pantalla del ordenador la frase "Hola Mundo". Ya que una placa Arduino no tiene una pantalla, haremos parpadear un LED.

Ejemplo 1

void setup() {              
  pinMode(13, OUTPUT);  
}
void loop() {
  digitalWrite(13, HIGH);   // set the LED on
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // set the LED off
  delay(1000);              // wait for a second
}

Ejemplo 2
const int ledPin =  13;      // the number of the LED pin
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated
long interval = 1000;           // interval at which to blink (milliseconds)

void setup() {
  pinMode(ledPin, OUTPUT);    
}

void loop()
{
  unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;

    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;
    digitalWrite(ledPin, ledState);
  }


}

Boton

Los pulsadores o switches conectan dos puntos de un circuito al ser pulsados. Este ejemplo enciende el LED integrado en el pin 13 cuando pulsas el botón.

Conecta tres cables a la placa Arduino. Los dos primeros, rojo y negro, conectan a las dos hileras largas verticales de los laterales de la placa universal (breadboard) para proporcionar acceso a la fuente de 5 voltios y a masa (ground). El tercer cable va desde el pin digital 2 a una patilla del pulsador. Esa misma patilla del pulsador se conecta a través de una resistencia pull-down (en este caso 10 KOhms) a masa. El otro extremo del pulsador se conecta a la fuente de 5 voltios.

Cuando el pulsador está abierto (sin pulsar) no hay conexión entre las dos patas del pulsador, de forma que el pin está conectado a tierra (a través de la resistencia pull-down) y leemos un LOW (bajo ó 0). Cuando el botón se cierra (pulsado), se establece la unión entre sus dos extremos, conectando el pin a 5 voltios, por lo que leemos un HIGH (alto ó 1).

También puedes cablear el circuito en sentido contrario, con una resistencia "pull-up" que mantenga la entrada en HIGH, y que pase a LOW cuando se pulse el botón. Así, el comportamiento del programa (sketch) se invertirá, con el LED normalmente encendido y apagado cuando se pulsa el botón.
Si se desconectas el pin digital de E/S del todo, el LED puede parpadear de forma errática. Esto se debe a la entrada es "flotante", es decir, al azar se tornará en HIGH o LOW. Por eso se necesita la resistencia pull-up o pull-down en el circuito.

Ejemplo 1

const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin
int buttonState = 0;         // variable for reading the pushbutton status
void setup() {
  pinMode(ledPin, OUTPUT);    
  pinMode(buttonPin, INPUT);  
}

void loop(){
    buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {  
    digitalWrite(ledPin, HIGH);
  }
  else {
    digitalWrite(ledPin, LOW);
  }
}

Ejemplo 2

const int  buttonPin = 2;    // the pin that the pushbutton is attached to
const int ledPin = 13;       // the pin that the LED is attached to
int buttonPushCounter = 0;   // counter for the number of button presses
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}
void loop() {
  buttonState = digitalRead(buttonPin);
  if (buttonState != lastButtonState) {
    if (buttonState == HIGH) {
      buttonPushCounter++;
      Serial.println("on");
      Serial.print("number of button pushes:  ");
      Serial.println(buttonPushCounter, DEC);
    }
    else {
      Serial.println("off");
    }
  }
  lastButtonState = buttonState;

  if (buttonPushCounter % 4 == 0) {
    digitalWrite(ledPin, HIGH);
  } else {
   digitalWrite(ledPin, LOW);
  }
 }

Ejemplo 3 Anti-Rebote

const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin
int ledState = HIGH;         // the current state of the output pin
int buttonState;             // the current reading from the input pin
int lastButtonState = LOW;   // the previous reading from the input pin
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int reading = digitalRead(buttonPin);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    buttonState = reading;
  }
  digitalWrite(ledPin, buttonState);
  lastButtonState = reading;
}

Reproduce un tono

Este ejemplo muestra como usar la función tone() para generar notas. Reproduce una pequeña melodia que quizás hayas escuchado antes.(la resistencia es de 100 Ohms o menor)

Ejemplo 1

#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

int melody[ ] = {
  NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};

// duracion de las notas: 4 = cuarto de nota, 8 = octavo de nota, etc.:
int noteDurations[] = {
  4, 8, 8, 4,4,4,4,4 };

void setup() {

  for (int thisNote = 0; thisNote < 8; thisNote++) {

    int noteDuration = 1000/noteDurations[thisNote];
    tone(8, melody[thisNote],noteDuration);

    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
  }
}

void loop() {
}

Ejemplo 2

#define sil     0
#define do1 15289
#define do2 7645
#define do3 3822
#define do4 1911
#define do5 956
#define do6 478
#define do7 239
#define dos1 14431
#define dos2 7215
#define dos3 3608
#define dos4 1804
#define dos5 902
#define dos6 451
#define dos7 225
#define re1 13621
#define re2 6810
#define re3 3405
#define re4 1703
#define re5 851
#define re6 426
#define re7 213
#define res1 12856
#define res2 6428
#define res3 3214
#define res4 1607
#define res5 804
#define res6 402
#define res7 201
#define mi1 12135
#define mi2 6067
#define mi3 3034
#define mi4 1517
#define mi5 758
#define mi6 379
#define mi7 190
#define fa1 11454
#define fa2 5727
#define fa3 2863
#define fa4 1432
#define fa5 716
#define fa6 358
#define fa7 179
#define fas1 10811
#define fas2 5405
#define fas3 2703
#define fas4 1351
#define fas5 676
#define fas6 338
#define fas7 169
#define sol1 10204
#define sol2 5102
#define sol3 2551
#define sol4 1276
#define sol5 638
#define sol6 319
#define sol7 159
#define sols1 9631
#define sols2 4816
#define sols3 2408
#define sols4 1204
#define sols5 602
#define sols6 301
#define sols7 150
#define la1 9091
#define la2 4545
#define la3 2273
#define la4 1136
#define la5 568
#define la6 284
#define la7 142
#define las1 8581
#define las2 4290
#define las3 2145
#define las4 1073
#define las5 536
#define las6 268
#define las7 134
#define si1 8099
#define si2 4050
#define si3 2025
#define si4 1012
#define si5 506
#define si6 253
#define si7 127
/*
Melodias con Arduino - Jorge García Tíscar
*/

// Variables de control
int pinAltavoz = 8;
//int tempo = 69; //para elisa
int tempo = 155; //himno alegria
//int tempo = 144; //tetris
//int m[] = {4,mi5,4,res5,4,mi5,4,res5,4,mi5,4,si4,4,re5,4,do5,2,la4,4,sil,4,do4,4,mi4,4,la4,2,si4,4,sil,4,mi4,4,sols4,4,si4,2,do5,4,sil,4,mi4,4,mi5,4,res5,4,mi5,4,res5,4,mi5,4,si4,4,re5,4,do5,2,la4,4,sil,4,do4,4,mi4,4,la4,2,si4,4,sil,4,mi4,4,do5,4,si4,2,la4,4,sil,4,sil,4,si4,4,do5,4,re5,2,mi5,4,sol4,4,fa5,4,mi5,2,re5,4,fa4,4,mi5,4,re5,2,do5,4,mi4,4,re5,4,do5,2,si4,4,sil,4,sol4,4,mi5,4,mi4,4,mi5,4,mi5,4,mi6,4,res5,4,mi5,4,res5,4,mi5,4,res5,4,mi5,4,res5,4,mi5,4,re5,4,mi5,4,res5,4,mi5,4,si4,4,re5,4,do5,2,la4,4,sil,4,do4,4,mi4,4,la4,2,si4,4,sil,4,mi4,4,sols4,4,si4,2,do5,4,sil,4,mi4,4,mi5,4,res5,4,mi5,4,res5,4,mi5,4,si4,4,re5,4,do5,2,la4,4,sil,4,do4,4,mi4,4,la4,2,si4,4,sil,4,mi4,4,do5,4,si4,2,la4};
int m[] = {-2,si4,1,do5,1,re5,1,re5,1,do5,1,si4,1,la4,1,sol4,1,sol4,1,la4,1,si4,-2,si4,2,la4,-2,la4,-2,si4,1,do5,1,re5,1,re5,1,do5,1,si4,1,la4,1,sol4,1,sol4,1,la4,1,si4,-2,la4,2,sol4,-2,sol4,2,sil,-2,la4,1,si4,1,sol4,1,la4,2,si4,2,do5,1,si4,1,sol4,1,la4,2,si4,2,do5,1,si4,1,la4,1,sol4,1,la4,-2,re4,-2,si4,1,do5,1,re5,1,re5,1,do5,1,si4,1,la4,1,sol4,1,sol4,1,la4,1,si4,-2,la4,2,sol4,-2,sol4};
//int m[]={1,la4,2,mi4,2,fa4,1,sol4,2,fa4,2,mi4,1,re4,2,re4,2,fa4,1,la4,2,sol4,2,fa4,1,mi4,2,mi4,2,fa4,1,sol4,1,la4,1,fa4,1,re4,-2,re4,2,sil,1,sol4,2,las4,2,re5,2,re5,2,do5,2,las4,1,la4,2,fa4,2,la4,2,la4,2,sol4,2,fa4,1,mi4,2,mi4,2,fa4,1,sol4,1,la4,1,fa4,1,re4,-2,re4};

// Variables auxiliares
long d[sizeof(m)/sizeof(int)];
int ta[sizeof(m)/sizeof(int)];
int i = 0;
int id = 0;
long t = 0;

void setup(){
  pinMode(pinAltavoz, OUTPUT);
  //Redistribuir vector melodia
  for(i=0;i<sizeof(m)/sizeof(int);i=i+2){
    if(m[i]>0){
      d[id] = 60000/(tempo*m[i]);
    }else{
      d[id] = (-60000*m[i])/tempo;
    }
    ta[id]=m[i+1];
    id++;
  }
}

void loop(){
  i = 0;
  for (i=0;i<sizeof(ta)/sizeof(int);i++){
    t = 0;
    if(ta[i]==0){
      delay(d[i]); // Silencio
    }else{
      while(t<d[i]*1000){ // Generar PWM
        digitalWrite(pinAltavoz, HIGH);
        delayMicroseconds(ta[i]);
        digitalWrite(pinAltavoz, LOW);
        delayMicroseconds(ta[i]);
        t = t + 2*ta[i];
      }
    }
    delay(10); // Pausa tras cada nota
  }
  delay(5000); // Pausa tras melodia
}

Entrada Analógica

Un potenciómetro es un elemento pasivo con un eje que proporciona una resistencia variable, la cual puede ser leida por una placa Arduino como un valor analógico. En este ejemplo, ese valor controlará la frecuencia con la que parpadeará un LED

Conectamos 3 cables a la placa Arduino. El primero desde masa a uno de los pines extremos del potenciómentro. El segundo, desde 5 voltios al otro pin extremo del potenciómetro . El tercero desde el pin analógico 2 al pin medio del potenciómetro.

Al girar el eje del potenciómetro, cambiamos el valor de la resistencia entre los pines de los extremos y el pin central del potenciómtro. Esto cambia la "cercanía" relativa del pin central a 5 Voltios y a masa, ofreciendo diferentes valores analógicos de entrada. Cuando giramos el eje a tope en un sentido, llegarán 0 voltios al pin central, y leeremos 0. Cuando giramos el eje a tope, pero en el otro sentido, llegarán 5 voltios al pin central y leeremos 1023. Entre medias, analogRead() retorna un número entre 0 y 1023 que es proporcional al valor del voltaje aplicado al pin central.

Ejemplo 1
int sensorPin = 0;    // selecciona el pin de entrada para el potenciómetro
int ledPin = 13;      // selecciona el pin para el LED
int sensorValue = 0;  // variable para almacenar el valor que ofrece el sensor
void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  sensorValue = analogRead(sensorPin);  
  digitalWrite(ledPin, HIGH);
  delay(sensorValue);        
  digitalWrite(ledPin, LOW);
  delay(sensorValue);                
}

Displays LCD

La librería LiquidCrystal te permite controlar displays LCD que sean complatibles con el driver Hitachi HD44780. Hay muchos de ellos ahí fuera, y puedes comunicarte con ellos a través del interfaz de 16 pines.
Este sketch de ejemplo imprime "Hello World!" en el LCD y muestra el tiempo en segundos desde que Arduino fué reseteado por última vez.

salida del sketch en un LCD de 2x16
El LCD tiene un interfaz paralelo, significando esto que el microcontrolador tiene que manipular varios pines del interfaz a la vez para controlarlo. El interfaz consta de los siguientes pines:
Un pin de selección de registro (RS) que controla en qué parte de la memoria del LCD estás escribiendo datos. Puedes seleccionar bien el regisro de datos, que mantiene lo que sale en la pantalla, o un registro de instrucción, que es donde el controlador del LCD busca las instrucciones para saber cual es lo siguiente que hay que hacer.

El pin de lectura/escritura (R/W)que selecciona el modo de lectura o el de escritura.
Un pin para habilitar (enable) que habilita los registros.
8 pines de datos (D00-D07). Los estados de estos pines (nivel alto o bajo) son los bits que estás escribiendo a un registro cuando escribes, o los valores de lectura cuando estás leyendo.
Hay también un pin de contraste del display (Vo), pines de alimentación (+5V y GND) y pines de retro-iluminación (Bklt+ y Bklt-), que te permiten alimentar el LCD, controlar el contraste del display, o encender y apagar la retro-iluminación, respectivamente.
El proceso de controlar el display involucra la colocación de los datos que componen la imagen de lo que quieres mostrar, en los registros de datos, y luego, colocar las instrucciones, en el registro de instrucciones. La librería LiquidCrystal te simplifica todo este proceso de forma que no neesitas saber las instrucciones de bajo nivel.

Los LCD-s compatibles con Hitachi pueden ser controlados de dos modos: 4 bits u 8 bits. El modo de 4 bits requiere siete pines de E/S de Arduino, mientras el modo de 8 bits requiere 11 pines. Para mostrar texto en la pantalla, puedes hacer la mayoría de las cosas en modo 4 bits, por lo que el ejemplo muestra como controlar un LCD de 2x16 en modo de 4 bits.

NOTA: La librería LiquidCrystal tiene revisiones venidas a menos después de la versión 0016 de Arduino. Gracias a Limor Fried por reescribirla para incluir los modos de 4 y 8 bits y otras funcionalidades. Estas notas hacen referencia a la versión actual como es Arduino 0017.

Ejemplo 1

// include the library code:
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
byte smiley[8] = {
  B00000,
  B10001,
  B00000,
  B00000,
  B10001,
  B01110,
  B00000,
};
byte smiley2[8] = {
  B00000,
  B10000,
  B01000,
  B00100,
  B00010,
  B00001,
  B00000,
};
void setup() {
    lcd.createChar(0, smiley);
    lcd.createChar(1, smiley2);
  // set up the LCD's number of columns and rows:

  lcd.begin(20, 4);
  // Print a message to the LCD.

}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  lcd.print("Todo en uno");

  lcd.setCursor(3, 5);
  lcd.print("/");
delay(300);
  lcd.setCursor(3, 5);
  lcd.print("-");
delay(300);
  lcd.setCursor(3, 5);
  lcd.print("|");
delay(300);
  lcd.setCursor(3, 5);
  lcd.write(1);
delay(300);

  lcd.setCursor(3, 0);
  lcd.write(0);
  lcd.setCursor(10,0);
  lcd.print(millis()/1000);
}

Display 7 segmentos

void setup(){
  DDRD=B11111110;
 }

void actualizarNumero(int valor){
  byte numero[10]={B01111110,B00001100,B10110110,B10011110,B11001100,B11011010,B11111010,B00001110,B11111110,B11001110};

  PORTD=numero[valor];
}

 void loop()  {

   for (int n=0;n<=9;n++){
     actualizarNumero(n);
     delay(1000);
   }

 }

Motor paso a paso unipolar

Ejemplo 1
 int motorPin1 = 11;                              // PIN-es del Motor
 int motorPin2 = 9;
 int motorPin3 = 10;
 int motorPin4 = 8;
 int delayTime = 500;                            // Delay que determina la velocidad de giro
void setup() {
  pinMode(motorPin1, OUTPUT);                    // Configuración de los PIN-es como salida digital
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}
void loop() {
  digitalWrite(motorPin1, HIGH);                 // Los pines se activan en secuencia
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);

  delay(delayTime);
}

Ejemplo 2
 int motorPins[] = {11, 9, 10, 8};                   // PIN-es del motor
 int count = 0;                                      // Contador 1
 int count2 = 0;                                     // Contador 2
 int delayTime = 500;                                // Delay que determina la velocidad de giro
 int val = 0;
void setup() {
  for (count = 0; count < 4; count++) {              // Configuración de los PIN-es como salida digital
    pinMode(motorPins[count], OUTPUT);
  }
}
void moveForward() {
  if ((count2 == 0) || (count2 == 1)) {             // Mueve el motor hacia delante. Para hacerlo desplaza los
    count2 = 16;
  }                                                 // bits de la vable count2 entre los PIN-es del motor.
  count2>>=1;                                    
  for (count = 3; count >= 0; count--) {            // 16 = 00010000 --> 00001000 --> 00000100  ...
    digitalWrite(motorPins[count], count2>>count&0x01);
  }
  delay(delayTime);
}
void moveBackward() {
  if ((count2 == 0) || (count2 == 1)) {              // Mueve el motor hacia delante. Para hacerlo desplaza los
    count2 = 16;                                     // bits de la vable count2 entre los PIN-es del motor.
  }
  count2>>=1;
  for (count = 3; count >= 0; count--) {             // 16 = 00010000 --> 00001000 --> 000 ...
    digitalWrite(motorPins[3 - count], count2>>count&0x01);
  }
  delay(delayTime);
}
void loop() {
  val = analogRead(0);
  if (val > 540) {                                   // Cuanto mayor es el valor del potenciómetro
    delayTime = 2048 - 1024 * val / 512 + 1;         // más rápido se mueve hacia delante
    moveForward();
  } else if (val < 480) {                            // Cuanto menor es el valor del potenciómetro
    delayTime = 1024 * val / 512 + 1;                // más rápido se mueve hacia atrás
    moveBackward();                                  
  } else {
    delayTime = 1024;                                // Cuando el valor del potenciometro se encuentra
  }                                                  // en la zona media, el motor se para.
}

Teclado PS2

Para recoger datos de un teclado PS2 usaremos la siguiente libreria PS2Keyboard.zip descargar y descomprimir en libraries en mi caso 

/opt/arduino-1.5.1/libraries

#include <PS2Keyboard.h>

const int DataPin = 4;
const int IRQpin =  3;

PS2Keyboard keyboard;

void setup() {
  delay(1000);
  keyboard.begin(DataPin, IRQpin);
  Serial.begin(9600);
  Serial.println("Keyboard Test:");
}

void loop() {
  if (keyboard.available()) {
 
    // read the next key
    char c = keyboard.read();
 
    // check for some of the special keys
    if (c == PS2_ENTER) {
      Serial.println();
    } else if (c == PS2_TAB) {
      Serial.print("[Tab]");
    } else if (c == PS2_ESC) {
      Serial.print("[ESC]");
    } else if (c == PS2_PAGEDOWN) {
      Serial.print("[PgDn]");
    } else if (c == PS2_PAGEUP) {
      Serial.print("[PgUp]");
    } else if (c == PS2_LEFTARROW) {
      Serial.print("[Left]");
    } else if (c == PS2_RIGHTARROW) {
      Serial.print("[Right]");
    } else if (c == PS2_UPARROW) {
      Serial.print("[Up]");
    } else if (c == PS2_DOWNARROW) {
      Serial.print("[Down]");
    } else if (c == PS2_DELETE) {
      Serial.print("[Del]");
    } else {
   
      // otherwise, just print all normal characters
      Serial.print(c);
    }
  }
}

Control de velocidad de M. DC

Como sabrán para el led conectado al pin 13 no es necesario el uso de la resistencia de 220 ohmios de protección, pero para la conexión del motor DC si se hace necesario utilizar un transistor 2n3904 o 2n2222 haciendo el uso de una resistencia de 1k y un diodo 1n4001 de protección contra la inducción del motor.

int motorPin = 9;    // motor en el pin 9 PWM

void setup()         // ejecutar una vez, cuando empieza
{
  pinMode(motorPin, OUTPUT);
}

void loop() {          
  analogWrite(motorPin, 50); //velocidad de motor 50 -255
  delay(10);
  digitalWrite(motorPin, LOW);
}

Control de LED RGB

Como sabrán para el led conectado al pin 13 no es necesario el uso de la resistencia de 220 ohmios de protección, pero para la conexión del motor DC si se hace necesario utilizar un transistor 2n3904

int ledRojo=9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11;  //Declara Pin LED Azul
int r=0; //Declara Pin LED Rojo
int g=0; //Declara Pin LED Verde
int b=0;  //Declara Pin LED Azul
String inString = "";    // string to hold input
int currentColor = 0;
int ok = 0;

void setup() // Se ejecuta cada vez queel Arduino se inicia
{
  Serial.begin(9600); //Open the serial port
  pinMode(ledRojo,OUTPUT);  //El LED Rojo como una salida
  pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
  pinMode(ledAzul,OUTPUT);  //El LED Azul como una salida
}

void loop() {
  int inChar;
  if (Serial.available() > 0) {
    inChar = Serial.read();
  }

  if (isDigit(inChar)) {
    inString = inString+(char)inChar;
  }

  if (inChar == ',') {
    if (inString.toInt()==12345 && ok==0){
        inString = "";
        ok=1;
        currentColor=0;
    }
    if (ok==1){
   
      switch (currentColor) {
      case 1:    // 0 = red
        r = inString.toInt();
        inString = "";
        break;
      case 2:    // 1 = green:
        g = inString.toInt();
        inString = "";
        break;
      case 3:    // 2 = blue:
        b = inString.toInt();
        inString = "";
        break;    
      }
   
      currentColor++;
      if(currentColor==4)
        currentColor=0;
        inString = "";
        ok==0;
      }
  }
   color(r,g,b);
}
//------------------------------------
//Funcion color
//------------------------------------

void color(int rojo, int verde, int azul){

    //Escritura de PWM del color Rojo
    analogWrite(ledRojo, rojo);
    //Escritura de PWM del color Verde
    analogWrite(ledVerde, verde);
    //Escritura de PWM del color Azul
    analogWrite(ledAzul, azul);
}

Sensar presencia de fuego

Este módulo sensor viene con 3 Pin Dual-hembra Longitud del cable 300mm Puente, rojo 3.3 v, Negro tierra y azul datos. de la siguiente manera:

//CONSTANTS
const int pinD0 = 0;
const int pinA0 = 1;

//VARIABLE
int A = -999;
int D = -999;
int readVal = 0;
boolean logging = false;
boolean fire = false;
boolean changed = true;


void setup() {            
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT);
  pinMode(0, INPUT);
  pinMode(1, INPUT);
  Serial.begin(19200);
}

void loop() {
  initialAll();
  readValues();
  loggingProcess();
  if (changed)
    printState();
  delay(1000);// wait for a second
}

void initialAll(){
  readVal = 0;
}

void readValues(){
  A = analogRead(pinA0);
  D = analogRead(pinD0);
  fireCheck();
  if (Serial.available()>0){
    readVal = Serial.read();
  }
}

void loggingProcess(){
  if (readVal == 'l'){
    if (logging)
      logging = false;
    else
      logging = true;
  }

  if (logging){
    Serial.println("------------");
    Serial.println("SYUMMARY");
    Serial.print("A0:");
    Serial.println(A);
    Serial.print("D0:");
    Serial.println(D);
    Serial.println("------------");
  }
}

void printState(){
  if (fire){
    Serial.println("------------");
    Serial.println("FLAME Detected");
    Serial.println("------------");
  }
  else{
    Serial.println("------------");
    Serial.println("NO FLAME");
    Serial.println("------------");
  }
  changed = !changed;
}

void fireCheck(){
  if (A < 350 && D < 350){
    fire = true;
    changed = !changed;
  }
  else{
    fire = false;
    changed = !changed;
  }
}

Lector de tarjeta SD

Este codigo es valido para Arduino UNO

Para el Arduino UNO es posible tambien usar los pines 11,12,13

#include <SPI.h>
#include <SD.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 4;  

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("\nInitializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output
  // or the SD library functions will not work.
  pinMode(10, OUTPUT);     // change this to 53 on a mega


  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card is inserted?");
    Serial.println("* Is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    return;
  } else {
   Serial.println("Wiring is correct and a card is present.");
  }

  // print the type of card
  Serial.print("\nCard type: ");
  switch(card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      break;
    default:
      Serial.println("Unknown");
  }

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    return;
  }


  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  Serial.print("\nVolume type is FAT");
  Serial.println(volume.fatType(), DEC);
  Serial.println();

  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
  volumesize *= 512;                            // SD card blocks are always 512 bytes
  Serial.print("Volume size (bytes): ");
  Serial.println(volumesize);
  Serial.print("Volume size (Kbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print("Volume size (Mbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);


  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);

  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
}


void loop(void) {

}

CNY70

La resistencia a aplicar es de 47K 

int ledpin=13;
int inpin=4;
int value=0;

void setup(){
  pinMode(ledpin, OUTPUT);
  pinMode(inpin,INPUT);
}
void loop(){
  value=digitalRead(inpin);
  digitalWrite(ledpin,value);
}

int pinReceptor = A0; //Guardamos en esta variable el pin Analógico
int sensorVal;
void setup(){
Serial.begin(9600); // Abrir comunicación por Serial
}
void loop(){
sensorVal = analogRead(pinReceptor);
Serial.println(sensorVal); // Leer el valor del Pin y escribirlo
delay(500);
}

Sensor de distancia sr04

Medidor de distancias a través de ultrasonidos HC-SR04. Esta librería es compatible con todas las placas Arduino NewPing_v1.5.zip, descargar y descomprimir en la ruta de arduino en el directorio libraries, en mi caso
/opt/arduino-1.5.1/libraries

#include <NewPing.h>

#define TRIGGER_PIN  12  // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN     11  // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

void setup() {
  Serial.begin(115200); // Open serial monitor at 115200 baud to see ping results.
}

void loop() {
  delay(50);                      // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
  unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).
  Serial.print("Ping: ");
  Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance in cm and print result (0 = outside set distance range)
  Serial.println("cm");
}

Sensor de temperatura LM35

Lectura de temperatura con el LM35

float pinTemperatura = 2;
float tempValor ;
void setup()
{
Serial.begin(9600);
}
void loop()
{
tempValor = ( 5.0 * analogRead(pinTemperatura) * 100.0) / 1024.0;
Serial.print("Temperatura (Celsius) = ");Serial.println(tempValor);
delay (1000);
}

Salida a TV

Para generar una salida a TV necestamos la sguiente libreria, la cual copiamos a la carpeta libraries en mi caso
 /opt/arduino-1.5.1/libraries
TVout_R5.91.zip
las resistencias son de 470Ω al pin 8 y 1K Ω va al pin 9

#include <TVout.h>

TVout TV;

void setup()  {
  TV.start_render(_PAL); //for devices with only 1k sram(m168) use TV.begin(_PAL,128,56)
}

void loop() {

  TV.clear_screen();
  TV.print_str(0,8,"Hola mundo");
  TV.delay_frame(50);
  TV.clear_screen();
  TV.draw_line(0,10,50,80,2);
  TV.delay_frame(50);
}

Control remoto IR

Para enviar información IR necesitamos la siguiente librería  NECIRrcv.zip, descargar y descomprimir en libraries en mi caso /opt/arduino-1.5.1/libraries, esta librería nos retornara un código exadecimal por cada tecla presionada, recordemos que cada control remoto suele tener un código exadecimal diferente para cada tecla, o simplemente envie a el Serial.println(ircode); el voltaje y la distribución de los pines depende del sensor IR

#include <NECIRrcv.h>
#define IRPIN 10    // pin that IR detector is connected to

#define n1 0xEF10BF00
#define n2 0xEE11BF00
#define n3 0xED12BF00
#define n4 0xEB14BF00
#define n5 0xEA15BF00
#define n6 0xE916BF00
#define n7 0xE718BF00
#define n8 0xE619BF00
#define n9 0xE51ABF00

NECIRrcv ir(IRPIN) ;

void setup()
{
  Serial.begin(9600) ;
  Serial.println("NEC IR code reception") ;
  ir.begin() ;
}

void loop()
{
  unsigned long ircode ;

  while (ir.available()) {
    ircode = ir.read() ;
    //Serial.println(ircode);
    switch(ircode)
    {
        case n1:
        {
                Serial.println(1);
                break;
        }
        case n2:
        {
                Serial.println(2);
                break;
        }
        case n3:
        {
                Serial.println(3);
                break;
        }
        case n4:
        {
                Serial.println(4);
                break;
        }
        case n5:
        {
                Serial.println(5);
                break;
        }
        case n6:
        {
                Serial.println(6);
                break;
        }
        case n7:
        {
                Serial.println(7);
                break;
        }
        case n8:
        {
                Serial.println(8);
                break;
        }
        case n9:
        {
                Serial.println(9);
                break;
        }
    }    
  }
}

//--------------------------pruebas con otra libreria ------------
Para esto usare las librerias IRemote (descargar de aqui) que las he probado con control remoto philips,lg y samsung, con excelentes resultados, usamdo un IR 1838

#include <IRremote.h>

int RECV_PIN = 10;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()

{

  Serial.begin(9600);

  irrecv.enableIRIn(); // Start the receiver

}

void loop() {

  if (irrecv.decode(&results)) {

    Serial.println(results.value, HEX);

    irrecv.resume(); // Receive the next value

  }

}

Comu. Bluetooth con Celular

para la comunicación con Bluetooth es similar a la comunicación USB serie, ya que el modulo Bluetooth se encarga de la comunicación y solo brinda entras y salidas seriales para el arduino

Nota: la conección de parte del modulo Bluetooth depende del modelo que se use, en nuestro caso es alimentado con 3.3v, hay que tener encuenta de que el pin RX del Bluetooth estará conectado al TX del Arduino, y el TX del Bluetooth al RX del Arduino.


String inString = "";  

void setup()
{
  Serial.begin(9600);
  pinMode(13,OUTPUT);
}

void loop() {
  int inChar;
  if (Serial.available() > 0) {
    inChar = Serial.read();
  }

  if (isDigit(inChar)) {
    inString = inString+(char)inChar;
  }

  if (inChar == '1') {
    digitalWrite(13, HIGH);
  }
  if (inChar == '2') {
    digitalWrite(13, LOW);
  }
}

por parte del celular usaremos este programa que a de instalar al celular numbers_v01.jar, este programa nos permitirá conectarnos y enviar los 9 dígitos del teclado del celular.

Nota: no todos los celulares permiten programar el Bluetooth del celular, para nuestro ejemplo usamos un celular Samsung GT-C3200.

Conexión ethernet

Para la comunicación ethernet usaremos la tarjeta ENC28J60 que no es la oficial de arduino, sin embargo es una mas económica y funciona bien.
Descargar las librerías  ethershield_v1.1_for_arduino_v1.0.zip , en la carpeta libraries de arduino existe una que se llama Ethernet, que la que se usa para la tarjeta ethernet oficial de arduino, ese directorio lo borraremos y descomprimiremos nuestras librerías que vienen con otro nombre ENC28J60  y las renombraremos a Ethernet.

Nota : cuando use 3.3v se perdía la señal, cuando subí a 5v trabajo perfectamente, pero el micro de la ethernet recalentaba

Ejemplo 1

#include "etherShield.h"
#include "ETHER_28J60.h"
static uint8_t mac[6] = {0x54, 0x55, 0x58, 0x10, 0x00, 0x24};
static uint8_t ip[4] = {192, 168, 1, 15};                      
static uint16_t port = 80;                                    
ETHER_28J60 ethernet;
void setup()
{
  ethernet.setup(mac, ip, port);
}

void loop()
{
  if (ethernet.serviceRequest())
  {
    ethernet.print("<H1>Hello World</H1>");
    ethernet.respond();
  }
  delay(100);
}

Ejemplo 2

#include "etherShield.h"
#include "ETHER_28J60.h"

int outputPin = 6;

static uint8_t mac[6] = {0x54, 0x55, 0x58, 0x10, 0x00, 0x24};  
static uint8_t ip[4] = {192, 168, 1, 15};                      

static uint16_t port = 80;                                    

ETHER_28J60 e;

void setup()
{
  e.setup(mac, ip, port);
  pinMode(outputPin, OUTPUT);
}

void loop()
{
  char* params;
  if (params = e.serviceRequest())
  {
    e.print("<H1>Web Remote</H1>");
    if (strcmp(params, "?cmd=on") == 0)
    {
      digitalWrite(outputPin, HIGH);
      e.print("<A HREF='?cmd=off'>Turn off</A>");
    }
    else if (strcmp(params, "?cmd=off") == 0) // Modified -- 2011 12 15 # Ben Schueler
    {
      digitalWrite(outputPin, LOW);
      e.print("<A HREF='?cmd=on'>Turn on</A>");
    }
    e.respond();
  }
}

Comunicación RF

Para la comunicación RF use la siguiente librería VirtualWire-1.4.zip descargar y descomprimir en libraries en mi caso /opt/arduino-1.5.1/libraries
Nota. la librería solo funciona con la versión 0022 de Arduino

Receptor

#include <VirtualWire.h>    // you must download and install the VirtualWire.h to your hardware/libraries folder
#undef int
#undef abs
#undef double
#undef float
#undef round

void setup()
{
    Serial.begin(9600);  
    vw_set_ptt_inverted(true);    // Required for RX Link Module
    vw_setup(2000);                   // Bits per sec
    vw_set_rx_pin(4);  
    vw_rx_start();  
Serial.println("Iniciando");
}

void loop()
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    if (vw_get_message(buf, &buflen)) // check to see if anything has been received
    {
    int i;
     
    for (i = 0; i < buflen; i++)
    {
        Serial.print(buf[i]);                     // the received data is stored in buffer
        }
    Serial.println("");
     }
}



Emisor

#include <VirtualWire.h>
#undef int
#undef abs
#undef double
#undef float
#undef round

void setup()
{
    vw_set_ptt_inverted(true); // Required for RF Link module
    vw_setup(2000);                 // Bits per sec
    vw_set_tx_pin(3);
}

void loop()
{
    const char *msg = "Hola blas !!!";       // this is your message to send
   vw_send((uint8_t *)msg, strlen(msg));
   vw_wait_tx();                                          // Wait for message to finish
   delay(200);
}