• Arduino Uno: La unidad de control principal que ejecutará el código C++.
• Sensor de Distancia Ultrasónico (por ejemplo, HC-SR04): Para medir la distancia hasta el objeto.
• Módulo Convertidor Boost XL6009: Para aumentar el voltaje de salida hasta 18V según la distancia medida.
• Fuente de Alimentación: Debe cumplir los requisitos del Arduino y del XL6009, teniendo en cuenta el voltaje y la corriente máxima necesarios para tu aplicación.
• Resistencias y Cables de Conexión: Para hacer las conexiones necesarias y potencialmente para formar un divisor de tensión si se necesita monitorear el voltaje de salida del XL6009.

• Sensor de Distancia Ultrasónico HC-SR04:
  • Conecta VCC a 5V en el Arduino.
  • Conecta GND a GND en el Arduino.
  • Conecta Trig a una de las salidas digitales en el Arduino.
  • Conecta Echo a una de las entradas digitales en el Arduino.
• Módulo Convertidor Boost XL6009:
  • Conecta el GND del módulo al GND del Arduino.
  • La entrada del módulo XL6009 (VIN) se conecta a la fuente de alimentación.
  • La señal de control para ajustar el voltaje de salida podría necesitar un circuito adicional, dependiendo de si el XL6009 seleccionado permite control directo desde el Arduino (ajuste de voltaje basado en PWM o similar). Algunos modelos pueden necesitar un circuito DAC o un PWM con filtro para convertir la señal a un voltaje analógico referente para el ajuste.

Cpp
#include <NewPing.h>

#define TRIGGER_PIN  12  // Pin de trigger del sensor HC-SR04
#define ECHO_PIN     11  // Pin de echo del sensor HC-SR04
#define MAX_DISTANCE 200 // Distancia máxima que deseamos medir (en cm)

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); 

void setup() {
  Serial.begin(9600); // Inicia la comunicación serial
}

void loop() {
  delay(50);  // Retardo entre mediciones
  unsigned int uS = sonar.ping(); // Envía un ping y recibe el eco
  float distance = uS / US_ROUNDTRIP_CM; // Convierte tiempo en distancia
  Serial.print("Distancia: ");
  Serial.print(distance); // Imprime la distancia medida
  Serial.println("cm");
  
  // Cálculo para ajustar el voltaje de salida
  float voltaje = calcularVoltaje(distance);
  // Aquí deberías agregar el código para ajustar el módulo XL6009 basado en el voltaje calculado
  // Esto dependerá de cómo tu módulo específico sea controlado
}

float calcularVoltaje(float distancia) {
  if(distancia > 8) {
    return 12.0; // Retorna el voltaje base si la distancia es mayor a 8 cm
  } else {
    float incremento = (8.0 - distancia) / 2.0 * 0.25;
    float voltaje = 12.0 + 12.0 * incremento; // Calcula el nuevo voltaje
    return voltaje > 18.0 ? 18.0 : voltaje; // Asegura no superar 18V
  }
}

1. Sensor HC-SR04 a Arduino Uno
   • VCC del HC-SR04 a 5V en el Arduino.
   • GND del HC-SR04 a GND en el Arduino.
   • Trig del HC-SR04 a un pin digital del Arduino, por ejemplo D12.
   • Echo del HC-SR04 a otro pin digital en el Arduino, por ejemplo D11.

2. Módulo Convertidor Boost XL6009
   • GND al GND común de tu proyecto.
   • VIN al Vout de tu fuente de alimentación, la cual debe cumplir con los requisitos mínimos del XL6009 y lo que desees alimentar con el voltaje aumentado.
   • VOUT del XL6009 conectará a la carga que deseas alimentar, siempre observando los límites de corriente y voltaje del módulo.

• Para un control PWM digital (si es compatible):
  • Conectar PWM OUT en Arduino a PWM IN o el pin de control en el XL6009.
• Para control analógico:
  • Conectar PWM OUT del Arduino a través de un filtro RC o un módulo DAC a la entrada de control del XL6009.

Cpp
#include <NewPing.h>

#define TRIGGER_PIN  12  // Pin de trigger para el sensor HC-SR04
#define ECHO_PIN     11  // Pin de echo para el sensor HC-SR04
#define MAX_DISTANCE 400 // Máxima distancia a medir (en cm)
#define PWM_PIN      3   // Pin PWM para controlar el voltaje (modificar según la conexión real)

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {
  pinMode(PWM_PIN, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  delay(50); // Espera para estabilizar el sensor
  unsigned int distance = sonar.ping_cm(); // Medida de la distancia en centímetros
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println("cm");
  
  int pwmValue = distanceToPWM(distance);
  analogWrite(PWM_PIN, pwmValue);

  delay(1000); // Espera entre lecturas
}

int distanceToPWM(unsigned int distance) {
  const unsigned int maxDistance = 8; // Distancia máxima de interés
  const int maxPWM = 255; // Máximo valor para PWM
  if (distance >= maxDistance || distance == 0) { // Si está fuera de rango o demasiado cerca para medir
    return 0; // Mínimo voltaje
  } else {
    // Calcula un valor proporcional para el PWM
    int pwmValue = static_cast<int>((1.0 - float(distance) / maxDistance) * maxPWM);
    // Asegura que el valor esté en los límites esperados
    return constrain(pwmValue, 0, maxPWM);
  }
}

Cpp
#include <NewPing.h>

// Define los pines para el sensor HC-SR04
#define TRIGGER_PIN  12
#define ECHO_PIN     11
#define MAX_DISTANCE 400 // Máxima distancia a medir (en cm)
#define PWM_PIN      3   // Pin PWM para la señal de control (ajustar según tu módulo XL6009)

// Inicializa el sensor HC-SR04
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {
  pinMode(PWM_PIN, OUTPUT); // Configura el pin PWM como salida
  Serial.begin(9600); // Inicia la comunicación serial
}

void loop() {
  delay(60); // Pequeña espera entre mediciones
  unsigned int distance = sonar.ping_cm(); // Realiza una medición en cm
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println("cm");
  
  // Ajusta el PWM basado en la distancia medida
  int pwmValue = calculatePWMValue(distance);
  analogWrite(PWM_PIN, pwmValue);

  delay(1000); // Espera antes de la próxima medición
}

// Función para calcular el valor PWM basado en la distancia
int calculatePWMValue(unsigned int distance) {
  // Establece los parámetros para el cálculo del PWM
  const unsigned int maxDistance = 8;  // Distancia máxima de interés en cm
  float voltageStep = (18.0 - 12.0) / (maxDistance / 2.0); // Define el paso de voltaje por cada 2cm

  if (distance == 0 || distance > maxDistance) { 
    // Si no hay objeto en rango o está muy lejos, establece el voltaje mínimo (equivale a 12V)
    return map(12, 0, 18, 0, 255);
  } else {
    // Calcula el voltaje deseado basado en la distancia
    float desiredVoltage = 12 + ((maxDistance - distance) / 2.0) * voltageStep;
    // Mapea el voltaje deseado a un valor PWM y asegura que no exceda 18V equivalentes
    int pwmValue = map(desiredVoltage, 0, 18, 0, 255);
    return constrain(pwmValue, 0, 255);
  }
}

1. Verifica las Conexiones del Sensor HC-SR04 y el XL6009
   • Asegúrate de que las conexiones físicas de todos los componentes (incluido el sensor HC-SR04 y cualquier conexión al módulo XL6009) estén correctamente hechas y sean firmes.
   • Confirma que el TRIGGER_PIN y ECHO_PIN estén correctamente conectados a los pines 12 y 11 en el Arduino, respectivamente, y que el PWM_PIN (p. ej., pin 3) esté bien conectado si estás utilizando un método de control para el XL6009.
2. Revisa la Alimentación
   • Verifica que la fuente de alimentación esté proporcionando el voltaje adecuado y corriente suficiente para el Arduino, el sensor HC-SR04, y el XL6009. Recuerda que el XL6009 y la carga conectada a este pueden requerir más corriente de la que el Arduino pueda suministrar directamente.
3. Confirma la Configuración del IDE de Arduino
   • Asegúrate de que estás seleccionando el tipo correcto de placa ("Arduino/Genuino Uno") y el puerto correcto en el IDE de Arduino antes de subir el código.
4. Diagnóstico del Sensor HC-SR04
   • Revisa si el sensor HC-SR04 está funcionando correctamente. Puedes hacerlo cargando un código más simple que solo mida y muestre la distancia para asegurarte de que el sensor no esté defectuoso.
5. Compatibilidad de la Señal PWM con el XL6009
   • Si la parte que no funciona es el control del módulo XL6009, vale la pena confirmar si tu módulo específico permite ser controlado mediante una señal PWM. Algunos módulos de boost converter no tienen un pin de control que acepte PWM directamente o requieren una señal analógica para el ajuste de voltaje. Si es así, necesitarías un filtro de bajo paso (para convertir PWM a analógico) o un DAC externo.
6. Prueba el Código Sin el Ajuste de Voltaje
   • Como una prueba de diagnóstico, intenta modificar el código para que solo mida la distancia y la imprima en el monitor serial sin intentar ajustar el voltaje. Esto puede ayudar a aislar si el problema está en la medición de distancia o en el control de voltaje.
7. Debugging Serial
   • Utiliza Serial.println() para imprimir variables clave como la distancia medida y el valor PWM calculado, para verificar si los valores son coherentes con tus expectativas.
8. Versión del IDE de Arduino y Librerías
   • Asegúrate de que estés utilizando una versión actualizada del IDE de Arduino y de las librerías. La librería NewPing podría no funcionar correctamente si está desactualizada o si hay conflictos con otras librerías.

• Verifica el código completo: Asegúrate de que el código que estés intentando cargar esté completo y no le falten partes. Esto incluye todas las llaves {}, paréntesis (), y punto y comas ; donde sean necesarios.
• Chequea las librerías: Confirma que la librería NewPing esté instalada correctamente en tu IDE de Arduino. Ve a Sketch > Include Library > Manage Libraries... y busca "NewPing" para instalarla o actualizarla.
• Revisa nombres de variables y funciones: Asegúrate de que todos los nombres estén escritos correctamente y de que estés utilizando correctamente mayúsculas y minúsculas, ya que C++ es sensible a ellas.

• Selecciona el tipo de placa correcto: En el menú de Herramientas (Tools), asegúrate de que el tipo de placa seleccionado sea "Arduino/Genuino Uno".
• Puerto correcto: En el menú de Herramientas (Tools), bajo la sección de "Puerto" (Port), asegúrate de seleccionar el puerto al que está conectado tu Arduino. Si no estás seguro, desconecta tu Arduino, abre el menú nuevamente para ver qué puertos desaparecen, y luego vuelve a conectar tu Arduino para ver qué puerto reaparece.
• Reinstala el IDE de Arduino: Si los problemas persisten, intenta reinstalar el IDE de Arduino, asegurándote de descargar la última versión desde el sitio web oficial de Arduino.

• Cable USB: Prueba con otro cable USB para descartar que el problema sea el cable.
• Puerto USB de la computadora: Cambia el Arduino a otro puerto USB en tu computadora.
• Placa Arduino Uno: Existe la posibilidad de que la placa de Arduino esté defectuosa. Si tienes otra placa Arduino, prueba cargar el código en esa placa para ver si el problema persiste.

• Problemas con el controlador: En algunos sistemas operativos, especialmente en Windows, es posible que necesites instalar o actualizar los drivers para la placa de Arduino. Consulta el foro de Arduino o la sección de ayuda para obtener guías sobre cómo instalar o actualizar los drivers.

Cpp
void setup() {
  pinMode(13, OUTPUT); // Configura el pin 13 como salida
}

void loop() {
  digitalWrite(13, HIGH);   // Enciende el LED
  delay(1000);              // Espera un segundo
  digitalWrite(13, LOW);    // Apaga el LED
  delay(1000);              // Espera un segundo
}

1. Conexión de Alimentación
   • VIN (Entrada de Voltaje): Aquí conectarás el voltaje de entrada que deseas elevar. Este puede ser desde una batería, un adaptador de corriente, u otra fuente de energía DC. El rango de tensión de entrada aceptable suele estar entre 3V y 32V, pero siempre verifica las especificaciones de tu módulo específico.
   • GND (Tierra): Este pin se conecta al negativo de tu fuente de energía y cualquier GND común en tu proyecto, incluyendo el GND del Arduino si estás usando uno.
2. Conexión de Salida
   • VOUT (+): Este es el positivo de la salida de voltaje elevado. La tensión de este punto dependerá de cómo ajustes el potenciómetro en el módulo XL6009 y de la capacidad del propio módulo.
   • GND (-): Al igual que en la entrada, este pin se conectará al GND común de tu circuito.
3. Ajuste de Salida
   • Potenciómetro: El XL6009 generalmente viene con un potenciómetro que permite ajustar el voltaje de salida. Girando el potenciómetro (a menudo con un destornillador pequeño), podrás aumentar o disminuir el voltaje de salida. La dirección exacta (horario o antihorario para aumentar) puede variar, así que te recomiendo empezar con ajustes pequeños y medir el voltaje de salida con un multímetro.

• Control de Voltaje desde Arduino (Avanzado): Si deseas controlar dinámicamente el voltaje de salida del módulo XL6009 desde un Arduino o cualquier microcontrolador, necesitarías una forma de convertir una señal digital (por ejemplo, PWM) en una señal analógica que podría influir en el circuito de feedback del XL6009. Esto podría implicar circuitos adicionales y complejidad, aparte de requerir un entendimiento profundo del funcionamiento interno del XL6009. Esta no es una función estándar del módulo y podría afectar su estabilidad y desempeño.

• Medición y Ajuste: Antes de conectar la salida del XL6009 a tu circuito o dispositivo, siempre mide el voltaje de salida con un multímetro para asegurarte de que esté dentro del rango deseado. Ajusta el potenciómetro según sea necesario.
• Capacidad de Corriente: Ten en cuenta la corriente máxima de salida que el XL6009 puede proporcionar sin sobrecalentarse. El enfriamiento adecuado (disipadores de calor, ventilación) puede ser necesario para cargas cercanas al límite del módulo.
• Funcionamiento Seguro: Siempre es buena práctica comenzar con la carga desconectada cuando ajustas el voltaje de salida por primera vez para evitar dañar tu carga por un voltaje inesperadamente alto.