Al mide Luz

En este ejercicio se usa una fotocélula que es un sensor de luz el cual varia su resistencia dependiendo de la luz. Conectamos la fotocélula a Arduino y vemos en el serial monitor diferentes valores dependiendo de la intensidad de la luz que capta el sensor.

*Conectar un cable desde 5v hasta la pata derecha del sensor. Conectar un cable desde GND hasta la pata izquierda del sensor. Conectar una resistencia desde la pata izquierda del sensor y en su otro extremo conectar un cable hasta A5.

*Cargar el siguiente código:

int potPin = A5; // Pin Analogo
int val = 0;

void setup() {
Serial.begin(9600); // Serial.begin para comenzar a comunicar a 9600 baudios
}

void loop() {
val = analogRead(potPin);
Serial.println(val); // Imprimir un valor separado en lineas
delay(1000); // cada segundo
}

Play Piezo Buzzer

En este ejercicio se utiliza el buzzer o piezo para crear música según las secuencias programadas y teniendo en cuenta el uso de los tiempos para hacer que suenen los tonos. El calculo de los todos esta hecho según la siguiente operación matemática:

timeHigh = 1/(2 * toneFrequency) = period / 2

*Conectar un cable desde GND hasta la linea azul. Conectar un cable desde la linea azul hasta la pata izquierda del LED. Poner una resistencia en la pata derecha del LED y el otro extremo conectarlo a un cable hasta el pin digital 13. Conectar un cable desde el pin digital 9 hasta la pata derecha del buzzer. Conectar una resistencia en la pata izquierda y desde el otro extremo añadir un cable hasta la linea azul.

*Cargar el siguiente código:


/* Play Melody
 * -----------
 *
 * Program to play melodies stored in an array, it requires to know
 * about timing issues and about how to play tones.
 *
 * The calculation of the tones is made following the mathematical
 * operation:
 *
 *       timeHigh = 1/(2 * toneFrequency) = period / 2
 *
 * where the different tones are described as in the table:
 *
 * note frequency period PW (timeHigh)
 * c        261 Hz        3830 1915
 * d        294 Hz        3400 1700
 * e        329 Hz        3038 1519
 * f        349 Hz        2864 1432
 * g        392 Hz        2550 1275
 * a        440 Hz        2272 1136
 * b        493 Hz        2028 1014
 * C        523 Hz        1912 956
 *
 * (cleft) 2005 D. Cuartielles for K3
 */

int ledPin = 13;
int speakerOut = 9;            
byte names[] = {'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C'};
int tones[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};
byte melody[] = "2d2a1f2c2d2a2d2c2f2d2a2c2d2a1f2c2d2a2a2g2p8p8p8p";
// count length: 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
//                                10                  20                  30
int count = 0;
int count2 = 0;
int count3 = 0;
int MAX_COUNT = 24;
int statePin = LOW;

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

void loop() {
  analogWrite(speakerOut, 0);  
  for (count = 0; count < MAX_COUNT; count++) {
    statePin = !statePin;
    digitalWrite(ledPin, statePin);
    for (count3 = 0; count3 <= (melody[count*2] - 48) * 30; count3++) {
      for (count2=0;count2<8;count2++) {
        if (names[count2] == melody[count*2 + 1]) {    
          analogWrite(speakerOut,500);
          delayMicroseconds(tones[count2]);
          analogWrite(speakerOut, 0);
          delayMicroseconds(tones[count2]);
        }
        if (melody[count*2 + 1] == 'p') {
          // make a pause of a certain size
          analogWrite(speakerOut, 0);
          delayMicroseconds(500);
        }
      }
    }
  }
}

Conexión en serie

El circuito en serie es cuando la terminal de salida de un dispositivo se conecta a la terminal de entrada del dispositivo siguiente.

Ejercicio que prende los LED's al mismo tiempo utilizando un circuito en serie.

Conectar un cable desde GND hasta la linea azul del breadboard. Conectar un cable desde pin digital 6 hasta un punto en la linea I, conectar tres cables uno al lado del otro en las lineas siguientes h, g, f y cada cable conectado a la pata izquierda de un LED. Conectar un resistencia a la pata derecha de cada cable desde la linea azul.

*Cargar el siguiente código:

int cadenaLeds[]={6,7,8,9};
int tiempo=200;
int n=0;

void setup (){
for(n=0;n<4;n++){
pinMode(cadenaLeds[n],OUTPUT);
}
}
void secuencia(){
for(n=0;n<4;n++){
digitalWrite(cadenaLeds[n],HIGH);//Envia 5V a la salida digital cuyo n se encuentre
delay(tiempo); // en la posicion de la lista definida por el valor de n (enciende el LED)
digitalWrite(cadenaLeds[n],LOW); //Envia 0V a la salida digital cuyo n se encuentre
} // en la posicion de la lista definida por el valor de n (apaga el LED)

}
void loop(){
secuencia();
}

Semáforo 2

En este ejercicio se prenden 3 LED's con un delay de 2500 ms, las luces simulan un semáforo.

*Conectar un cable desde GND a la lina azul del protoboard. Conectar un cable desde el pin digital 2 hasta la pata izquierda del LED y una resistencia desde la linea azul hasta la para derecha del LED. Repetir lo mismo con el pin digital 3 y 4.

*Cargar el siguiente código:



int pinRedLed = 2;
int pinYelLed = 3;
int pinGrnLed = 4;
int lightState = 0;

void setup() {
    pinMode(pinRedLed, OUTPUT);    /* Set the LED pins to output */
    pinMode(pinYelLed, OUTPUT);
    pinMode(pinGrnLed, OUTPUT);
    digitalWrite(pinRedLed, HIGH);  /* Turn the RED light on, so we don't cause any traffic accidents while we initialise <img src="http://s.wordpress.com/wp-includes/images/smilies/icon_smile.gif" alt=":)" class="wp-smiley">  */
}

void loop() {

    lightState++;
    if (lightState > 3) {            // If the light state > 3, reset it to 0 (red).
      lightState = 0;
    }    

  delay(2500);

  /* Display correct light sequence */
  if (lightState == 0) { // Red
    digitalWrite(pinRedLed, HIGH);
    lightOff(pinYelLed);
    lightOff(pinGrnLed);
  }
  if (lightState == 1) { // Red and Amber
    digitalWrite(pinRedLed, HIGH);
    digitalWrite(pinYelLed, HIGH);
    lightOff(pinGrnLed);
  }
  if (lightState == 2) { // Green
    digitalWrite(pinGrnLed, HIGH);
    lightOff(pinYelLed);
    lightOff(pinRedLed);
  }
  if (lightState == 3) { // Amber-only
    digitalWrite(pinYelLed, HIGH);
    lightOff(pinRedLed);
    lightOff(pinGrnLed);
  }

}

void lightOff(int pin) {
  digitalWrite(pin, LOW);
}

*Video semáforo 2:

Semaforo 1 - conexión paralela

En este ejercicio se prenden 4 LED's con intervalos de 200ms. Utilice resistencias de 150 ohms porque con ellas los LED's brillaban más. Este ejercicio es una conexión paralela.

*Conectar un cable desde GND a la linea azul del protoboard. Conectar un cable desde el pin digital 6 hasta la pata izquierda del LED y una resistencia desde la linea azul hasta la pata derecha del LED. Conectar de la misma forma con los pin digital 7, 8 y 9.

*Cargar el siguiente código:


int cadenaLeds[]={6,7,8,9};
 int tiempo=200;
 int n=0;

 void setup (){
   for(n=0;n<4;n++){
     pinMode(cadenaLeds[n],OUTPUT);
   }
 }
 void secuencia(){
   for(n=0;n<4;n++){
    digitalWrite(cadenaLeds[n],HIGH);//Envia 5V a la salida digital cuyo n se encuentre
    delay(tiempo);                   // en la posicion de la lista definida por el valor de n (enciende el LED)
    digitalWrite(cadenaLeds[n],LOW); //Envia 0V a la salida digital cuyo n se encuentre
   }                                 // en la posicion de la lista definida por el valor de n (apaga el LED)

 }
 void loop(){
   secuencia();
 }

*Video Semaforo 1:

IR sensor

Sensor IR...

Conectar un cable desde la pata izquierda al analog pin 0. Conectar un cable desde la pata derecha a 5v. Conectar un cable desde la pata del centro hasta GND.

Cargar el siguiente código:


byte sensorPin=0;
int latestVal=0;
int maxVal=0;
int minVal=1024;

void setup() {
  Serial.begin(9600);
  Serial.println("in setup");
}

void loop() {
  //Serial.println("In loop");
  latestVal = analogRead(sensorPin);
  if(latestVal < minVal) {
    minVal = latestVal;
  }
  if(latestVal > maxVal) {
    maxVal = latestVal;
  }
  Serial.print("Max: ");
  Serial.print(maxVal);
  Serial.print(" Min: ");
  Serial.print(minVal);
  Serial.print(" Latest: ");
  Serial.println(latestVal);
  delay(1000);
}

Digital In lectura de un pulsador 2

En este ejercicio al apretar el botón se enciende el LED que estaba apagado y al soltar el botón el LED se apaga.

Conectar un cable desde la pata izquierda del botón a GND. Conectar un cable desde la J al frente de la pata derecha del botón al pin 2. Conectar un cable desde la linea azul al frente de la pata izquierda del botón hasta 5v. Colocar una resistencia de 10k desde la pata derecha del botón hasta el cable que esta en la linea azul.

Cargar el siguiente código:


int ledPin = 13; // Escoge el pin para el led
int inPin = 2; // Escoge el pin para el pulsador
int val = 0; // variable para leer el estado del pin

void setup()
{
  pinMode(ledPin, OUTPUT); // declara el LED como salida
  pinMode(inPin, INPUT); // declara el pulsador como entrada
}

void loop()
{
  val = digitalRead(inPin); // Lee el valor del pulsador
  if (val == HIGH) // verifica si la entrada es HIGH (Pulsador sin presionar)
  {
    digitalWrite(ledPin, LOW); // apaga el LED
  }
  else
  {
    digitalWrite(ledPin, HIGH); // Enciende el LED
  }
}

Digital In lectura de un pulsador

En este ejercicio al apretar el botón se apaga el LED que esta encendido y al soltar el botón se vuelve a prender.

Conectar el un cable desde la pata izquierda del botón hasta GND. Conectar un cable desde la linea J en la pata derecha del botón hasta el pin 10. Conectar un cable desde la linea azul al frente de la pata izquierda del botón hasta 5v. Entre la pata derecha y el cable en la linea azul colocar una resistencia de 10k.
Conectar el LED al pin 13.

Cargar el siguiente código:


/* Pulsador
*/
 int ledPin = 13;                    // PIN del LED
 int inPin = 10;                     // PIN del pulsador
 int value = 0;                      // Valor del pulsador
void setup() {
  pinMode(ledPin, OUTPUT);          // Inicializa el pin 13 como salida digital
  pinMode(inPin, INPUT);            // Inicializa el pin 10 como entrada digital
}
void loop() {
  value = digitalRead(inPin);       // Lee el valor de la entrada digital
  digitalWrite(ledPin, value);        
}

Analog In Potenciometro y comserial

Con este ejercicio se puede controlar la intensidad de luz de un LED con un potenciometro. A diferencia del ejercicio anterior el LED no parpadea.

*Conectar el potenciometro a Arduino. Un cable desde 5v a la pata izquierda del potenciometro, un cable desde GND a la pata derecha y un cable desde el puerto análogo A2 (indicando en el código que es A2) hasta la pata central del potenciometro.
*Conectar un LED. Un cable desde GND hasta la pata izquierda, un cable desde el puerto digital 9 (que es PWM) conectado por medio de una resistencia hasta la pata derecha del LED.

Código :


int potPin = 2;     // pin A/I para pot
int potValue = 0;   // vlor leirdo desde el pot
int led = 9;     // pin PWM con LED.

void setup() {
   // inicializar comunicación serial a 9600 bps:
  Serial.begin(9600);
}
void loop() {
  potValue = analogRead(potPin); // lee valor de pot
  analogWrite(led, potValue/4); // PWM el LED con valor de pot
// (dividido en 4 para que calce en un byte)
  Serial.println(potValue);     // imprime el valor del pot
delay(10);                     // espera 10 milliseg antes del prox loop
}

Analog In Potenciometro

En este ejercicio se conecta un potenciometro para que controle la velocidad en que el LED se prendera y apagara parpadeando.

Descripción:

El potenciometro es un dispositivo electromecánico que consta de una resistencia de valor fijo sobre la que se desplaza un contacto deslizante, el cursor, que la divide eléctricamente.

Se conecta el potenciometro a Arduino. Un cable conectado a 5v hacia la pata izquierda del potenciometro, un cable de GND a la pata derecha y un cable de A2 a la pata central del potenciometro.

Se conecta un LED a Arduino. Un cable desde GND hasta la pata izquierda del LED, un cable desde Pin 13 a través de una resistencia a la pata derecha del LED.

Código:

int potPin = 2; // seleccionar el pin de entrada analogico para el potenciometro

int ledPin = 13; // seleccionar el pin de salida digital para el LED

int val = 0; // variable para almacenar el valor capturado desde el sensor

void setup() {

  pinMode(ledPin, OUTPUT);  // declara el ledPin en modo salida

}

void loop() {

  val = analogRead(potPin);    // lee el valor del sensor

  digitalWrite(ledPin, HIGH);  // enciende LED

  delay(val);             // detiene el programa por un tiempo determinado por la variable

  digitalWrite(ledPin, LOW);   // apaga el LED

  delay(val);            // detiene el programa por un tiempo determinado por la variable

} 

Analog In lee LDR

Descripción:

Un LDR es una resistencia variable, que varia su valor dependiendo de la cantidad de luz que incide sobre su superficie.

Cuanta mas intensidad de luz incide en la superficie de la LDR menor será su resistencia y cuanto menos luz incide mayor será la resistencia.

Suelen ser utilizados como sensores de luz ambiental o como una fotocélula que activa un determinado proceso en ausencia o presencia de luz.

Con este ejercicio puedes encender y apagar un LED, la cantidad de tiempo que se encienda y apague depende de la cantidad de luz que el sensor detecte. Mientras más luz el LED se prendera y apagara más lento, mientras menos luz lo hará más rápido.

Sensor LDR:

*Se conecta un cable desde 5v a la pata derecha del sensor, un cable de A3 a la pata izquierda del sensor y un cable desde GND conectado a través de una resistencia a la pata izquierda del sensor y otro cable que desde la resistencia a la pata derecha del LED.

Se conecta, un LED al Pin 13 u otro Pin a elección, un cable desde el Pin(numero) a través de una resistencia a la pata izquierda del LED.

Como se ve indicado aquí:

Código:

int LightPin = 3; // selecciona el pin de entrada para el sensor de luz

int ledPin = 2; // selecciona el pin para el LED

int val = 0; // variable para almacenar el valor capturado desde el sensor

void setup() {

  pinMode(ledPin, OUTPUT);  // declara el ledPin en modo salida

}

void loop() {

  val = analogRead(LightPin);    // read the value from the sensor

  digitalWrite(ledPin, HIGH);  // enciende el LED

  delay(val);                  // detiene el programa por un tiempo

  digitalWrite(ledPin, LOW);   // apaga el LED

  delay(val);                  // detiene el programa por un tiempo

} 

Fotos:

LED fade in out

Fading : http://arduino.cc/en/Tutorial/Fading

Demuestra el uso del output análogo PWM para crear el efecto de desvanecimiento en un LED. PWM es un técnica obtener conductas análogas por un output digital.

Se conecta un cable a GND y luego a la pata más corta del LED, se conecta un cable a Pin 9 (que tiene la simbologia de PWM), luego a la pata más larga del LED y entremedio una resistencia de 220-ohm.

*Código:


#define LED 9   // pin LED
int i = 0;      // para contar arriba y abajo
void setup() {
  pinMode(LED, OUTPUT);   // le dice a Arduino que LED es un output
}
void loop(){
  for (i = 0; i < 255; i++) {   // loop de 0 a 254 (fade in)
    analogWrite(LED, i);        // setea brillo de LED
    delay(10);                 // espera 10ms porque analogWrite
                               // es instantaneo y podriamos
                               // no ver ningun cambio
  }
  for (i = 1; i > 0; i--) {   // loop de 255 a 1 (fade out)
    analogWrite(LED, i);      // setea brillo de LED
    delay(10);               // espera 10ms
  }
}

Blink

1)
Blink es el ejemplo básico de Arduino. Prende un LED por un segundo y lo apaga por un segundo ( o el tiempo que uno programe). Para este ejercicio usamos el Pin 13 ya que tiene un LED y una resistencia incorporados en la placa Arduino. Para este ejercicio solo necesitamos un LED.

*Observaciones: en el código, delay (1000), el número indica la cantidad de segundos en los cuales el LED se prendera y se mantendrá apagado.

*Código:

int ledPin =13;                // LED connected to digital pin 13

void setup()                    // run once, when the sketch starts

{

  pinMode(ledPin, OUTPUT);      // sets the digital pin as output

}

void loop()                     // run over and over again

{

  digitalWrite(ledPin, HIGH);   // sets the LED on

  delay(1000);                  // waits for a second

  digitalWrite(ledPin, LOW);    // sets the LED off

  delay(1000);                  // waits for a second

}

2) También se puede realizar este ejercicio siguiendo el siguiente esquema:

*Se conecta un cable a GND y a la pata izquierda del LED, se conecta un cable desde el Pin 8 (u otro) con la pata derecha del LED y entremedio un resistencia. 

En el código es necesario especificar a que Pin esta conectado, en int ledPin = (numero);

Con una resistencia de 10k el LED brilla menos que con una resistencia de 330.

LED con resistencia de 10K:

LED con resistencia 330: