Arduino


Prácticas de laboratorio para ARDUINO

Estos laboratorios han sido diseñados para que el interesado en ARDUINO, en el cual pueda entender su programación.  En esta recopilación encontraremos temas para implementar y diseñar sus propios proyectos con ARDUINO, por lo tanto se explicarán algunos conocimientos básicos:

Tipos de placas Arduino

Arduino al ser un sistema de Hardware libre, permite a los diseñadores hacer distintas versiones de circuitos impresos, entre ellos estan:


  • Arduino UNO
  • Arduino Mega 2560
  • Arduino Nano
  • Arduino Pro y Pro Mini
  • Arduino Lilypad (utilizado en e-textile)


¿Cuál de ellos escoger? Si eres "novato" en arduito te recomiendo que consigas el arduino UNO o el Arduino Mega 2560 y luego hagas el salto a las versiones más pequeñas de Arduino.

¿Qué cable necesito? Si utilizar Arduino UNO o Mega 2560, se utiliza un cable USB normal (del que utiliza la impresora), si utilizas las versiones más pequeñas, se utiliza un cable USB a USB mini.

Características de Arduino UNO
  • Entradas/Salidas digitales: Las encuentras en la parte superior de la placa de Arduino, numeradas del pin 1 al 13.
  • Pin 13 digital: Tiene adherido un LED superficial, por lo cual no se recomienda utilizar este pin como entrada ya que mantiene cierto voltaje en dicho pin.
  • PWM digital: Las encuentras en los pines digitales y estan identificados con el simbolo ~ debajo del número de pin.
  • Entradas Análogas: la encuentras en la parte inferior de la placa de Arduino y puedes utilizarlas como análogas o también como entradas/salidas digitales, son identificadas con el prefijo A#.
  • Botón de reset: presionalo si necesitas reiniciar tu programa, éste se tardará aproximadamente 1 segundo en correr el programa.
  • Pines de alimentación: los encuentras en la parte inferior de la placa de Arduino y puedes identificar sus voltajes de alimentación 5V, 3.3V, GND y Vref.
Pines de Arduino UNO:


Laboratorios

Es recomendable que aparte que se hagan los laboratorios al pie de la letra, también cambien de puertos de salida y entrada para poder adquidir la experiencia en el control de puertos. Para saber que hacen los comandos, les recomiendo visitar la página de Arduino: ARDUINO.

Para descargar el software de programación de Arduino, haz click aquí: arduino-0022.


NOTA: El pin Digital 13 es más difícil de usar que otros pines digitales porque tiene un LED y una resistencia asociada soldados a la placa en la mayoría de las placas. Si activa la resistencia pull-up 20k del interior, se pondra en alrededor de 1,7 V en lugar de los 5V que se esperan debido a que el LED integrado y la resistencia en serie bajan el nivel del voltaje, lo que se traduce en que siempre retornará bajo (LOW). Si estás obligado a usar el pin 13 como entrada digital, utiliza una resistencia pulldown externa.

LABORATORIO 1 - semáforo:  Realizar un programa en lenguaje C para el circuito mostrado abajo, el cual simule el funcionamiento de un semáforo con tiempos imaginarios.

Materiales:
  • 1 Arduino UNO
  • 3 resistencias 1 Kohms
  • 3 LED (rojo, amarillo, verde)
Intrucciones utilizadas:
  • pinMode: define si un pin del Arduino es entrada o salida, este comando es únicamente para 1 pin, asi que si quieres varios pines de entrada y salida se repite el comando y se cambia los campos.
  • digitalWrite: establece un estado lógico (1 o 0) en la salida del pin de Arduino.
  • delay: retardo en milisegundos
CÓDIGO FUENTE:
void setup() {
  pinMode (2,OUTPUT); //Configura el pin 2 como salida
  pinMode (3,OUTPUT);
  pinMode (4,OUTPUT);
}
void loop() {
  digitalWrite (2,HIGH); //Asigna un estado 1 lógico al pin 2
  delay (4000); //Retardo de 4 segundos (4000 ms)
  digitalWrite (2,LOW); //Asigna un estado 0 lógico al pin 2
  for (int cuenta = 0;cuenta <5;cuenta++)
  {
    digitalWrite (3,HIGH);
    delay (1000);
    digitalWrite (3,LOW);
    delay (200);
   }
  digitalWrite (4,HIGH);
  delay (5000);
  digitalWrite (4,LOW);
}

LABORATORIO 1a - semáforo:  Realizar un programa en lenguaje C para el circuito mostrado abajo, el cual simule el funcionamiento de un semáforo con tiempos imaginarios.


Materiales:
  • 1 Arduino UNO
  • 3 resistencias 1 Kohms
  • 3 LED (rojo, amarillo, verde)

CÓDIGO FUENTE:

void setup() {
  pinMode (2,OUTPUT);
  pinMode (3,OUTPUT);
  pinMode (4,OUTPUT);
  digitalWrite(3,HIGH);
  digitalWrite (4,HIGH);
  digitalWrite (5,HIGH);
}
void loop() {
  digitalWrite (2,LOW);
  delay (4000);
  digitalWrite (2,HIGH);
  for (int cuenta = 0;cuenta <5;cuenta++)
  {
    digitalWrite (3,LOW);
    delay (1000);
    digitalWrite (3,HIGH);
    delay (200);
   }
  digitalWrite (4,LOW);
  delay (5000);
  digitalWrite (4,HIGH);
}

LABORATORIO 2 - ADC:  Realizar un programa en lenguaje C para el circuito mostrado, el cual lea un valor  analógico en uno de sus puertos recibido por el potenciómetro e indique con 3 leds si es un nivel de voltaje alto (verde), medio (amarillo) o bajo(rojo) que recibe en su puerto.


Materiales:
  • 1 Arduino UNO
  • 3 resistencias 1 Kohms
  • 1 resistencia de 330 ohms
  • 1 potenciometro de 10 Kohms
  • 3 LED (rojo, amarillo, verde)

CÓDIGO FUENTE:
int valor = 0;
void setup() {
  pinMode (2,OUTPUT);
  pinMode (3,OUTPUT);
  pinMode (4,OUTPUT);
  digitalWrite(3,HIGH);
  digitalWrite (4,HIGH);
  digitalWrite (5,HIGH);
}
void loop() {
  valor = analogRead(A5); //Almacena en la variable "valor" la lectura análoga en el ADC5
  if (valor < 341)
  {
    digitalWrite (3,HIGH);
    digitalWrite (4,HIGH);
    digitalWrite (2,LOW);
   }
   if (valor > 340 && valor <683)
  {
    digitalWrite (2,HIGH);
    digitalWrite (4,HIGH);
    digitalWrite (3,LOW);
   }
   if (valor > 683)
  {
    digitalWrite (3,HIGH);
    digitalWrite (2,HIGH);
    digitalWrite (4,LOW);
   }
}

LABORATORIO 3 - PWMRealizar un programa en lenguaje C para el circuito mostrado, el cual lea un valor  analógico en uno de sus puertos recibido por el potenciómetro y atenue la intensidad lumínica de un led según sea el valor recibido del potenciómetro.

Materiales:
  • 1 Arduino UNO
  • 1 resistencia 1 Kohms
  • 1 resistencia de 330 ohms
  • 1 potenciometro de 10 Kohms
  • 1 LED rojo

Intrucciones utilizadas:
  • analogRead: se utiliza para leer los valores de las entradas analógicas del Arduino (cabe resaltar que con pinMode tambien se pueden configurar los puertos analógicos como salidas digitales).
  • map: hace una reasignación de un rango a otro
  • analogWrite: utiliza salidas análogas (se encuentran entre los pines digitales y se identifican porque arriba del número tiene el simbolo: ~) para dar valore analogos.

CÓDIGO FUENTE:

int valor,valor1;
void setup() {
  pinMode (9,OUTPUT);
}
void loop() {
  valor = analogRead(A5);
  valor1 = map(valor,0,1023,0,254); //reasigna un valor de un rango a otro
  analogWrite (9,valor1); //Envia un pulso PWM al pin
}

LABORATORIO 4 - switch tipo toggle:  Realizar un programa en lenguaje C para el circuito mostrado, el cual lea un valor  lógico 1 y luego 0  por medio de un interruptor.


Materiales:
  • 1 Arduino UNO
  • 1 resistencia 1 Kohms
  • 1 resistencia de 10 Kohms
  • 1 resistencia de 330 ohms
  • 1 switch pulsador
  • 1 LED rojo
CÓDIGO FUENTE:

int estado=0,control=0,control1=2;
void setup() {
  pinMode (4,OUTPUT);
  pinMode (3,INPUT); //Configura al pin 3 como entrada
  digitalWrite (4,HIGH);
}
void loop() {
  estado = digitalRead (3);
  if (estado == HIGH)
  {
    delay (200);
    estado = digitalRead (3);
     if (estado == LOW)
     {
       switch (control)
       {
         case 0: digitalWrite (4,HIGH); control = 1; break;
         case 1: digitalWrite (4,LOW); control = 0; break;
       }
      }
   }
}

LABORATORIO 4a - switch tipo toggle:  Realizar un programa en lenguaje C para el circuito mostrado, el cual lea un valor  lógico 0 y luego 1  por medio de un interruptor.

Materiales:
  • 1 Arduino UNO
  • 1 resistencia 1 Kohms
  • 1 resistencia de 10 Kohms
  • 1 resistencia de 330 ohms
  • 1 switch pulsador
  • 1 LED rojo

CÓDIGO FUENTE:
int estado=0,control=0,control1=2;
void setup() {
  pinMode (4,OUTPUT);
  pinMode (3,INPUT);
  digitalWrite (4,HIGH);
}
void loop() {
  estado = digitalRead (3);
  if (estado == LOW)
  {
    delay (200);
    estado = digitalRead (3);
     if (estado == HIGH)
     {
       switch (control)
       {
         case 0: digitalWrite (4,HIGH); control = 1; break;
         case 1: digitalWrite (4,LOW); control = 0; break;
       }
      }
   }
}

LABORATORIO 5 - temperaturaRealizar un programa en lenguaje C para el circuito mostrado, el cual lea la temperatura medida por el DS18B20 y envie el valor de la temperatura por medio de la comunicación serial a la PC. Descarga la libreria "One Wire" y copiala a la carpeta libraries en la carpeta de Arduino, descargalo aquí: One Wire.

Materiales:
  • 1 Arduino UNO
  • 1 resistencia de 10 Kohms
  • 1 DS18B20
CÓDIGO FUENTE:
 #include <OneWire.h>

OneWire ds(4);  // en que pin
int BMS, BLS, LecturaT, Signo, Tc_100, Temp, decimas;

void setup(void) {
  Serial.begin(9600); //inicia comunicación serial con PC
}

void loop(void) {
  byte i;
  byte present = 0;
  byte data[12];
  byte addr[8];

  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);

  delay(1000);

  present = ds.reset();
  ds.select(addr);   
  ds.write(0xBE);

  for ( i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
  BLS = data[0];
  BMS = data[1];
  LecturaT = (BMS << 8) + BLS;
  Signo = LecturaT & 0x8000;
  if (Signo)
  {
    LecturaT = (LecturaT ^ 0xffff) + 1;
  }
  Tc_100 = (6 * LecturaT) + LecturaT / 4;

  Temp = Tc_100 / 100;
  decimas = Tc_100 % 100;

  Serial.print("valor: ");
  if (Signo)
  {
     Serial.print("-");
  }
  Serial.print(Temp);
  Serial.print(".");
  if (decimas < 10)
  {
     Serial.print("0");
  }
  Serial.print(decimas);
  Serial.print("\n");
}


LABORATORIO 6 - servomotorRealizar un programa en lenguaje C para el circuito mostrado, el cual haga que un servomotor gire media vuelta y luego regrese al origen, el ciclo debe ser infinito.

Materiales:
  • 1 Arduino UNO
  • 1 resistencia de 330 ohms
  • 1 servomotor

CÓDIGO FUENTE:

#include <Servo.h>  //Libreria servomotor, se puede tener hasta 9 servomotores funcionando
Servo servomotor; //Nombrar (en este caso se llama "servomotor") a cada uno de los servos
int pos = 0;
void setup()
{
  servomotor.attach(12); //en que pin esta el servo
}

void loop()
{
  for(pos = 0; pos < 180; pos += 5)
  {                              
    servomotor.write(pos); //Envia pulso para mover servo        
    delay(20);                  
  }
  for(pos = 180; pos>=0; pos-=5)
  {                              
    servomotor.write(pos);          
    delay(20);                  
  }


LABORATORIO 6a - servomotorRealizar un programa en lenguaje C para el circuito mostrado, el cual haga que un servomotor gire dependiendo de la cantidad que se gira un potenciómetro. Los límites de funcionamiento de dicho motor con respecto a su posición son: mínimo 0 y máximo 180.


Materiales:
  • 1 Arduino UNO
  • 2 resistencias de 330 ohms
  • 1 potenciometro 10 Kohm
  • 1 servomotor
CÓDIGO FUENTE:

#include <Servo.h>
Servo 
servomotor;
int analogo = 4;
int valor;
void setup()
{
  
servomotor.attach(12);
}
void loop()
{
  valor = analogRead(analogo);          
  valor = map(valor, 0, 1023, 0, 179);  
  
servomotor.write(valor);                
  delay(20);                        


LABORATORIO 7 - sonidos morseRealizar un programa en lenguaje C para el circuito mostrado, el cual haga piezo sounder produzca un sonido semejante al código morse. Utilizando los dos circuitos mostrados.

Circuito 1:

Circuito 2:

Materiales:
  • 1 Arduino UNO
  • 1 resistencia de 1 Kohms
  • 1 2N2222
  • 1 diodo 1N4004
  • 1 piezo buzzer
  • 1 capacitor de 0.1uf 25V

CÓDIGO FUENTE:

int repite;
void setup() {
  pinMode(8, OUTPUT);
}
void loop() {
  buzz(8, 2500, 500);
  delay(1000);
}
void buzz(int Pinsalida, long frecuencia, long tiempo) {
  long retardo = 1000000/frecuencia/2;
  long ciclos = frecuencia* tiempo/ 1000;
 for (repite=0; repite<4;repite++)
 {
 for (long i=0; i < ciclos; i++){
    digitalWrite(Pinsalida,HIGH);
    delayMicroseconds(retardo); //Retardo en microsegundos
    digitalWrite(Pinsalida,LOW);
    delayMicroseconds(retardo-100);
  }
 delay (100);
 }
 delay (800);
}

LABORATORIO 8 - sensor HallRealizar un programa en lenguaje C para el circuito mostrado, el cual detecte un campo magnético por medio de un sensor de efecto Hall (A3144), apague el LED.

Materiales:
  • 1 Arduino UNO
  • 1 sensor de efecto Hall A3144
  • 1 resistencia 1Kohm
  • 1 LED rojo

CÓDIGO FUENTE:
int puerto;

void setup() {
  pinMode (2,INPUT);
  pinMode (12,OUTPUT);
}

void loop() {
  puerto = digitalRead (2);
  if (puerto == HIGH)
  {
    digitalWrite (12,HIGH);
  }
  if (puerto == LOW)
  {
      digitalWrite (12,LOW);
   }
}


LABORATORIO 9 - control de puertos: EN DESARROLLO.

LABORATORIO 10 - protocolo I2C: Realizar un programa en lenguaje C para el circuito mostrado, el cual grabe por I2c a una memoria EEPROM dos valores 78 y 66 presionando dos interruptores (cada interruptor para cada uno de los valores) y ese mismo PICAXE cuando se presione otro interruptor y lee en la EEPROM 78 hará parpadear el LED del pin 13.




Materiales:
  • 1 Arduino UNO
  • 3 interruptores
  • 3 resistencia 10Kohm
  • 3 resistencia 1Kohm
  • 1 24LC256
Intrucciones utilizadas:
  • Wire.h: librería para el protocolo I2C, define los comandos para lectura y escritura en dispositivos que se puedan comunicar por I2C.
CÓDIGO FUENTE:
#include <Wire.h>
#define eeprom 0x50    //Dirección de la memoria 24LC256
int estado1, estado2, estado3, busqueda;
int luz = LOW;
byte valormem = 0xFF;
unsigned int direccion = 0;

void setup(void){
  pinMode (8,INPUT);
  pinMode (9,INPUT);
  pinMode (10,INPUT);
  pinMode (13,OUTPUT);
  Wire.begin();
}

void loop(){
  estado1 = digitalRead(8);
  if (estado1 == HIGH)
  {
    delay(150);
    estado1 = digitalRead(8);
    if (estado1 == LOW)
    {
       writeEEPROM(eeprom, direccion, 78);
    }
  }
  estado2 = digitalRead(9);
  if (estado2 == HIGH)
  {
    delay(150);
    estado2 = digitalRead(9);
    if (estado2 == LOW)
    {
       writeEEPROM(eeprom, direccion, 66);
    }
  }
  estado3 = digitalRead(10);
  if (estado3 == HIGH)
  {
    delay(150);
    estado3 = digitalRead(10);
    if (estado3 == LOW)
    {
      Wire.beginTransmission(eeprom);
      Wire.write((int)(direccion >> 8));   // MSB
      Wire.write((int)(direccion & 0xFF)); // LSB
      Wire.endTransmission();
      Wire.requestFrom(eeprom,1);
      if (Wire.available()) valormem = Wire.read();
      if (valormem == 78)
      {
       for (int ciclo=0;ciclo <21;ciclo++)
       {
         luz = !luz;
         digitalWrite(13,luz);
         delay (300);
         valormem = 0;
       }
      }
    }
  }
}

void writeEEPROM(int deviceaddress, unsigned int eeaddress, word data ) {
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
  delay(5);
}

LABORATORIO 11 - interrupciones: Realizar un programa en lenguaje C para el circuito mostrado, el cual interrumpa el parpadeo de un LED utilizando una interrupción en el pin INT 0 (PIN DIGITAL 2).





Materiales:
  • 1 Arduino UNO
  • 1 interruptor
  • 1 resistencia 4.7Kohm
  • 1 resistencia 1Kohm
  • 1 555
  • 2 capacitores de 0.1uF
  • 1 LED
Intrucciones utilizadas:
  • attachInterrupt: comando para configurar las interrupciones del Arduino (Arduino UNO tiene 2 interrupciones en los pines digitales 2 y 3), agregando el nombre de la subfuncion y el estado de disparo de la interrupción, cabe resaltar que cuando Arduino entra en interrupción el comando delay o milis son desactivados, en el caso de milis la función se queda en pausa hasta que se salga de la interrupción.

CÓDIGO FUENTE:
 int estado=LOW;
void setup() {
  pinMode (2,INPUT);
  pinMode (12,OUTPUT);
  pinMode (13,OUTPUT);
  attachInterrupt(0,inversion,FALLING);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(300);
  digitalWrite(13, LOW);
  delay(300);
}

void inversion()
{
  estado = !estado;
  digitalWrite(12,estado);
}