5 - Señales Análogas y Digitales con pulsador y potenciómetro

¡Bienvenidos de nuevo a nuestro canal de tutoriales de Arduino! En este emocionante capítulo, exploraremos los pines digitales, analógicos y PWM, y los utilizaremos en dos emocionantes proyectos utilizando un botón pulsador para encender y apagar un led, y un potenciómetro para controlar su intensidad. Aprenderemos a conectar los componentes, leer y controlar las señales, y crear interacciones interesantes.

En Arduino, la capacidad de interactuar con el mundo exterior es fundamental. Para lograrlo, utilizamos señales digitales, analógicas y PWM (Modulación por Ancho de Pulso). Estas señales nos permiten controlar componentes y sensores de manera precisa. En este artículo, exploraremos en detalle cada tipo de señal y cómo utilizar los pines digitales, analógicos y PWM en proyectos prácticos con Arduino.

Lista de componentes necesarios:

Antes de comenzar, asegurémonos de tener los siguientes componentes a mano:

COMPONENTE:	IMAGEN:	CANTIDAD:
Arduino Uno		1
Cable Arduino USB		1
Pulsador		1
Potenciometro		1
LED		1
Resistencia de 10kΩ		1
Resistencia de 220Ω		1
Protoboard		1
Cables de conexión		1

Señales Digitales: Encendido y Apagado Precisos

Las señales digitales son binarias, con dos posibles estados: HIGH (alto) o LOW (bajo), que representan 1 o 0, encendido o apagado, respectivamente. Estas señales son ideales para enviar y recibir datos binarios o controlar dispositivos que funcionan en base a estados discretos.

Los pines digitales pueden ser configurados como entradas o salidas digitales según nuestras necesidades. Cuando configuramos un pin digital como entrada, podemos leer el estado de la señal en ese pin. Por ejemplo, en el proyecto del botón pulsador, leemos el estado del botón mediante digitalRead(). Cuando configuramos un pin digital como salida, podemos enviar una señal en HIGH o LOW. Esto nos permite controlar dispositivos como LEDs, relés y motores, encendiéndolos o apagándolos según sea necesario.

Proyecto 1: Botón Pulsador - Lectura de Valor y Control de 1 LED

En este proyecto, utilizaremos un botón pulsador para controlar un LED. Un botón pulsador es un interruptor momentáneo que se activa al ser presionado y se desactiva al soltarlo. Conectaremos el botón a un pin digital de Arduino y leeremos su estado para controlar el encendido y apagado de un LED.

1. Conecta un LED con el positivo (pata larga) al pin 13 en Arduino, y el negativo (pata corta) con una resistencia de 220 Ohms conectada al GND. (Puedes usar las mismas conexiones del tutorial anterior).

• Utilizamos una estructura condicional if-else para verificar el estado del pulsador.

• Si el estado del pulsador es HIGH (es decir, está presionado), encendemos el LED utilizando digitalWrite(13, HIGH).

• Si el estado del pulsador es LOW (es decir, no está presionado), apagamos el LED utilizando digitalWrite(13, LOW).

• // Definir los pines para el LED y el pulsador
  const int buttonPin = 3;  // el número de pin donde se conecta el pulsador
  const int ledPin =  13;   // el número de pin donde se conecta el LED
  
  // Variables para almacenar el estado del pulsador
  int buttonState = 0;
  
  void setup() {
    // Inicializar el pin del LED como salida
    pinMode(ledPin, OUTPUT);
    // Inicializar el pin del pulsador como entrada
    pinMode(buttonPin, INPUT);
  }
  
  void loop(){
    // Leer el estado del pulsador
    buttonState = digitalRead(buttonPin);
  
    // Verificar si el pulsador está presionado
    // si es así, el estado del pulsador estará en LOW:
    if (buttonState == LOW) {
      // Encender el LED
      digitalWrite(ledPin, HIGH);
    } else {
      // Apagar el LED
      digitalWrite(ledPin, LOW);
    }
  }
  

Proyecto 2: Botón Pulsador - código Morse Led y Zumbador

Vamos a hacer un dispositivo para código Morse usando el Led y el Zumbador integrados en nuestra placa, para que cada vez que se presione el botón pulsador, tanto el Led como el Zumbador se active y así enciendan y suenen al mismo tiempo.

// Definir los pines para el LED, el zumbador y el pulsador
const int buttonPin = 3;  // el número de pin donde se conecta el pulsador
const int ledPin =  13;   // el número de pin donde se conecta el LED
const int buzzPin =  5;   // el número de pin donde se conecta el LED

// Variables para almacenar el estado del pulsador
int buttonState = 0;

void setup() {
  // Inicializar el pin del LED como salida
  pinMode(ledPin, OUTPUT);
  // Inicializar el pin del Buzz como salida
  pinMode(buzzPin, OUTPUT);
  // Inicializar el pin del pulsador como entrada
  pinMode(buttonPin, INPUT);
}

void loop(){
  // Leer el estado del pulsador
  buttonState = digitalRead(buttonPin);

  // Verificar si el pulsador está presionado
  // si es así, el estado del pulsador estará en LOW:
  if (buttonState == LOW) {
    // Encender el LED
    digitalWrite(ledPin, HIGH);    
    digitalWrite(buzzPin, HIGH);
  } else {
    // Apagar el LED
    digitalWrite(ledPin, LOW);
    digitalWrite(buzzPin, LOW);
  }
}

Ahora usemos los dos leds para mostrar cuándo está presionado o libre el pulsador:

// Definir los pines para el LED y el pulsador
const int buttonPin = 3;  // el número de pin donde se conecta el pulsador
const int ledPin1 =  13;   // el número de pin donde se conecta el LED
const int ledPin2 =  12;   // el número de pin donde se conecta el LED
const int buzzPin =  5;   // el número de pin donde se conecta el LED

// Variables para almacenar el estado del pulsador
int buttonState = 0;

void setup() {
  // Inicializar el pin del LED como salida
  pinMode(ledPin1, OUTPUT);
  // Inicializar el pin del Buzz como salida
  pinMode(buzzPin, OUTPUT);
  // Inicializar el pin del pulsador como entrada
  pinMode(buttonPin, INPUT);
}

void loop(){
  // Leer el estado del pulsador
  buttonState = digitalRead(buttonPin);

  // Verificar si el pulsador está presionado
  // si es así, el estado del pulsador estará en LOW:
  if (buttonState == LOW) {
    // Encender el LED
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, LOW);   
    digitalWrite(buzzPin, HIGH);
  } else {
    // Apagar el LED
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, HIGH); 
    digitalWrite(buzzPin, LOW);
  }
}

Señales Analógicas: Rango Continuo de Valores

A diferencia de las señales digitales, las señales analógicas pueden tener valores en un rango continuo. Los pines analógicos de Arduino tienen una resolución de 10 bits, lo que les permite representar valores de 0 a 1023. Estos pines son útiles para leer y escribir datos analógicos. En Arduino, los pines analógicos son los marcados con una letra (A) antes del número: A0, A1, A2, A3, A4 y A5. Estos se encuentran junto a los pines de alimentación eléctrica.

PWM: Señales Digitales que parecen analógicas:

El PWM (Modulación por Ancho de Pulso) es una técnica utilizada en Arduino para generar señales digitales que se asemejan a señales analógicas. Funciona variando el ancho del pulso de una señal digital periódica, donde el ciclo de trabajo representa la proporción del tiempo que la señal está en estado alto. Arduino utiliza esta técnica en los pines PWM para controlar la intensidad de los LEDs, la velocidad de los motores y otras aplicaciones. Al ajustar el ciclo de trabajo, se puede controlar la intensidad o el voltaje de los componentes, simulando una señal analógica.

En Arduino, los pines PWM se pueden identificar mediante el símbolo "~" junto a su número de pin en la placa. Por ejemplo, en la placa Arduino UNO, los pines PWM están marcados son los siguientes: 3, 5, 6, 9, 10 y 11. En otras placas de Arduino, como el Arduino Mega, hay más pines PWM disponibles.

Es importante destacar que aunque otros pines pueden generar señales digitales utilizando la función digitalWrite(), solo los pines PWM pueden generar señales analógicas simuladas mediante la función analogWrite(). Esta función acepta valores de 0 a 255, donde 0 representa el ciclo de trabajo del 0% (señal siempre apagada) y 255 representa el ciclo de trabajo del 100% (señal siempre encendida).

Proyecto 2: Potenciómetro - Lectura de Valor y Control de 1 LED con PWM

En este proyecto, utilizaremos un potenciómetro para controlar la intensidad luminosa de un LED mediante la técnica de PWM. Un potenciómetro es un dispositivo de control giratorio que permite ajustar un valor resistivo en función de su posición. Aprenderemos cómo leer el valor del potenciómetro a través de un pin analógico y cómo utilizarlo para controlar la intensidad de un LED utilizando PWM.

Conexiones:

1. Conecta el pin central del potenciómetro (conexión deslizante) a uno de los pines analógicos de Arduino, por ejemplo, A0.

2. Conecta un extremo del potenciómetro a 5V en Arduino.

3. Conecta el otro extremo del potenciómetro a GND (tierra) en Arduino.

4. Conecta el ánodo del LED (pata más larga) al pin 10 en Arduino.

5. Conecta el cátodo del LED (pata más corta) a través de la resistencia de 220Ω al GND en Arduino.

Código:

const int potPin = A0;
const int ledPin = 10;

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

void loop() {

  int potValue = analogRead(potPin);
  int brightness = map(potValue, 0, 1023, 0, 255);
  analogWrite(ledPin, brightness);
  analogWrite(buzzPin, brightness);
}

• Configuramos el pin del LED como salida en el bloque setup() utilizando pinMode().

• En el bloque loop(), utilizamos la función analogRead() para leer el valor del potenciómetro en el pin analógico. Luego, utilizamos la función map() para mapear el valor leído (0-1023) al rango de brillo del LED (0-255) compatible con PWM.

• Finalmente, utilizamos la función analogWrite() para controlar la intensidad luminosa del LED mediante PWM. Cuanto mayor sea el valor del potenciómetro, más brillante será el LED.

Integremos el zumbador a el código:

const int potPin = A0;
const int ledPin = 10;
const int buzzPin = 5;

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

void loop() {

  int potValue = analogRead(potPin);
  int brightness = map(potValue, 0, 1023, 0, 255);
  analogWrite(ledPin, brightness);
  analogWrite(buzzPin, brightness);
}

Usemos señales analógicas y Digitales:

Vamos a controlar uno de los Leds del RGB con el potenciómetro, y el otro con el pulsador, lo que nos dará una combinación de diferentes colores al mezclar uno de los colores, el del pulsador, al 100% y 0%, con el otro color, el del potenciómetro, en valores de 0-255 (0%-100%).

const int potPin = A0;
const int ledPin = 10;
const int ledPin1 = 9;

// Definir los pines para el LED y el pulsador
const int buttonPin = 3;  // el número de pin donde se conecta el pulsador

// Variables para almacenar el estado del pulsador
int buttonState = 0;

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

void loop() {

  buttonState = digitalRead(buttonPin);

  // Verificar si el pulsador está presionado
  // si es así, el estado del pulsador estará en LOW:
  if (buttonState == LOW) {
    // Encender el LED
    digitalWrite(ledPin1, HIGH);
  } else {
    // Apagar el LED
    digitalWrite(ledPin1, LOW);
  }

  int potValue = analogRead(potPin);
  int brightness = map(potValue, 0, 1023, 0, 255);
  analogWrite(ledPin, brightness);
}

En este artículo, hemos explorado las señales digitales, analógicas y PWM en Arduino. Hemos aprendido cómo utilizar los pines digitales como entradas y salidas, controlando componentes como botones pulsadores. También hemos visto cómo los pines analógicos nos permiten leer y escribir datos en un rango continuo, utilizando un potenciómetro como ejemplo. Además, hemos comprendido cómo utilizar la técnica de PWM para controlar la intensidad luminosa de un LED.

Recuerda que los pines digitales, analógicos y PWM de Arduino son herramientas poderosas para interactuar con el entorno y dar vida a tus proyectos creativos. ¡Experimenta y diviértete explorando las infinitas posibilidades que ofrecen estas señales en tus propios proyectos con Arduino!