Carrito utilitario con tracción a 6 ruedas y dirección a 6 ruedas con bogie de balancín.
Suspensión inspirada en los rovers marcianos 'Curiosity' y 'Perseverance' de la NASA.
Código de Arduino también disponible (incompleto a partir del 28-06-22). Deja un mensaje. En GitHub.

Creality.

Ender 5

Sí.

No.

50%

Numerosos archivos, pero no creo que ninguno necesite soporte.

/***

• _SISU_04
• Versión: 04_01
• Fecha de inicio: 03-13-22
• Última revisión: 05-05-22 (INCOMPLETA - HCSR04, Buzzer y LED no funcionan)
• DCC
• Describción:
• • Carrito utilitario Rover con suspensión de rocker-bogie inspirada.
• Por los rovers marcianos 'Curiosity' y 'Perseverance' de la NASA.
• • Tracción a las 6 ruedas con dirección a las 6 ruedas.
• • Incluye control remoto por infrarrojos, un sensor de distancia ultrasónico, y un zumbador.
• y luz LED RGB.

  ---

• ---

  Motores DC.
  motorLF = Motor DC delantero izquierdo.
  motorRF = Motor de corriente continua delantero derecho.
  motorLM = Motor DC medio izquierdo.
  motorRM = Motor DC medio derecho.
  motorLR = Motor DC trasero izquierdo.
  motorRR = Motor DC trasero derecho.

  ---

  Conductores de motor L298N.
  _L298NF = L298N para motores delanteros (ubicados en la parte delantera izquierda del chasis)
  L298N_M = L298N para motores intermedios (ubicado en la parte frontal derecha del chasis)
  ___ L298N_R = L298N para motores traseros (ubicados en el centro del chasis)

  ---

  Servos de dirección.
  servoLF = Servo de dirección frontal izquierdo.
  servoRF = Servo de dirección delantero derecho.
  servoLM = Servo de dirección medio izquierdo.
  servoRM = Servo de dirección medio derecho.
  ServoLR = Servo de dirección trasero izquierdo.
  ServoRR = Servo de dirección trasero derecho.
  ****/

/***

• Incluye, declara constantes/variables e inicializa:
  ****/
  // Incluye bibliotecas

  Incluye // control remoto infrarrojo.

  Incluye // servos de dirección.

  Incluye // planea hacer uso de 'ping' en el futuro.

  
  const int L298N_F_ENA = 2; // pin de E/S PWM digital para controlar la velocidad del motor 'A' - motorLF
  const int L298N_F_ENB = 3; // pin de E/S PWM digital para controlar la velocidad del motor 'B' - motorRF
  const int L298N_F_IN1 = 23; // pin de E/S digital - encendido/apagado para el cable del motor 'A' [OUT1] (motorLF)
  const int L298N_F_IN2 = 25; // pin de E/S digital - encendido/apagado para el cable del motor 'A' [OUT2] (motorLF)
  const int L298N_F_IN3 = 27; // pin de E/S digital - encendido/apagado para el cable del motor 'B' [OUT3] (motorRF)
  const int L298N_F_IN4 = 29; // pin de E/S digital - encendido/apagado para el cable del motor 'B' [OUT4] (motorRF)
  const int L298N_M_ENA = 4; // pin de E/S PWM digital para controlar la velocidad del motor 'A' (motorLM)
  const int L298N_M_ENB = 5; // pin de E/S PWM digital para controlar la velocidad del motor 'B' (motorRM)
  const int L298N_M_IN1 = 33; // pin de E/S digital - encendido/apagado para el cable del motor 'A' [OUT1] (motorLM)
  const int L298N_M_IN2 = 35; // pin de E/S digital - encendido/apagado para el cable del motor 'A' [OUT2] (motorLM)
  const int L298N_M_IN3 = 37; // pin de E/S digital - encendido/apagado para el cable del motor 'B' [OUT3] (motorRM)
  const int L298N_M_IN4 = 39; // pin de E/S digital - encendido/apagado para el cable del motor 'B' [OUT4] (motorRM)
  const int L298N_R_ENA = 6; // pin de E/S PWM digital para controlar la velocidad del motor 'A' (motorLR)
  const int L298N_R_ENB = 7; // pin de E/S PWM digital para controlar la velocidad del motor 'B' (motorRR)
  const int L298N_R_IN1 = 43; // pin de E/S digital - encendido/apagado para el cable del motor 'A' [OUT1] (motorLR)
  const int L298N_R_IN2 = 45; // pin de E/S digital - encendido/apagado para el cable del motor 'A' [OUT2] (motorLR)
  const int L298N_R_IN3 = 47; // pin de E/S digital - encendido/apagado para el cable del motor 'B' [OUT3] (motorRR)
  const int L298N_R_IN4 = 49; // pin de E/S digital - encendido/apagado para el cable del motor 'B' [OUT4] (motorRR)

Int MS = 190; // baja velocidad (150/255, alrededor del 60%)
// velocidad media por defecto (190/255, alrededor del 75%)
// alta velocidad (230/255, alrededor del 90%)

// Servos de dirección.
// Crear objetos Servo para controlar los servos.
Servo servoLF; // delantero izquierdo
Servo servoRF; // delantero derecho
Servo servoLM; // medio izquierdo
Servo servoRM; // medio derecho
Servo servoLR; // trasero izquierdo.
Servo servoRR; // trasero derecho
// Define pines para servos (en MEGA 2560)
int servoLF_Pin = 22; // pin de E/S digital para control de posición.
Int servoRF_Pin = 24; // pin de E/S digital para control de posición.
int servoLM_Pin = 32; // pin de E/S digital para control de posición.
Int servoRM_Pin = 34; // pin de E/S digital para control de posición.
Int servoLR_Pin = 42; // pin de E/S digital para control de posición.
Int servoRR_Pin = 44; // pin de E/S digital para control de posición.

Int servoLF_Pos = 90; // comienza con las ruedas apuntando hacia adelante.
int servoRF_Pos = 90;
int servoLM_Pos = 90;
int servoRM_Pos = 90;
Int servoLR_Pos = 90;
Int servoRR_Pos = 90;

const int IR_in = A0; // variable para almacenar el pin de entrada de la señal del receptor de IR #
IRrecv irrecv(IR_in); // crea un objeto de clase utilizado para recibir la clase.
decodificar_resultados resultados; // crear un objeto de clase de resultados de decodificación
un long sin firmar lastCode; // define una variable para almacenar el último código IR recibido PREGUNTA
unsigned long key_value=0; // PREGUNTA

// Otros
const int buzzer = 11; // pin del zumbador activo - pin PWM utilizado - para control de tono en el futuro.
const int LED_R = 10; // Pin PWM para la intensidad roja del LED RGB montado (o incluye un resistor de 220 ohmios)
const int LED_G = 9; // Pin PWM para la intensidad verde del LED RGB montado (o incluye un resistor de 220 ohmios)
const int LED_B = 8; // Pin PWM para la intensidad del LED RGB azul montado (o incluye un resistor de 220 ohmios)
int redValue; // define variables para la intensidad del LED.
int greenValue;
int blueValue;

// Configurar las variables de HC-SR04.

Define triggerPin A4

Defina echoPin A5

Larga duración, cm, pulgadas;
Int distancia;

Defina la distancia máxima como 200.

// Configuración de NewPing de pines y distancia máxima.
Nuevo sonar Ping (triggerPin, echoPin, maxDistance);

/***

• Código de 'Configuración' inicial para ejecutar una vez:
  ****/
  void setup()
  {
  
  pinMode(L298N_F_ENA, SALIDA);
  pinMode(L298N_F_ENB, SALIDA);
  pinMode(L298N_F_IN1, SALIDA);
  pinMode(L298N_F_IN2, SALIDA);
  pinMode(L298N_F_IN3, SALIDA);
  pinMode(L298N_F_IN4, SALIDA);
  pinMode(L298N_M_ENA, SALIDA);
  pinMode(L298N_M_ENB, SALIDA);
  pinMode(L298N_M_IN1, SALIDA);
  pinMode(L298N_M_IN2, SALIDA);
  pinMode(L298N_M_IN3, SALIDA);
  pinMode(L298N_M_IN4, SALIDA);
  pinMode(L298N_R_ENA, SALIDA);
  pinMode(L298N_R_ENB, SALIDA);
  pinMode(L298N_R_IN1, SALIDA);
  pinMode(L298N_R_IN2, SALIDA);
  pinMode(L298N_R_IN3, SALIDA);
  pinMode(L298N_R_IN4, SALIDA);

  // Adjuntar servos en pines de servo a objetos de servo
  servoLF.attach(servoLF_Pin);
  servoRF.attach(servoRF_Pin);
  servoLM.attach(servoLM_Pin);
  servoRM.attach(servoRM_Pin);
  servoLR.attach(servoLR_Pin);
  servoRR.attach(servoRR_Pin);

// Establece los pines de HC-SR04.
pinMode(triggerPin, SALIDA);
pinMode(echoPin, INPUT);

pinMode(IR_in, INPUT);
irrecv.enableIRIn();
decodificar_resultados resultados;
irrecv.blink13(true);

// Establece el PIN del zumbador.
pinMode(buzzer, SALIDA);

// Establece los pines del LED RGB.
pinMode(LED_R, OUTPUT); // establece los pines como "salida"
pinMode(LED_G, SALIDA);
pinMode(LED_B, SALIDA);
digitalWrite(LED_R, LOW); // LED por defecto apagado
digitalWrite(LED_G, LOW);
digitalWrite(LED_B, LOW);
}

/***

• Código del 'Bucle' Principal para Ejecutarse Repetidamente:
  ***/
  void loop()
  {
  // Activar el pulso HC-SR04.
  digitalWrite(triggerPin, LOW); // limpia el gatillo al establecerlo en bajo.
  delayMicroseconds(5);
  digitalWrite(triggerPin, HIGH); // activar el sensor durante 10 microsegundos.
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  
  duración = pulseIn(echoPin, ALTO);

  // Convertir el tiempo en distancia (velocidad del sonido = 343 m/s)
  cm = (duración/2) / 29.1; // Divide por 29.1 o multiplica por 0.0343
  Pulgadas = (duración/2) / 74; // Divide por 74 o multiplica por 0.0135

  
  si (irrecv.decode(&results)) // verificar si se recibió el código
  {
  si(results.value==0xFFFFFFFF) // si es una repetición, entonces usa el último código recibido.
  {
  resultados.valor=últimoCódigo;
  }
  switch (results.value)
  {
  caso 0xFF10EF: // recibir la tecla "<"
  turnLeft(); // gira a la izquierda.
  break; // salir de la declaración "switch"

  caso 0xFF5AA5: // recibe la tecla ">"
  turnRight(); // gira a la derecha.
  Pausa;

  caso 0xFF6897: // recibir la tecla "*"
  doglegLeft(); // gira todos los servos a la izquierda.
  Pausa;

  caso 0xFF9867: // recibir la tecla "0"
  turnFront(); // gira todos los servos hacia adelante
  Pausa;

  caso 0xFFB04F: // recibir la tecla "#"
  DoglegRight(); // gira todos los servos a la derecha.
  Pausa;

  caso 0xFF18E7: // recibir la tecla de flecha hacia arriba
  ¡Detente!
  retraso(100);
  forwardMS(); // ejecuta los motores DC para avanzar.
  Pausa;

  caso 0xFF4AB5: // recibir la tecla de flecha hacia abajo
  ¡Detente!
  retraso(100);
  backwardMS(); // ejecuta motores de corriente directa para moverse en reversa
  Pausa;

  caso 0xFF38C7: // recibir la tecla "OK"
  halt(); // detener todos los motores.
  Pausa;

  caso 0xFF22DD: // recibir la tecla "4"
  beep(); // pitido y parpadeo en rojo
  flashRed();
  Pausa;

  caso 0xFF02FD: // recibir la tecla "5"
  beep(); // pitido y parpadeo en verde.
  flashGreen();
  Pausa;

  caso 0xFFC23D: // recibir la tecla "6"
  beep(); // pitido y destello azul
  flashBlue();
  Pausa;

  delay(30); // retraso para evitar lecturas falsas.
  irrecv.resume(); // recibe el siguiente valor.
  }
  }
  // Desencadenar acciones basadas en la distancia HC-SR04 si (pulgadas > 1 y pulgadas < 6)
  {
  flashRed();
  beep();
  flashRed();
  }
  si (pulgadas > 6 y pulgadas < 12)
  {
  flashYellow();
  beep();
  flashYellow();
  }
  si (pulgadas > 12 y pulgadas < 24)
  {
  flashGreen();
  beep();
  flashGreen();
  }
  si (pulgadas > 24)
  {
  flashBlue();
  beepBeep();
  beepBeep();
  flashBlue();
  }
  }

/*****

• Otras funciones que se llamarán:
  *****/
  void beep() // hace sonar el zumbador durante 200/1000 segundos.
  {
  digitalWrite(buzzer, ALTO);
  retraso(200);
  digitalWrite(buzzer, LOW);
  }

  void beepBeep() // hace sonar el zumbador dos veces y más rápido.
  {
  digitalWrite(buzzer, ALTO);
  retraso(150);
  digitalWrite(buzzer, LOW);
  retraso(150);
  digitalWrite(buzzer, ALTO);
  retraso(150);
  digitalWrite(buzzer, LOW);
  }

  void flashRed() // parpadea el LED RGB de color rojo durante 200/1000 segundos.
  {
  redValue = 255;
  greenValue = 0;
  blueValue = 0;
  analogWrite(LED_R, redValue);
  analógicoEscribe(LED_G, valorVerde);
  analogWrite(LED_B, blueValue);
  retraso(200);
  redValue=0;
  analogWrite(LED_R, redValue);
  }

  void flashYellow() // Hacer parpadear el LED RGB de color amarillo durante 200/1000 segundos.
  {
  redValue = 255;
  greenValue = 255;
  blueValue = 0;
  analogWrite(LED_R, redValue);
  analógicoEscribe(LED_G, valorVerde);
  analogWrite(LED_B, blueValue);
  retraso(200);
  redValue = 0;
  greenValue = 0;
  analogWrite(LED_R, redValue);
  analógicoEscribe(LED_G, valorVerde);
  }

  void flashGreen() // Hacer parpadear el LED RGB de color verde durante 200/1000 segundos.
  {
  redValue = 0;
  greenValue = 255;
  blueValue = 0;
  analogWrite(LED_R, redValue);
  analógicoEscribe(LED_G, valorVerde);
  analogWrite(LED_B, blueValue);
  retraso(200);
  greenValue=0;
  analógicoEscribe(LED_G, valorVerde);
  }

  void flashBlue() // parpadea el LED RGB azul durante 200/1000 segundos.
  {
  redValue = 0;
  greenValue = 0;
  blueValue = 255;
  analogWrite(LED_R, redValue);
  analógicoEscribe(LED_G, valorVerde);
  analogWrite(LED_B, blueValue);
  retraso(200);
  blueValue=0;
  analogWrite(LED_B, blueValue);
  }

  void msSlow() // establece la velocidad del motor MS a lenta.
  {
  MS = 150;
  }

  void msMedium() // establece la velocidad del motor MS a medio.
  {
  MS = 190;
  }

  void msFast() // Establece la velocidad del motor MS a rápida.
  {
  MS = 230;
  }

  void forwardMS() // Establece que los motores de CC se muevan hacia adelante a la velocidad establecida de "MS".
  {
  digitalWrite(L298N_F_IN1, HIGH); // Enciende los motores.
  digitalWrite(L298N_F_IN2, LOW);
  digitalWrite(L298N_F_IN3, LOW);
  digitalWrite(L298N_F_IN4, ALTO);
  digitalWrite(L298N_M_IN1, ALTO);
  digitalWrite(L298N_M_IN2, LOW);
  digitalWrite(L298N_M_IN3, LOW);
  digitalWrite(L298N_M_IN4, ALTO);
  digitalWrite(L298N_R_IN1, LOW);
  digitalWrite(L298N_R_IN2, ALTO);
  digitalWrite(L298N_R_IN3, ALTO);
  digitalWrite(L298N_R_IN4, LOW);
  AnalogWrite(L298N_F_ENA, MS); // establece la velocidad.
  AnalogWrite(L298N_F_ENB, MS);
  AnalogWrite(L298N_M_ENA, MS);
  AnalogWrite(L298N_M_ENB, MS);
  AnalogWrite(L298N_R_ENA, MS);
  AnalogWrite(L298N_R_ENB, MS);
  }

void backwardMS() // Establece que los motores DC se muevan hacia atrás a la velocidad establecida de "MS".
{
digitalWrite(L298N_F_IN1, LOW);
digitalWrite(L298N_F_IN2, ALTO);
digitalWrite(L298N_F_IN3, ALTO);
digitalWrite(L298N_F_IN4, LOW);
digitalWrite(L298N_M_IN1, LOW);
digitalWrite(L298N_M_IN2, HIGH);
digitalWrite(L298N_M_IN3, ALTO);
digitalWrite(L298N_M_IN4, LOW);
digitalWrite(L298N_R_IN1, ALTO);
digitalWrite(L298N_R_IN2, LOW);
digitalWrite(L298N_R_IN3, LOW);
digitalWrite(L298N_R_IN4, ALTO);
AnalogWrite(L298N_F_ENA, MS);
AnalogWrite(L298N_F_ENB, MS);
AnalogWrite(L298N_M_ENA, MS);
AnalogWrite(L298N_M_ENB, MS);
AnalogWrite(L298N_R_ENA, MS);
AnalogWrite(L298N_R_ENB, MS);
}

void halt() // Detener/Parar los motores de CC.
{
analogWrite(L298N_F_ENA, 0);
analógicoEscribe(L298N_F_ENB, 0);
analogWrite(L298N_M_ENA, 0);
analogWrite(L298N_M_ENB, 0);
analogWrite(L298N_R_ENA, 0);
analogWrite(L298N_R_ENB, 0);
}

void turnFront() // Girar todos los servos hacia adelante directamente.
{
servoLF.write(90);
servoRF.write(90);
servoLM.write(90);
servoRM.write(90);
servoLR.write(90);
servoRR.write(90);
delay(20); // permitir que el servo llegue allí.
}

void turnLeft() // Girar los servos para hacer un giro a la izquierda.
{
servoLF.write(60);
servoRF.write(60);
servoLM.write(90);
servoRM.write(90);
servoLR.write(120);
servoRR.write(120);
retraso(20);
}

void turnRight() // Girar todos los servos para hacer un giro a la derecha.
{
servoLF.write(120);
servoRF.write(120);
servoLM.write(90);
servoRM.write(90);
servoLR.write(60);
servoRR.write(60);
retraso(20);
}

void doglegLeft() // Girar todos los servos a Dogleg Izquierdo
{
servoLF.write(60);
servoRF.write(60);
servoLM.write(60);
servoRM.write(60);
servoLR.write(60);
servoRR.write(60);
retraso(20);
}

void doglegRight() // Gira todos los servos a Dogleg Right.
{
servoLF.write(120);
servoRF.write(120);
servoLM.write(120);
servoRM.write(120);
servoLR.write(120);
servoRR.write(120);
retraso(20);
}