Blog

8. Control de servo de 0 a 180º. Tutorial Arduino

Para controlar un servo motor de giro continuo, debemos conectar el motor a la placa
del microcontrolador en función de las indicaciones del manual del motor.
Servomotor: EMAX ES08MA II

Las tres conexiones que debemos realizar son las siguientes:
VCC (Cable Anaranjado)
GND (Cable Negro)
Señal (Cable Amarillo)
Para el control del motor, conectaremos el cable identificado como “señal” al puerto 9
del Arduino UNO.
Para nuestro ejemplo, utilizamos un sensor Shield para Arduino UNO.
El sensor Shield, es una placa auxiliar que se coloca sobre el Arduino y nos permite
hacer las conexiones hacia los sensores, interruptores y en nuestro caso a los motores
de una forma mas sencilla.

Una vez realizadas las conexiones, debemos incluir en el programa del Arduino, la
librería servo.h

Esta librería nos permitirá controlar el servo de una manera muy sencilla.
La librería servo.h ya viene incluida en el ide de Arduino, por lo que no será necesario
descargar otra librería para efectuar el control del servomotor.
Luego debemos declarar el objeto que estará asociado al control de este motor.

Esto lo hacemos mediante la siguiente instrucción:
miservo.attach(9)
donde el argumento de la función, corresponde al pin en donde estará conectado el
cable identificado como “Señal” del motor.
Para nuestro ejemplo, hemos conectado el cable de control al pin 9 del Arduino UNO.
Por ultimo debemos escribir la instrucción con la cual controlaremos el ángulo del
servomotor.
Se trata de la instrucción miservo.write()

Como estamos trabajando con un servomotor de giro limitado, El argumento de esta
función corresponderá a la posición del eje del servomotor.
Si utilizamos (0) como argumento, el motor girara y se posicionara en 0 grados.
Si utilizamos (90), el motor girara y se posicionara en 90 grados.
Si utilizamos (180), el motor girara y se posicionara en 180 grados.

El programa hará que el eje del motor se posicione en 0 grados, haga una pausa de 1
segundo, luego se posicionara en 180 grados, hará una pausa de 1 segundo, luego
regresa a 0 grados, haga una pausa de ½ segundo, luego se posicionara en 45, 90, 135,
180 y regrese a 135, 90, 45 y 0 grados. Volviendo a realizar el ciclo.
Como pueden observar, es muy fácil controlar un servomotor utilizando un Arduino.

La Navidad con Arduino

Ya queda algo lejos la Navidad, pero siempre vuelve… así que queremos compartir con vosotros el proyecto de Mae, un árbol programado con arduino con luces y canciones navideñas. Os compartimos el paso a paso del proyecto debajo del video, esperamos que os guste 🙂

CONECTANDO EL ALTAVOZ A LA PLACA DE ARDUINO:

  • Conectar el cable de tierra que sale del altavoz a GND de Arduino.
  • El otro cable conectarlo al pin 5.

CONECTANDO LOS LEDS:

Nuestra tira de leds funciona a 12 voltios y Arduino sólo proporciona 5 voltios  por lo que son necesarios tres transistores (uno por cada uno de los colores básicos de la tira:Rojo Verde y Azul) que funcionen como amplificadores.

Para simplificar el proyecto, partimos de los transistores ya  implementados por lo que únicamente es necesario realizar las siguientes conexiones:

  • Cable negro a GROUND
  • Cable rojo al pin 9
  • Cable verde al pin 10
  • Cable azul al pin 11

En este enlace se incluye la explicación detallada del control de tiras de LED de 12 voltios con Arduino: https://www.youtube.com/watch?v=Shly4dIspPY

El código del que hemos partido para incluir los villancicos se puede encontrar en: https://www.hackster.io/joshi/piezo-christmas-songs-fd1ae9

En la url anterior se hace referencia a la librería pitches que se puede descargar desde:

https://www.arduino.cc/en/Tutorial/toneMelody

Este es el código que hemos utilizado y que puedes compilar y subir a la placa:

/*

  Arduino Christmas Songs

  Based on a project and code by Dipto Pratyaksa, updated on 31/3/13

  Modified for Christmas by Joshi, on Dec 17th, 2017.

  Modificado por RGG 2019

*/

#include “pitches.h”

#define melodyPin 5

#define red 9

#define green 10

#define blue 11

int t = 500;

// Jingle Bells

int melody[] = {

  NOTE_E5, NOTE_E5, NOTE_E5,

  NOTE_E5, NOTE_E5, NOTE_E5,

  NOTE_E5, NOTE_G5, NOTE_C5, NOTE_D5,

  NOTE_E5,

  NOTE_F5, NOTE_F5, NOTE_F5, NOTE_F5,

  NOTE_F5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5,

  NOTE_E5, NOTE_D5, NOTE_D5, NOTE_E5,

  NOTE_D5, NOTE_G5

};

int tempo[] = {

  8, 8, 4,

  8, 8, 4,

  8, 8, 8, 8,

  2,

  8, 8, 8, 8,

  8, 8, 8, 16, 16,

  8, 8, 8, 8,

  4, 4

};

// We wish you a merry Christmas

int wish_melody[] = {

  NOTE_B3, 

  NOTE_F4, NOTE_F4, NOTE_G4, NOTE_F4, NOTE_E4,

  NOTE_D4, NOTE_D4, NOTE_D4,

  NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_F4,

  NOTE_E4, NOTE_E4, NOTE_E4,

  NOTE_A4, NOTE_A4, NOTE_B4, NOTE_A4, NOTE_G4,

  NOTE_F4, NOTE_D4, NOTE_B3, NOTE_B3,

  NOTE_D4, NOTE_G4, NOTE_E4,

  NOTE_F4

};

int wish_tempo[] = {

  4,

  4, 8, 8, 8, 8,

  4, 4, 4,

  4, 8, 8, 8, 8,

  4, 4, 4,

  4, 8, 8, 8, 8,

  4, 4, 8, 8,

  4, 4, 4,

  2

};

// Santa Claus is coming to town

int santa_melody[] = {

  NOTE_G4,

  NOTE_E4, NOTE_F4, NOTE_G4, NOTE_G4, NOTE_G4,

  NOTE_A4, NOTE_B4, NOTE_C5, NOTE_C5, NOTE_C5,

  NOTE_E4, NOTE_F4, NOTE_G4, NOTE_G4, NOTE_G4,

  NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4,

  NOTE_E4, NOTE_G4, NOTE_C4, NOTE_E4,

  NOTE_D4, NOTE_F4, NOTE_B3,

  NOTE_C4

};

int santa_tempo[] = {

  8,

  8, 8, 4, 4, 4,

  8, 8, 4, 4, 4,

  8, 8, 4, 4, 4,

  8, 8, 4, 2,

  4, 4, 4, 4,

  4, 2, 4,

  1

};

void setup(void) {

  pinMode(5, OUTPUT); // Zumbador

  pinMode(13, OUTPUT); // Indicador de Led cuando se reproduce una nota

  randomSeed(analogRead(0));

 }

void loop() {

  sing(1);

  delay(3000);

  sing(2);

  delay(3000);

  sing(3);

  delay(5000);

}

int song = 0;

void sing(int s) {

  // Iteracciones sobre las notas de la melodía:

  song = s;

  if (song == 3) {

    Serial.println(” ‘We wish you a Merry Christmas'”);

    int size = sizeof(wish_melody) / sizeof(int);

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

      // Para calcular la duración de una nota, dividimos un segundo entre el tipo de nota

     int noteDuration = 1000 / wish_tempo[thisNote];

      buzz(melodyPin, wish_melody[thisNote], noteDuration);

      // Para distinguir las notas, establecemos un tiempo mínimo entre ellas.

      // la duración de la nota + 30% funciona bien:

      int pauseBetweenNotes = noteDuration * 1.30;

      delay(pauseBetweenNotes);

      // deja de sonar el tono

      buzz(melodyPin, 0, noteDuration);

    }

  } else if (song == 2) {

    Serial.println(” ‘Santa Claus is coming to town'”);

    int size = sizeof(santa_melody) / sizeof(int);

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

      // Para calcular la duración de una nota, dividimos un segundo entre el tipo de nota

      int noteDuration = 900 / santa_tempo[thisNote];

      buzz(melodyPin, santa_melody[thisNote], noteDuration);

     // Para distinguir las notas, establecemos un tiempo mínimo entre ellas.

      // la duración de la nota + 30% funciona bien:

      int pauseBetweenNotes = noteDuration * 1.30;

      delay(pauseBetweenNotes);

       // deja de sonar el tono

      buzz(melodyPin, 0, noteDuration);

    }

  } else {

    Serial.println(” ‘Jingle Bells'”);

    int size = sizeof(melody) / sizeof(int);

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

       // Para calcular la duración de una nota, dividimos un segundo entre el tipo de nota

      int noteDuration = 1000 / tempo[thisNote];

      buzz(melodyPin, melody[thisNote], noteDuration);

       // Para distinguir las notas, establecemos un tiempo mínimo entre ellas.

      // la duración de la nota + 30%  funciona bien:

      int pauseBetweenNotes = noteDuration * 1.30;

      delay(pauseBetweenNotes);

       // deja de sonar el tono

      buzz(melodyPin, 0, noteDuration);

    }

  }

}

void buzz(int targetPin, long frequency, long length) {

  //inicializamos las variables para los colores de los leds

  int ColorR = 0;

  int ColorG = 0;

  int ColorB=0;

  digitalWrite(13, HIGH);

  //Los colores los generamos aleatoriamente

  ColorR=random(0,255);

  ColorG=random(0,255);

  ColorB=random(0,255);

  //Enviamos el valor de los colores básicos para generar el color final

  analogWrite(green, ColorG);

  analogWrite(red, ColorR);

  analogWrite(blue, ColorB);

  long delayValue = 1000000 / frequency / 2; // calcula el valor de espera entre transiciones

  long numCycles = frequency * length / 1000; //calcula el número de ciclos 

  for (long i = 0; i < numCycles; i++) { //bucle para el número de ciclos que hemos obtenido

    digitalWrite(targetPin, HIGH); // enviamos el valor  high al zumbador

    delayMicroseconds(delayValue); // esperamos el tiempo calculado

    digitalWrite(targetPin, LOW); //enviamos el valor low al zumbador 

    delayMicroseconds(delayValue); // esperamos el tiempo calculado

  }

  digitalWrite(13, LOW);

 }

No olvides copiar el fichero pitches.h a Arduino/libraries

Comprueba que el altavoz reproduce correctamente los villancicos y se encienden los leds.

Puedes probar a cambiar los colores de los LEDS en lugar de generarlos aleatoriamente. Para ello, puede ser útil la página https://www.colorspire.com/rgb-color-wheel/ (Donde, dado un color nos indica la cantidad de Rojo, Verde y Azul necesario).

Una palanca moderna

Hoy os presentamos una construcción simple y genial: una palanca, pero adaptada a robótica, con motores y engranajes… nos lo enseña su creadora Noa, una fantástica mini ingeniera con mucha creatividad y conocimientos.

¿Qué os parece?

7. Control servo continuo. Tutorial Arduino

Para controlar un servo motor de giro continuo, debemos conectar el motor a la placa
del microcontrolador en función de las indicaciones del manual del motor.
Las tres conexiones que debemos realizar son las siguientes:
VCC, GND y Señal.
Una vez realizadas las conexiones, debemos incluir en el programa del Arduino, la librería
servo.h

Esta librería nos permitirá controlar el servo de una manera muy sencilla.
La librería servo.h ya viene incluida en el ide de Arduino, por lo que no será necesario
descargar otra librería para efectuar el control del motor.
Luego debemos declarar el objeto que estará asociado al control de este motor.

Esto lo hacemos mediante la siguiente instrucción:
miservo.attach(9)
donde el argumento de la función, corresponde al pin en donde estará conectado el cable
del motor que corresponde a la señal de control.
Para nuestro ejemplo, hemos conectado el cable de control al pin 9 del Arduino UNO.

Por ultimo debemos escribir la instrucción con la cual controlaremos la velocidad del
motor.
Se trata de la instrucción miservo.write()
Como estamos trabajando con un servomotor de giro continuo, El argumento de esta
función corresponderá a la velocidad con la cual girara el motor.
Si utilizamos (0) como argumento, el motor girara a máxima velocidad hacia un sentido.
Si utilizamos (90), el motor de detendrá.
Si utilizamos (180), el motor girara en sentido contrario.

Como estas instrucciones están escritas en el void loop (), estas se ejecutaran en forma
continua.

El motor girara en un sentido a máxima velocidad por 2 segundos,
luego se detendrá por 2 segundos,
el motor girara a máxima velocidad y en sentido opuesto por 2 segundos,
luego se detendrá por 2 segundos,
y se repetirá continuamente mientras el microcontrolador este energizado.
Ustedes pueden experimentar utilizando otros valores entre los señalados y comprueben
que ocurre con la velocidad del motor.

Robot hambriento2 con sensor IR

Vamos a construir un robot que se accione al depositar un objeto en su bandeja. 

ELEMENTOS:

  • Componentes del robot impresos
  • Servo
  • Sensor de IR
  • Placa Arduino
  • Cables

Partimos del robot impreso y montado de la versión 1 con MRT.

Incluye el sensor de IR en la carcasa del robot y fija el servo. Puedes seguir las instrucciones en el tutorial  https://www.youtube.com/watch?v=KfP_LfUiwdc

Realiza la siguiente implementación con la placa de Arduino:

CODIFICACIÓN

1.- INTRODUCCIÓN

Comentario que describe el programa, autor, fecha etc.

Por ejemplo:

/*

 * ROBOT  HAMBRIENTO 

 * 

* Autor:

* DICIEMBRE 2019

* 1 SERVO

* 1 SENSOR DE INFRARROJOS

*

* El brazo del robot se mueve cuando el sensor IR detecta un objeto 

 * 

 */

2.- SECCIÓN ENCABEZADO

DECLARACIÓN DE OBJETOS, VARIABLES, CONSTANTES:

  • Hay que incluir la librería del servo:

Desde menú Programa, elige ‘Incluir librería’ y luego elegir ‘Servo’

En el programa aparecerá la línea de código:

#include <Servo.h>

  • Hay que declarar una constante de tipo entero para indicar el pin de Arduino dónde está conectado el sensor IR

const int pinSI = 3;

  • Hay que declarar una constante de tipo entero para indicar el pin de Arduino dónde está conectado el sensor IR

const int pinServo = 12;

3.- SECCIÓN SETUP

En esta sección se incluye el código que sólo se ejecuta una vez:

Configuraciones, inicializaciones … 

  • Configura el pin del sensor de infrarrojos para que se comporte como entrada mediante la función pinMode():

      pinMode(pinSI, INPUT);

  • Asocia el pin al servo

      armServo.attach(pinServo);

  • Mueve el servo a la posición inicial

                armServo.write(90);

4.- SECCIÓN LOOP

En esta sección vamos a codificar la siguiente secuencia de instrucciones:

  • Cuando el sensor detecta un objeto su valor es 0, entonces hay que comerse lo que hay en la bandeja:
  • Esperamos dos segundos
  • Decimos cuál es el pin del servo
  • Subimos el brazo: Mover el servo 10 grados
  • Esperamos 300 milisegundos
  • Bajamos el brazo:Mover el brazo 90 grados
  • Esperamos medio segundos
  • Liberamos el brazo

El código correspondiente sería:

//Si hay objeto:

if (digitalRead(pinSI) == 0) {

  //esperamos un segundo

    delay(1000);

  // Asociamos el pin 12 al servo

  armServo.attach(12);

  // Movemos el motor 10 grados (brazo arriba)

 armServo.write(10);

  // esperamos 300 ms

  delay(300);

  // Movemos el motor 90 grados (brazo abajo)

  armServo.write(90);

  //Esperamos medio segundo

  delay(500);

  // Liberamos el brazo

  armServo.detach();

}

  • Compila el programa (traducir nuestro código a 0 y 1 que es lo que entiende el microcontrolador (Arduino). Las teclas:Control+R
  • Corrige los errores si los hubiera
  • Sube el código a la placa. Las teclas:Control+U
  • Comprueba el funcionamiento.
  • Si es necesario calibrar el sensor se pueden seguir las instrucciones desde la url: http://diwo.bq.com/programando-un-sensor-infrarrojo-en-bitbloq/

6.Control de una salida analógica. Tutorial Arduino

Antes de escribir un programa para controlar una salida analógica del Arduino,
debemos empezar por identificar que puertos del Arduino están dispuestos para
generar una señal en base a un PWM y en segundo lugar explicaremos que es una señal
PWM.

PWM PINS: 3, 5, 6, 9, 10, 11

¿Qué es PWM y cómo funciona?
La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de
pulse-width modulation) de una señal o fuente de energía es una técnica en la que se
modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por
ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o
para controlar la cantidad de energía que se envía a una carga.
El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en
relación con el período. Expresado matemáticamente:

D es el ciclo de trabajo
es el tiempo en que la función es positiva (ancho del pulso)
T es el período de la función

Para las salidas analógicas se usan los pines que están marcados como PWM y es que
en realidad las salidas analógicas no dan una señal continua a un nivel determinado,
sino que mediante pulsos consiguen obtener un nivel de tensión promedio proporcional
al ancho de estos pulsos.

Como se puede ver en la imagen superior, variando en ancho del pulso, podemos
obtener una señal promedio equivalente.
Para la primera señal, cuyo ancho de pulso es del 10%, nos daría una señal analógica de
0.5v (el 10% de 5V).
Para la segunda una señal, cuyo ancho de pulso es del 50%, nos daría una señal
analógica de 2.5v.
Y para la tercera señal obtendríamos una señal, cuyo ancho de pulso es del 90%,
obtendríamos un valor equivalente de 4.5v.
Instrucciones para controlar la salida analógica en un Arduino.
La instrucción que debemos implementar es la siguiente:

analogWrite

Sintaxis:
analogWrite(pin, value)

Parámetros:
pin: el pin Arduino para escribir. Tipos de datos permitidos: int.
value: El ciclo de trabajo: entre 0 (siempre apagado) y 255 (siempre encendido). Tipos
de datos permitidos: int.

Programa de ejemplo:
Para modificar el valor del voltaje en la salida PWM seleccionada (pin 6), solo basta con
modificar el argumento (value) de la función analogWrite.
Value, solo permite un valor entre 0 y 255.
Con value igual a 255, obtendremos aproximadamente 5 Vdc en el pin seleccionado,
para el ejemplo (pin 6).

Con value igual a 127, obtendremos aproximadamente 2.3 Vdc

Con value igual a 0, obtendremos 0 Vdc.

De esta forma podemos controlar el nivel de voltaje que deseamos sobre el pin 6. Para
medir el voltaje utilizamos un multímetro. Recuerden que el parámetro value, solo
admite valores entre 0 y 255.
Para value = 0, El voltaje será 0 Vdc
Para value = 255, el voltaje será 5 Vdc.

Semillero controlado por Arduino

Un proyecto que trata de implementar un riego por goteo.

El agua almacenada en un depósito será extraída a través de un tubo de riego por la acción de una bomba alimentada con una batería.

Por su parte, la bomba será activada a través de un relé conectado a una placa Arduino UNO.

A partir del código, encendemos o apagamos la bomba enviando una señal HIGH o LOW al relé que abrirá o cerrará el circuito (el valor correcto dependerá del fabricante).


En esta versión, hemos realizado una codificación sencilla en la que la bomba se activa y desactiva cada 5 segundos.

Este proyecto, se podrá ampliar utilizando sensores de humedad que determinaran la activación de la bomba, incluir una fuente de luz, un sensor de temperatura que puede determinar la activación de un ventilador etc. en otra versión mejorada iremos viendo los avances del mismo. Os compartimos el código sencillo realizado y el video explicativo para ver el resultado.

/*

  • Semillero riego automatico 1.0
    • RGG 2019
    • 1 Relé
  • 1 Bomba
    • Se trata de accionar la bomba de agua a partir de un relé conectado a Arduino
      */

//Indicamos el pin donde está conectado el Relé
const int pinRL = 9;

void setup() {
// put your setup code here, to run once:

//Indicamos los pines de Salida
pinMode(pinRL, OUTPUT);

//Abrimos una conexión serie con el PC
Serial.begin(9600);
}

void loop() {
// put your main code here, to run repeatedly:
//Enviamos un valor HIGH al pin del Relé
digitalWrite(pinRL, HIGH);
Serial.println (“Enviamos un High”);
//Esperamos 5 segundos
delay(5000);

//Enviamos un valor LOW al pin del Relé
digitalWrite(pinRL, LOW);
Serial.println (“Enviamos un LOW se activa el relé y la bomba”);
//Esperamos 5 segundo
delay(5000);
}

La caja de sombras, Arduino

Realizamos una caja que recree una escena dando la impresión de tres dimensiones. Para ello, hemos impreso una caja y tres paneles con los siguientes planos:

  • primer plano vegetación
  • segundo plano: ciervo y arbolado
  • tercer plano: horizonte de casas

Con Arduino le hemos dotado de iluminación. Los ficheros stl para la impresión los hemos descargado de THINGIVERSE:
Los paneles: https://www.thingiverse.com/thing:2746834 (el último panel de montañas no lo hemos impreso para que el resultado no fuera demasiado opaco)

La caja: https://www.thingiverse.com/thing:2449008

Hemos preferido esta caja porque a diferencia del proyecto ‘Winter in 3D’ de donde hemos elegido los paneles de la escena, la pared posterior no es maciza.Una vez descargados,  con la aplicación CURA hemos generado los ficheros gcode realizando las modificaciones necesarias para que los paneles se puedan insertar en la caja: 72x74x1.1 mm.

La calidad de impresión la hemos rebajado para que fuera viable imprimirlos en clase (altura del filamento para el primer plano: 015, segundo 02 y tercero 03. Relleno al 100%).

Respecto a la iluminación, hemos implementado en una placa protoboard dos leds conectándolos a un Arduino UNO y realizando la codificación para encenderlos durante 10 segundos. Posteriormente, se mantienen apagados durante otros 10 segundos.

Adjuntamos el código para un led, se podría modificar para incluir más leds.

/*

  • LED 1.0 para la caja de sombras
    • Daniela 2019
    • 1 LED
    • Encendido de un led y apagado transcurrrido un tiempo

  • */

//Indicamos el pin donde está conectado el LED
const int ledPIN = 13;

void setup() {
// put your setup code here, to run once:
//Indicamos que el pin del LED es de Salida
pinMode(ledPIN , OUTPUT);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(ledPIN , HIGH); // enviamos al Pin el valor HIGH
delay(10000); // esperamos 10 segundos
digitalWrite(ledPIN , LOW); // enviamos al Pin el valor LOW
delay(10000); // esperamos 10 segundos
}

Y aquí podéis ver el resultado y la explicación del propio alumno, esperamos que os guste 🙂

5.Lectura de señales analógicas -Tutorial Arduino

¿Qué es una señal Analógica?


En la mayoría de los sistemas automatizados, utilizamos sensores para supervisor el mundo exterior. Estos sensores nos entregan una señal analógica. Como ejemplo mas practico podemos citar  el caso de los sensores de:

  • Temperatura 
  • Distancia
  • Presión
  • PH
  • Intensidad de corriente en un circuito
  • Caudal de agua en una tubería
  • Velocidad de un coche
  • % de Humedad

Para leer este tipo de señales continuas, necesitamos un convertidor analógico a digital (o ADC por sus siglas en ingles) y que nos permite leer el valor de una señal analógica en un momento dado.
Estos convertidores toman una muestra del valor actual de la señal y nos entregan su valor instantáneo, medido en Voltios.
Mediante la lectura repetida de muestras a lo largo del tiempo podemos reconstruir la señal original con mayor o menor precisión, dependiendo de la exactitud de nuestra medida y de la velocidad a la que pueda tomar esas muestras.

¿Cómo usar el Arduino UNO para leer señales Analógicas?

Arduino UNO dispone de seis convertidores analógico a digital, nominados de A0 hasta A5, rotuladas como ANALOG IN:

Los convertidores de Arduino UNO y Mega son de 10 bits de resolución por lo que nos devolverá valores entre 0 y 210 = 1.024 para tensiones entre 0 y 5V.

Asegúrate de no usar sensores que puedan dar más de 5V máximo (con Arduino UNO y Mega), ya que dañarías el chip principal de Arduino.

Para usar las entradas analógicas, utilizaremos un potenciómetro en vez de un sensor, el cual conectaremos como se indica el siguiente circuito. Aplicaremos tensión de 5 Vdc a los extremos del potenciómetro y conectamos el pin central (cursor o variable) a la entrada del puerto A5 del Arduino.

Escribimos el siguiente programa:

Observación:

No necesitamos declarar en el setup() que vamos a usar una puerta analógica. Y la segunda es que para tomar una muestra (leer) del pin A5, usaremos la instrucción:

int sensorValue = analogRead(A5);

Luego de descargar el programa sobre la placa, arrancamos la consola serial y veras que a medida que giras el cursor del potenciómetro, las lecturas varían de forma continua reflejando la posición del potenciómetro, las lecturas reflejan la caída en voltios sobre la resistencia del potenciómetro. Con esto hemos logrado leer el valor de una señal analógica.

Proudly powered by WordPress | Theme: HoneyBee by SpiceThemes