copilot

• Arduino Uno R3 Shield Template: The project sets up a base for designing shields compatible with the Arduino Uno R3, ensuring the correct pin layout and functionalities.
• Official Pinout Inclusion: The design includes the standard pinout for the Arduino Uno R3, which indicates the names and alternative roles of each pin, such as SDA (Serial Data Line), SCL (Serial Clock Line), etc.

• J2, J3, J4, J1: These are connectors typically used to interface with the Arduino pins. The exact nature of these connectors can vary based on how they are configured in your design.
• RESET: This is a net designated for the reset function of the microcontroller, allowing you to link any reset-related components or pins.
• VIN, +3V3, +5V: These are power nets for voltage supplies. VIN is typically used for the input voltage, while +3V3 and +5V provide power to corresponding Arduino voltage pins.
• Arduino Uno R3 PINOUT: Acts as a reference for the standard pin mapping of the Arduino Uno R3, which helps to keep track of where each function is enabled on the shield.
• Outline: This defines the silkscreen outline of the Arduino Uno R3 board to guide layout design and component placement.

• Net connecting J2 Pin 5 to +5V Pin 1: Carries the 5V power supply to J2.
• Ground (GND): Interconnects ground pins on the board.
• Net connecting J2 Pin 4 to +3V3 Pin 1: Used for supplying 3.3V power.
• Net for VIN Pin 1: Represents the input voltage connection point.
• Net connecting J2 Pin 3 to RESET Pin 1: Links the reset line.

gadiell

copilot

• Arduino Uno: La placa microcontroladora que actuará como el cerebro del proyecto.
• Sensor de Velocidad (Ej: Sensor de Efecto Hall o LIDAR):
  • Sensor de Efecto Hall: Detecta el campo magnético de un imán adjunto al objeto en movimiento.
  • LIDAR: Utiliza tecnología láser para medir distancias y, con ello, calcular velocidad.
  • Sensor de Ultrasonido (como el HC-SR04): Mide la distancia por ultrasonido y calcula la velocidad basado en cambios en la distancia en el tiempo.

• Pantalla LCD o LED: Para mostrar la velocidad calculada. Puede ser un LCD 16x2 con I2C para una conexión más sencilla.
• Batería o Fuente de Alimentación: Suministra energía a todo el sistema.
• Resistencias y Capacitores: Según sea necesario para el circuito.
• Protoboard y Cables de Conexión: Para armar el circuito de manera provisional y hacer conexiones entre componentes fácilmente.

• PC con Software Arduino IDE: Para programar el Arduino Uno.

• Módulo de Bluetooth/Wi-Fi (Ej: HC-05 para Bluetooth): Para enviar datos a un dispositivo móvil o computadora sin cables.
• Sensores Adicionales: Dependiendo del enfoque, a veces puede ser útil combinar múltiples sensores (ejemplo: acelerómetros).

1. Conectar el Sensor: Conectar el sensor seleccionado al Arduino Uno. Para un sensor como el HC-SR04, usarás pines digitales por ejemplo.
2. Programar el Arduino: Escribir un código que envíe señales al sensor para medir distancia (en el caso de un ultrasonido) o que lea el efecto Hall.
3. Calcular la Velocidad: Implementar la fórmula de velocidad $v = \frac{\Delta d}{\Delta t}$, donde $\Delta d$ es el cambio en distancia y $\Delta t$ es el cambio en tiempo.
4. Mostrar los Datos: Mandar la velocidad calculada a través de la pantalla LCD.

gadiell

copilot

• Arduino Uno
• Sensor ultrasonido HC-SR04 o Sensor ToF VL53L0X
• Pantalla LCD 16x2 con I2C (para mostrar la velocidad)
• Cables de conexión
• Resistencias (si es necesario para el circuito)
• Protoboard (opcional, para conexiones temporales)
• Fuente de alimentación (por ejemplo, una batería de 9V con adaptador para el Arduino)

• Conectar VCC del sensor a +5V en el Arduino.
• Conectar GND del sensor a GND en el Arduino.
• Conectar Echo a un pin digital, por ejemplo pin 8.
• Conectar Trig a otro pin digital, por ejemplo pin 9.

• Si usas un módulo con I2C: conectar VCC, GND, SDA, SCL al Arduino. SDA va al pin A4 y SCL al pin A5.

Cpp
#include 

const int trigPin = 9;
const int echoPin = 8;

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  lcd.begin();
  lcd.backlight();
}

void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  duration = pulseIn(echoPin, HIGH);
  distance = (duration * 0.034) / 2; // Convertir a distancia

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Distancia: ");
  lcd.print(distance);
  lcd.print(" cm");

  // Calculo de velocidad basado en distancia previa
  // A completar con la lógica para actualización de velocidad
  
  delay(1000); // Esperar 1 segundo antes de la siguiente lectura
}

• $v = \frac{\Delta d}{\Delta t}$

gadiell

copilot

• Arduino Uno
• Sensor Infrarrojo: Puedes usar dos sensores (uno para entrada y otro para salida) si quieres medir la velocidad a través de todo un tramo.
• Protoboard y cables de conexión
• Fuente de alimentación para el Arduino: Puede ser alimentado vía USB desde una PC.

1. Colocación de Sensores:
   • Coloca un sensor infrarrojo al inicio del riel (entrada) y otro al final (salida) del tramo donde deseas medir la velocidad.
2. Conexiones:
   • Conectar el pin de señal de cada sensor a un pin digital del Arduino (por ejemplo, entrada en pin 2 y salida en pin 3).
   • Conectar los pines de alimentación (VCC) de los sensores al pin +5V del Arduino.
   • Conectar los pines GND de los sensores al GND del Arduino.

Cpp
const int sensorEntrada = 2; // Pin del sensor de entrada
const int sensorSalida = 3;  // Pin del sensor de salida

unsigned long tiempoInicial = 0;
unsigned long tiempoFinal = 0;
const float distancia = 0.5; // Distancia entre sensores en metros

void setup() {
  pinMode(sensorEntrada, INPUT);
  pinMode(sensorSalida, INPUT);
  Serial.begin(9600);
}

void loop() {
  // Detección en sensor de entrada
  if (digitalRead(sensorEntrada) == LOW) { 
    tiempoInicial = millis();
    Serial.println("Canica detectada en entrada");
    delay(100); // Pequeña espera para evitar lecturas múltiples
  }

  // Detección en sensor de salida
  if (digitalRead(sensorSalida) == LOW) {
    tiempoFinal = millis();
    Serial.println("Canica detectada en salida");

    // Calcular tiempo transcurrido
    unsigned long tiempoTranscurrido = tiempoFinal - tiempoInicial; // Tiempo en milisegundos
    float tiempoSegundos = tiempoTranscurrido / 1000.0; // Convertir a segundos

    // Calcular velocidad
    float velocidad = distancia / tiempoSegundos; // Velocidad en metros por segundo
    Serial.print("Velocidad: ");
    Serial.print(velocidad);
    Serial.println(" m/s");

    delay(100); // Pequeña espera para evitar lecturas múltiples
  }
}

• Ajusta la Distancia: Asegúrate de actualizar la variable distancia con la medida exacta entre los sensores.
• Tiempos de Pulso: Dependiendo del comportamiento de los sensores infrarrojos, puede que necesites ajustar las condiciones de detección (LOW vs. HIGH).

gadiell

copilot

• Pantalla LCD 16x2 con módulo I2C

1. VCC: Conecta al pin +5V del Arduino.
2. GND: Conecta al pin GND del Arduino.
3. SDA: Conecta al pin A4 del Arduino.
4. SCL: Conecta al pin A5 del Arduino.

Cpp
#include 
#include 

const int sensorEntrada = 2; // Pin del sensor de entrada
const int sensorSalida = 3;  // Pin del sensor de salida

unsigned long tiempoInicial = 0;
unsigned long tiempoFinal = 0;
const float distancia = 0.5; // Distancia entre sensores en metros

LiquidCrystal_I2C lcd(0x27, 16, 2); // Direccion I2C. Asegúrate de que sea 0x27 para tu pantalla.

void setup() {
  pinMode(sensorEntrada, INPUT);
  pinMode(sensorSalida, INPUT);
  Serial.begin(9600);

  lcd.begin(16, 2);
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Velocidad:");
}

void loop() {
  // Detección en sensor de entrada
  if (digitalRead(sensorEntrada) == LOW) { 
    tiempoInicial = millis();
    Serial.println("Canica detectada en entrada");
    delay(100); // Pequeña espera para evitar lecturas múltiples
  }

  // Detección en sensor de salida
  if (digitalRead(sensorSalida) == LOW) {
    tiempoFinal = millis();
    Serial.println("Canica detectada en salida");

    // Calcular tiempo transcurrido
    unsigned long tiempoTranscurrido = tiempoFinal - tiempoInicial; // Tiempo en milisegundos
    float tiempoSegundos = tiempoTranscurrido / 1000.0; // Convertir a segundos

    // Calcular velocidad
    float velocidad = distancia / tiempoSegundos; // Velocidad en metros por segundo
    Serial.print("Velocidad: ");
    Serial.print(velocidad);
    Serial.println(" m/s");

    // Mostrar velocidad en la pantalla LCD
    lcd.setCursor(0, 1); // segunda línea
    lcd.print("  ");
    lcd.setCursor(0, 1); // segunda línea
    lcd.print(velocidad);
    lcd.print(" m/s  ");

    delay(100); // Pequeña espera para evitar lecturas múltiples
  }
}

• Dirección I2C de la Pantalla: La dirección 0x27 es común, pero si no funciona, puedes escanear el bus I2C con un escáner de I2C para confirmar.
• Inicialización de la Pantalla: Asegúrate de inicializar la pantalla con lcd.begin() seguido de lcd.backlight() para asegurarte de que esté visible.

gadiell

copilot

• Pantalla LCD 16x2

1. VSS: Conecta al pin GND del Arduino.
2. VDD: Conecta al pin +5V del Arduino.
3. V0: Conecta al terminal central de un potenciómetro para control de contraste, los otros terminales del potenciómetro van a +5V y GND.
4. RS: Conecta al pin digital 7 del Arduino.
5. RW: Conecta al pin GND del Arduino (modo escritura).
6. E (Enable): Conecta al pin digital 8 del Arduino.
7. D4-D7: Conecta a los pines digitales 9, 10, 11, 12 respectivamente.
8. A (Anodo de luz de fondo): Conecta al pin +5V del Arduino.
9. K (Cátodo de luz de fondo): Conecta al pin GND del Arduino.

Cpp
#include 

const int sensorEntrada = 2; // Pin del sensor de entrada
const int sensorSalida = 3;  // Pin del sensor de salida

unsigned long tiempoInicial = 0;
unsigned long tiempoFinal = 0;
const float distancia = 0.5; // Distancia entre sensores en metros

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

void setup() {
  pinMode(sensorEntrada, INPUT);
  pinMode(sensorSalida, INPUT);
  Serial.begin(9600);

  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Velocidad:");
}

void loop() {
  // Detección en sensor de entrada
  if (digitalRead(sensorEntrada) == LOW) { 
    tiempoInicial = millis();
    Serial.println("Canica detectada en entrada");
    delay(100); // Pequeña espera para evitar lecturas múltiples
  }

  // Detección en sensor de salida
  if (digitalRead(sensorSalida) == LOW) {
    tiempoFinal = millis();
    Serial.println("Canica detectada en salida");

    // Calcular tiempo transcurrido
    unsigned long tiempoTranscurrido = tiempoFinal - tiempoInicial; // Tiempo en milisegundos
    float tiempoSegundos = tiempoTranscurrido / 1000.0; // Convertir a segundos

    // Calcular velocidad
    float velocidad = distancia / tiempoSegundos; // Velocidad en metros por segundo
    Serial.print("Velocidad: ");
    Serial.print(velocidad);
    Serial.println(" m/s");

    // Mostrar velocidad en la pantalla LCD
    lcd.setCursor(0, 1); // segunda línea
    lcd.print("         "); // Limpiar la línea antes de imprimir nueva velocidad
    lcd.setCursor(0, 1); // segunda línea
    lcd.print(velocidad);
    lcd.print(" m/s");

    delay(100); // Pequeña espera para evitar lecturas múltiples
  }
}

• Potenciómetro: Ajusta el potenciómetro para que el contraste de la pantalla sea adecuado y puedas leer claramente los caracteres.
• Código Limpio: Asegúrate de limpiar la segunda línea del LCD antes de escribir nueva información para evitar residuos gráficos de lecturas anteriores.

gadiell

copilot

gadiell

copilot

• Arduino Uno
• Sensor Infrarrojo de Dos Patas: Uno para detectar la entrada y otro para la salida de la canica.
• Pantalla LCD 16x2 con I2C
• Protoboard y cables de conexión

• Sensor de Entrada:
  • Conectar un pin (generalmente el negativo) a GND.
  • Conectar el otro pin al pin digital 2 del Arduino.
• Sensor de Salida:
  • Conectar un pin a GND.
  • Conectar el otro pin al pin digital 3 del Arduino.

• VCC: Conecta al pin +5V del Arduino.
• GND: Conecta al pin GND del Arduino.
• SDA: Conecta al pin A4 del Arduino.
• SCL: Conecta al pin A5 del Arduino.

Cpp
#include 
#include 

const int sensorEntrada = 2; // Pin del sensor de entrada
const int sensorSalida = 3;  // Pin del sensor de salida

unsigned long tiempoInicial = 0;
unsigned long tiempoFinal = 0;
const float distancia = 0.5; // Distancia entre sensores en metros (ajusta esto según tu setup)

LiquidCrystal_I2C lcd(0x27, 16, 2); // Cambia 0x27 si tu dirección I2C es diferente

void setup() {
  pinMode(sensorEntrada, INPUT);
  pinMode(sensorSalida, INPUT);
  Serial.begin(9600);

  lcd.begin(16, 2);
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Velocidad:");
}

void loop() {
  // Detección en sensor de entrada
  if (digitalRead(sensorEntrada) == LOW) { 
    tiempoInicial = millis();
    Serial.println("Canica entrada");
    delay(50); // Pequeña espera para evitar lecturas múltiples
  }

  // Detección en sensor de salida
  if (digitalRead(sensorSalida) == LOW) {
    tiempoFinal = millis();
    Serial.println("Canica salida");

    // Calcular tiempo transcurrido
    unsigned long tiempoTranscurrido = tiempoFinal - tiempoInicial; // Tiempo en milisegundos
    float tiempoSegundos = tiempoTranscurrido / 1000.0; // Convertir a segundos

    // Calcular velocidad
    float velocidad = distancia / tiempoSegundos; // Velocidad en metros por segundo
    Serial.print("Velocidad: ");
    Serial.print(velocidad);
    Serial.println(" m/s");

    // Mostrar velocidad en la pantalla LCD
    lcd.setCursor(0, 1); // Segunda línea
    lcd.print("        "); // Limpiar la línea
    lcd.setCursor(0, 1);
    lcd.print(velocidad);
    lcd.print(" m/s");

    delay(50); // Otra pequeña espera
  }
}

• Dirección I2C: La dirección 0x27 es común para muchos módulos LCD I2C. Si no funciona, usa un programa de escaneo I2C para encontrar la dirección correcta.
• Ajusta la Distancia: Asegúrate de ajustar la variable distancia con la separación real entre los sensores.

gadiell

copilot

1. Abrir el Administrador de Librerías en Arduino IDE:
   • Ve a "Sketch" > "Incluir Librería" > "Administrar Bibliotecas...".
2. Buscar la Librería:
   • En el buscador del Administrador de Librerías, escribe LiquidCrystal I2C.
3. Seleccionar e Instalar:
   • Busca una librería que se llame LiquidCrystal I2C de un autor de confianza, como Frank de Brabander.
   • Haz clic en "Instalar". Espera a que la instalación se complete.
4. Incluir la Librería en tu Código:
   • Asegúrate de que tu código haya importado la librería correctamente con #include .

• Arduino IDE Actualizado: Asegúrate de estar usando una versión reciente del Arduino IDE.
• Reiniciar el IDE: A veces, reiniciar el IDE después de instalar una librería puede resolver problemas.

gadiell

copilot

1. Dirección I2C: Asegúrate de que la dirección I2C definida en el código coincide con la dirección real de tu LCD. Usa un programa de escaneo I2C para detectar la dirección de tu pantalla. Puedes encontrar un escáner I2C en internet que te ayudará a determinar la dirección correcta.
2. Conexiones Correctas:
   • VCC de la pantalla debe ir al +5V del Arduino.
   • GND de la pantalla debe ir al GND del Arduino.
   • SDA debe estar conectado al A4 del Arduino.
   • SCL debe estar conectado al A5 del Arduino.
3. Código Verificado: Asegúrate de que estás usando correctamente las funciones de la librería en tu código. Veamos una vez más el código con atención particular a la inicialización y uso del LCD:

Cpp
#include 
#include 

const int sensorEntrada = 2; // Pin del sensor de entrada
const int sensorSalida = 3;  // Pin del sensor de salida

unsigned long tiempoInicial = 0;
unsigned long tiempoFinal = 0;
const float distancia = 0.5; // Distancia entre sensores en metros (ajusta esto según tu setup)

LiquidCrystal_I2C lcd(0x27, 16, 2); // Cambia 0x27 si tu dirección I2C es diferente

void setup() {
  pinMode(sensorEntrada, INPUT);
  pinMode(sensorSalida, INPUT);
  Serial.begin(9600);

  lcd.begin(16, 2);
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Velocidad:");
}

void loop() {
  // Detección en sensor de entrada
  if (digitalRead(sensorEntrada) == LOW) { 
    tiempoInicial = millis();
    Serial.println("Canica entrada");
    delay(50); // Pequeña espera para evitar lecturas múltiples
  }

  // Detección en sensor de salida
  if (digitalRead(sensorSalida) == LOW) {
    tiempoFinal = millis();
    Serial.println("Canica salida");

    // Calcular tiempo transcurrido
    unsigned long tiempoTranscurrido = tiempoFinal - tiempoInicial; // Tiempo en milisegundos
    float tiempoSegundos = tiempoTranscurrido / 1000.0; // Convertir a segundos

    // Calcular velocidad
    float velocidad = distancia / tiempoSegundos; // Velocidad en metros por segundo
    Serial.print("Velocidad: ");
    Serial.print(velocidad);
    Serial.println(" m/s");

    // Mostrar velocidad en la pantalla LCD
    lcd.setCursor(0, 1); // Segunda línea
    lcd.print("        "); // Limpiar la línea
    lcd.setCursor(0, 1);
    lcd.print(velocidad, 3); // Mostrar con tres decimales
    lcd.print(" m/s");

    delay(50); // Otra pequeña espera
  }
}

• Contraste del LCD: Asegúrate de que el contraste del LCD esté ajustado correctamente. Si el LCD no está legible, puede que necesites ajustar un potenciómetro conectado al pin V0 del LCD si lo utilizas, aunque generalmente no es necesario para módulos con I2C integrados.
• Pruebas con Hello World: Intenta primero un código básico que simplemente muestre "Hello World" en la LCD para asegurarte que toda la cadena de conexiones y configuraciones está funcionando antes de introducir las lecturas de velocidad.

• Revisa el Monitor Serial para asegurar que las lecturas de los sensores funcionan y que los tiempos y cálculos se realizan correctamente.
• Si resolvimos algún problema con el I2C, pero aún no ves los resultados correctos, quizás haya un problema en la forma en que los sensores detectan la canica.

gadiell

copilot

• LED: Puedes usar cualquier diodo LED básico.
• Resistencia: Usualmente una resistencia de 220Ω o 330Ω es adecuada para limitar la corriente al LED.

• Ánodo del LED: Conecta a un pin digital del Arduino (por ejemplo, pin 4).
• Cátodo del LED: Conecta a GND a través de la resistencia.

Cpp
#include 
#include 

const int sensorEntrada = 2; // Pin del sensor de entrada
const int sensorSalida = 3;  // Pin del sensor de salida
const int ledPin = 4; // Pin para el LED

unsigned long tiempoInicial = 0;
unsigned long tiempoFinal = 0;
const float distancia = 0.5; // Distancia entre sensores en metros (ajusta esto según tu setup)

LiquidCrystal_I2C lcd(0x27, 16, 2); // Cambia 0x27 si tu dirección I2C es diferente

void setup() {
  pinMode(sensorEntrada, INPUT);
  pinMode(sensorSalida, INPUT);
  pinMode(ledPin, OUTPUT); // Configurar LED como salida
  Serial.begin(9600);

  lcd.begin(16, 2);
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Velocidad:");
}

void loop() {
  // Detección en sensor de entrada
  if (digitalRead(sensorEntrada) == LOW) {
    tiempoInicial = millis();
    Serial.println("Canica entrada");
    digitalWrite(ledPin, HIGH); // Encender LED
    delay(50);
  }

  // Detección en sensor de salida
  if (digitalRead(sensorSalida) == LOW) {
    tiempoFinal = millis();
    Serial.println("Canica salida");
    digitalWrite(ledPin, LOW); // Apagar LED después de pasar

    // Calcular tiempo transcurrido
    unsigned long tiempoTranscurrido = tiempoFinal - tiempoInicial; 
    float tiempoSegundos = tiempoTranscurrido / 1000.0;

    // Calcular velocidad
    float velocidad = distancia / tiempoSegundos; 
    Serial.print("Velocidad: ");
    Serial.print(velocidad);
    Serial.println(" m/s");

    // Mostrar velocidad en la pantalla LCD
    lcd.setCursor(0, 1);
    lcd.print("        "); 
    lcd.setCursor(0, 1);
    lcd.print(velocidad, 3); 
    lcd.print(" m/s");

    delay(50); 
  }
}

• LED Control: Se enciende el LED (digitalWrite(ledPin, HIGH)) cuando el sensor de entrada detecta la canica. Luego, se apaga el LED (digitalWrite(ledPin, LOW)) después de que la canica pasa por el sensor de salida.
• Pin del LED: Elige cualquier pin digital libre; he sugerido el pin 4. Asegúrate de cambiarlo si decides usar otro pin.

copilot

gadiell

copilot