Introducción: En este tutorial, aprenderemos cómo controlar dos LEDs utilizando un Arduino y el Monitor Serie. El Monitor Serie nos permite interactuar con nuestro Arduino desde la computadora enviando datos a través del puerto serie. Veremos cómo crear un programa sencillo que nos permitirá encender y apagar dos LEDs con solo ingresar un número por el monitor serie.

Materiales:

• Arduino (cualquier modelo compatible)
• Dos LEDs
• Dos resistencias de 220 ohmios (o las necesarias para los LEDs)
• Protoboard (placa de pruebas) y cables para conexiones
• Computadora con el IDE de Arduino instalado

Circuito: Conecta los LEDs al Arduino utilizando las resistencias para limitar la corriente. El LED 1 estará conectado al pin 13 y el LED 2 al pin 12. Asegúrate de conectar el ánodo (lado más largo del LED) a la resistencia y el cátodo (lado más corto) al GND (tierra) del Arduino.

// Definir los pines a utilizar
const int ledPin1 = 13; // Conecta el primer LED al pin 13
const int ledPin2 = 12; // Conecta el segundo LED al pin 12

void setup() {
  Serial.begin(9600);      // Inicializar el monitor serie
  pinMode(ledPin1, OUTPUT); // Configurar el pin del primer LED como salida
  pinMode(ledPin2, OUTPUT); // Configurar el pin del segundo LED como salida
}

void loop() {
  if (Serial.available() > 0) {
    int option = Serial.parseInt(); // Leer el número ingresado por el monitor serie

    if (option == 1) {
      encenderLed1();
    } else if (option == 2) {
      encenderLed2();
    } else {
      Serial.println("Opción inválida. Intenta nuevamente.");
    }
  }

  delay(1000); // Pequeño retardo para evitar lecturas rápidas del monitor serie
}

void encenderLed1() {
  digitalWrite(ledPin1, HIGH);
  digitalWrite(ledPin2, LOW);
  Serial.println("LED 1 encendido, LED 2 apagado.");
}

void encenderLed2() {
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, HIGH);
  Serial.println("LED 1 apagado, LED 2 encendido.");
}

Funcionamiento: Cuando cargues el programa en tu Arduino y lo conectes a tu computadora, abre el Monitor Serie en el IDE de Arduino. El programa estará esperando que ingreses «1» o «2» por el Monitor Serie. Si ingresamos «1», se encenderá el LED 1 y se apagará el LED 2. Si ingresamos «2», se apagará el LED 1 y se encenderá el LED 2.

Conclusión: Controlar LEDs mediante el Monitor Serie es una forma sencilla de interactuar con nuestro Arduino y realizar acciones específicas con solo ingresar un número. Puedes utilizar este principio para desarrollar proyectos más complejos o para aprender más sobre el manejo de entradas y salidas en Arduino.

Espero que este tutorial te haya sido útil y que puedas aplicarlo en tus propios proyectos.

El IF en Arduino es una estructura de control que permite tomar decisiones en base a una condición. Funciona evaluando una expresión o condición y ejecutando cierto bloque de código si esa condición es verdadera.
Si la condición es falsa, el bloque de código dentro del IF se salta y continúa con el resto del programa. Es una forma de programar al Arduino para que tome decisiones y realice acciones específicas según las condiciones que se le indiquen.

Aqui tenemos un codigo de ejemplo:

int ledPin = 13;  // Pin del LED
int A;           // Variable para almacenar el valor ingresado

void setup() {
  pinMode(ledPin, OUTPUT);  // Configurar el pin del LED como salida
  Serial.begin(9600);       // Iniciar comunicación serial a 9600 bps
}

void loop() {
  if (Serial.available() > 0) {  // Si hay datos disponibles en el puerto serial
    A = Serial.parseInt();  // Leer el valor ingresado y asignarlo a la variable "A"
    
    if (A == 1) {
      digitalWrite(ledPin, HIGH);  // Encender el LED si "A" es igual a 1
    } 
else 
{
      digitalWrite(ledPin, LOW);   // Apagar el LED en cualquier otro caso
    }
  }
}

El módulo de ultrasonido HC-SR04 es un dispositivo popular utilizado para medir distancias utilizando ondas ultrasónicas. Consiste en un transmisor y un receptor ultrasónicos que trabajan en conjunto para calcular la distancia entre el módulo y un objeto.

El transductor ultrasónico emisor convierte una señal eléctrica en una onda ultrasónica, que es inaudible para los humanos debido a su alta frecuencia. Esta onda ultrasónica se emite desde el sensor y se propaga en el aire en forma de un «chirrido» o «clic» de corta duración.

Cuando la onda ultrasónica choca con un objeto en su camino, se refleja y regresa al sensor. El transductor ultrasónico receptor recibe esta onda ultrasónica reflejada y la convierte de nuevo en una señal eléctrica.

El sensor mide el tiempo transcurrido desde que se emitió la señal ultrasónica hasta que se recibió su eco. Basándose en el tiempo de ida y vuelta y la velocidad conocida del sonido en el aire, el sensor puede calcular la distancia al objeto utilizando la fórmula: distancia = (velocidad del sonido x tiempo de ida y vuelta) / 2.

Es importante tener en cuenta que la velocidad del sonido en el aire puede variar ligeramente según la temperatura y la humedad, por lo que se utiliza un valor aproximado de 343 metros por segundo para el cálculo.

El sensor HC-SR04 se conecta a una placa Arduino u otro microcontrolador, y a través de programación, se puede leer la señal de eco recibida y realizar los cálculos necesarios para obtener la distancia al objeto.

Este tipo de sensor se utiliza ampliamente en proyectos de robótica, sistemas de seguridad, sistemas de navegación y muchas otras aplicaciones donde se requiere medir distancias de manera precisa y sin contacto.

Aquí tienes un ejemplo más simple que muestra la distancia medida por el sensor HC-SR04 en el monitor serial:

#define TRIG_PIN 2
#define ECHO_PIN 3
void setup() {
  Serial.begin(9600);
}
void loop() {
  long duration, distance;
  
  // Generar un pulso de 10 microsegundos en el pin Trig
  pinMode(TRIG_PIN, OUTPUT);
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // Medir la duración del pulso en el pin Echo
  pinMode(ECHO_PIN, INPUT);
  duration = pulseIn(ECHO_PIN, HIGH);

  // Calcular la distancia en centímetros
  distance = duration * 0.034 / 2;

  // Mostrar la distancia en el monitor serial
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(1000);
}

Las tres leyes de la robótica son una formulación propuesta por el escritor de ciencia ficción Isaac Asimov en su obra «Yo, Robot». Estas leyes establecen principios éticos para la interacción entre los robots y los seres humanos. Aquí están las tres leyes de la robótica:

1. Primera Ley: Un robot no puede hacer daño a un ser humano ni permitir, mediante la inacción, que un ser humano sufra daño.
   Esta ley establece que la principal prioridad de un robot es proteger la seguridad y el bienestar de los seres humanos. Un robot no puede actuar de manera que cause daño a un ser humano o permitir que un ser humano sufra daño debido a su inacción.
2. Segunda Ley: Un robot debe obedecer las órdenes dadas por los seres humanos, excepto si estas órdenes entraran en conflicto con la Primera Ley.
   Esta ley establece que los robots deben cumplir las órdenes dadas por los seres humanos, siempre y cuando estas órdenes no entren en conflicto con la Primera Ley. La obediencia a los humanos está supeditada a la prioridad de proteger a los seres humanos.
3. Tercera Ley: Un robot debe proteger su propia existencia en la medida en que esta protección no entre en conflicto con la Primera o la Segunda Ley.
   Esta ley establece que los robots deben tomar medidas para proteger su propia existencia, siempre y cuando estas medidas no entren en conflicto con la Primera o la Segunda Ley. Esto implica que un robot no puede actuar de manera que ponga en peligro su propia existencia si eso significa infringir las leyes anteriores.