6-Rad-Antrieb mit 6-Rad-Lenkung für Nutzfahrzeuge mit Rocker-Bogie.
Eine Aufhängung, inspiriert von den Mars-Rovern 'Curiosity' und 'Perseverance' der NASA.
Arduino-Code ebenfalls verfügbar (unvollständig zum 28. Juni 2022). Hinterlassen Sie eine Nachricht. Auf GitHub.

Creality

Ender 5

Ja

Nein.

50%

Zahlreiche Dateien, aber ich glaube nicht, dass irgendeine Unterstützung nötig ist.

/***

• _SISU_04
• Version: 04_01
• Startdatum: 03-13-22
• Letzte Überarbeitung: 05-05-22 (UNVOLLSTÄNDIG - HCSR04, Summer und LED funktionieren nicht)
• DCC
• Beschreibung:
• • Rover-Utility-Wagen mit von der Rocker-Bogie-Aufhängung inspirierter Federung
• Von den NASA-Mars-Rovern 'Curiosity' und 'Perseverance'.
• • 6-Rad-Antrieb mit 6-Rad-Lenkung.
• • Beinhaltet eine IR-Fernbedienung, einen Ultraschall-Abstandssensor, einen Summer.
• und RGB-LED-Licht.

  ---

• ---

  DC-Motoren
  MotorLF = Linker vorderer Gleichstrommotor
  MotorRF = Rechter vorderer Gleichstrommotor
  motorLM = Linker mittlerer Gleichstrommotor
  motorRM = Rechter mittlerer Gleichstrommotor
  MotorLR = Linker hinterer DC-Motor
  motorRR = Rechter hinterer Gleichstrommotor

  ---

  L298N Motor-Treiber
  _L298NF = L298N für Frontmotoren (befindet sich links vorne im Chassis)
  L298N_M = L298N für mittlere Motoren (befindet sich rechts vor dem Chassis)
  ___ L298N_R = L298N für Hintermotoren (befindet sich in der Mitte des Chassis)

  ---

  Steuerungsservos
  servoLF = Lenkservo links vorne
  servoRF = Rechter vorderer Lenkservo
  servoLM = linkes mittleres Lenkservo
  servoRM = Rechter mittlerer Lenkservo
  servoLR = Linker hinterer Lenkservo
  servoRR = Rechter hinterer Lenkservo
  ****/

/***

• Einfügen, Konstanten/Variablen deklarieren und initialisieren:
  ****/
  // Bibliotheken einbinden

  beinhalten // Infrarot-Fernbedienung

  Einbeziehen // Lenkservos

  Einbeziehen // Planen, 'ping' in Zukunft zu nutzen.

  // L298N DC-Motor-Treiber für Arduino MEGA 2560 Pin-Zuweisungen
  const int L298N_F_ENA = 2; // digitaler PWM-I/O-Pin zur Steuerung der Geschwindigkeit von Motor 'A' - motorLF
  const int L298N_F_ENB = 3; // digitaler PWM-I/O-Pin zur Steuerung der Geschwindigkeit von Motor 'B' - motorRF
  const int L298N_F_IN1 = 23; // digitaler I/O-Pin - Ein/Aus für Motor 'A' Leitung [OUT1] (MotorLF)
  const int L298N_F_IN2 = 25; // digitaler I/O-Pin - Ein-/Ausschalten für Motor 'A'-Anschluss [OUT2] (motorLF)
  const int L298N_F_IN3 = 27; // digitaler I/O-Pin - Ein-/Ausschalten für Motor 'B'-Kabel [OUT3] (MotorRF)
  const int L298N_F_IN4 = 29; // digitaler I/O-Pin - Ein/Aus für Motor 'B' Leitung [OUT4] (MotorRF)
  const int L298N_M_ENA = 4; // digitaler PWM-I/O-Pin zur Steuerung der Geschwindigkeit von Motor 'A' (MotorLM)
  const int L298N_M_ENB = 5; // digitaler PWM-I/O-Pin zur Steuerung der Geschwindigkeit von Motor 'B' (motorRM)
  const int L298N_M_IN1 = 33; // digitaler I/O-Pin - Ein/Aus für Motor 'A' Leitung [OUT1] (MotorLM)
  const int L298N_M_IN2 = 35; // digitaler I/O-Pin - Ein-/Ausschalten für Motor 'A'-Kabel [OUT2] (MotorLM)
  const int L298N_M_IN3 = 37; // digitaler I/O-Pin - Ein/Aus für Motor 'B' Leitung [OUT3] (motorRM)
  const int L298N_M_IN4 = 39; // digitaler I/O-Pin - Ein/Aus für Motor 'B' Leitung [OUT4] (motorRM)
  const int L298N_R_ENA = 6; // digitaler PWM-I/O-Pin zur Steuerung der Geschwindigkeit von Motor 'A' (motorLR)
  const int L298N_R_ENB = 7; // digitaler PWM-I/O-Pin zur Steuerung der Geschwindigkeit von Motor 'B' (MotorRR)
  const int L298N_R_IN1 = 43; // digitaler I/O-Pin - Ein-/Ausschalten für Motor 'A'-Leitung [OUT1] (motorLR)
  const int L298N_R_IN2 = 45; // digitaler I/O-Pin - Ein-/Ausschalten für Motor 'A'-Leitung [OUT2] (motorLR)
  const int L298N_R_IN3 = 47; // digitaler I/O-Pin - Ein-/Ausschalten für Motor 'B'-Leitung [OUT3] (MotorRR)
  const int L298N_R_IN4 = 49; // digitaler I/O-Pin - Ein/Aus für Motor 'B' Leitung [OUT4] (MotorRR)

// Geschwindigkeiten von DC-Motoren
int MS = 190; // niedrige Geschwindigkeit (150/255, etwa 60%)
// mittlere Standardgeschwindigkeit (190/255, etwa 75%)
// hohe Geschwindigkeit (230/255, etwa 90%)

// Lenkservos
// Erstelle Servo-Objekte, um die Servos zu steuern.
Servo servoLF; // linke Front
Servo servoRF; // rechte Front
Servo servoLM; // links Mitte
Servo servoRM; // rechts in der Mitte
Servo servoLR; // linker hinterer Teil
Servo servoRR; // rechter Hinterradantrieb
// Definieren Sie Pins für Servos (auf MEGA 2560)
int servoLF_Pin = 22; // digitaler I/O-Pin für Positionskontrolle
int servoRF_Pin = 24; // digitaler I/O-Pin für die Positionskontrolle
int servoLM_Pin = 32; // digitaler I/O-Pin für die Positionskontrolle
int servoRM_Pin = 34; // digitaler I/O-Pin für die Positionskontrolle
int servoLR_Pin = 42; // digitaler I/O-Pin für die Positionskontrolle
int servoRR_Pin = 44; // digitaler I/O-Pin für Positionskontrolle
// Definieren Sie Variablen für Servo-Positionen
int servoLF_Pos = 90; // Beginne mit den Rädern geradeaus.
int servoRF_Pos = 90;
Int servoLM_Pos = 90;
int servoRM_Pos = 90;
int servoLR_Pos = 90;
int servoRR_Pos = 90;

// IR-Empfänger
const int IR_in = A0; // Variable zur Speicherung des Eingangs-Pins für das IR-Empfängersignal #
IRrecv irrecv(IR_in); // erstelle ein Klassenobjekt, das zum Empfangen von Klassen verwendet wird.
decode_results results; // erstelle ein Objekt der Klasse für Dekodierungsergebnisse
Unsignierter langer letzter Code; // Definieren Sie eine Variable zum Speichern des letzten empfangenen IR-Codes FRAGE
Unsignierter langer Schlüsselwert = 0; // FRAGE

// Sonstiges
const int buzzer = 11; // aktiver Buzzer-Pin - verwendeter PWM-Pin - für zukünftige Tonsteuerung
const int LED_R = 10; // PWM-Pin für die rote Intensität der montierten RGB-LED (oder fügen Sie einen 220-Ohm-Widerstand hinzu)
const int LED_G = 9; // PWM-Pin für die grüne Intensität der montierten RGB-LED (oder schließe einen 220-Ohm-Widerstand ein)
const int LED_B = 8; // PWM-Pin für die Blauintensität der montierten RGB-LED (oder fügen Sie einen 220-Ohm-Widerstand hinzu)
int redValue; // Definieren Sie Variablen für die LED-Intensität.
int grüner Wert;
int blueValue;

// Richten Sie HC-SR04-Variablen ein.

Definiere TriggerPin A4

Definieren Sie echoPin A5

Lange Dauer, cm, Zoll;
Int Distanz;

Definiere maxDistance 200

// NewPing-Einstellung von Pins und maximaler Entfernung
NewPing-Sonar(TriggerPin, EchoPin, Maximalentfernung);

/***

• Initialer 'Setup'-Code, der einmal ausgeführt werden soll:
  ****/
  void setup()
  {
  // Setze die angeschlossenen Pins des L298N auf Ausgang
  pinMode(L298N_F_ENA, OUTPUT);
  pinMode(L298N_F_ENB, OUTPUT);
  pinMode(L298N_F_IN1, OUTPUT);
  pinMode(L298N_F_IN2, OUTPUT);
  pinMode(L298N_F_IN3, OUTPUT);
  pinMode(L298N_F_IN4, OUTPUT);
  pinMode(L298N_M_ENA, AUSGANG);
  pinMode(L298N_M_ENB, OUTPUT);
  pinMode(L298N_M_IN1, OUTPUT);
  pinMode(L298N_M_IN2, OUTPUT);
  pinMode(L298N_M_IN3, OUTPUT);
  pinMode(L298N_M_IN4, OUTPUT);
  pinMode(L298N_R_ENA, AUSGANG);
  pinMode(L298N_R_ENB, AUSGANG);
  pinMode(L298N_R_IN1, OUTPUT);
  pinMode(L298N_R_IN2, OUTPUT);
  pinMode(L298N_R_IN3, OUTPUT);
  pinMode(L298N_R_IN4, OUTPUT);

  // Befestige Servos auf Servo-Pins an Servo-Objekten
  servoLF.attach(servoLF_Pin);
  servoRF.attach(servoRF_Pin);
  servoLM.attach(servoLM_Pin);
  servoRM.attach(servoRM_Pin);
  servoLR.attach(servoLR_Pin);
  servoRR.attach(servoRR_Pin);

// Setze HC-SR04-Pins
pinMode(triggerPin, OUTPUT);
pinMode(echoPin, INPUT);

// Setze die IR-Empfänger-Pins und starte
pinMode(IR_in, INPUT);
irrecv.enableIRIn();
decode_results Ergebnisse;
irrecv.blink13(true);

// Setze Buzzer-Pin
pinMode(buzzer, OUTPUT);

// Setze RGB-LED-Pins
pinMode(LED_R, OUTPUT); // setzt Pins auf "Output"
pinMode(LED_G, OUTPUT);
pinMode(LED_B, OUTPUT);
digitalWrite(LED_R, LOW); // setzt die LED standardmäßig auf ausgeschaltet
digitalWrite(LED_G, LOW);
digitalWrite(LED_B, LOW);
)

/***

• Haupt-'Schleifen'-Code, der wiederholt ausgeführt werden soll:
  ***/
  void loop()
  {
  // Trigger HC-SR04-Impuls
  digitalWrite(triggerPin, LOW); // Löscht den Trigger, indem er auf niedrig gesetzt wird.
  delayMicroseconds(5);
  digitalWrite(triggerPin, HIGH); // trigger Sensor für 10 Mikrosekunden
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  // Lies den Echo-Pin, um die Dauer in Mikrosekunden zu erhalten.
  Dauer = pulseIn(echoPin, HIGH);

  // Konvertiere die Zeit in eine Entfernung (Schallgeschwindigkeit = 343 m/s)
  cm = (Dauer/2) / 29,1; // Teilen durch 29,1 oder multiplizieren mit 0,0343
  Zoll = (Dauer/2) / 74; // Teilen durch 74 oder multiplizieren mit 0,0135

  // Infrarot-Empfänger
  wenn (irrecv.decode(&results)) // überprüfen, ob der Code empfangen wurde
  {
  wenn (results.value == 0xFFFFFFFF) // Wenn es sich um eine Wiederholung handelt, dann verwende den letzten empfangenen Code.
  {
  results.value=lastCode;
  )
  switch (results.value)
  {
  Fall 0xFF10EF: // Empfange die Taste "<"
  turnLeft(); // dreht nach links
  break; // Aussteigen aus der "switch"-Anweisung

  Fall 0xFF5AA5: // Empfange die Taste ">"
  turnRight(); // nach rechts drehen
  Pause;

  case 0xFF6897: // Empfangen der Taste "*"
  doglegLeft(); // drehe alle Servos nach links
  Pause;

  Fall 0xFF9867: // Empfange die Taste "0"
  turnFront(); // drehe alle Servos nach vorne
  Pause;

  Fall 0xFFB04F: // Empfangen der Taste "#"
  DoglegRight(); // drehe alle Servos nach rechts
  Pause;

  Fall 0xFF18E7: // Empfange die Pfeil-nach-oben-Taste
  halt();
  delay(100);
  forwardMS(); // Lasse die DC-Motoren laufen, um vorwärts zu fahren.
  Pause;

  case 0xFF4AB5: // Empfange die Pfeiltaste nach unten
  halt();
  delay(100);
  backwardMS(); // Laufen Sie DC-Motoren, um sich rückwärts zu bewegen.
  Pause;

  case 0xFF38C7: // empfange "OK"-Taste
  halt(); // stoppe alle Motoren
  Pause;

  Fall 0xFF22DD: // Empfange die Taste "4"
  beep(); // Piepen und rot blinken
  FlashRed();
  Pause;

  Fall 0xFF02FD: // Empfangen der Taste "5"
  beep(); // Piepsen und grün blinken
  flashGreen();
  Pause;

  case 0xFFC23D: // Empfange die Taste "6"
  beep(); // Piepen und blaues Blinken
  flashBlue();
  Pause;

  delay(30); // Verzögerung, um falsche Messwerte zu verhindern
  irrecv.resume(); // empfange den nächsten Wert
  )
  )
  // Aktionen auslösen basierend auf der HC-SR04-Entfernung, wenn (Zoll > 1 und Zoll < 6)
  {
  FlashRed();
  Beep();
  FlashRed();
  )
  wenn (Zoll > 6 und Zoll < 12)
  {
  FlashYellow();
  Beep();
  FlashYellow();
  )
  wenn (Zoll > 12 und Zoll < 24)
  {
  flashGreen();
  Beep();
  flashGreen();
  )
  wenn (Zoll > 24)
  {
  flashBlue();
  BeepBeep();
  BeepBeep();
  flashBlue();
  )
  )

/*****

• Andere Funktionen, die aufgerufen werden sollen:
  *****/
  void beep() // lässt den Summer 200/1000 Sekunden lang ertönen.
  {
  digitalWrite(buzzer, HIGH);
  Verzögerung(200);
  digitalWrite(buzzer, LOW);
  )

  void beepBeep() // lässt den Summer zweimal und schneller ertönen.
  {
  digitalWrite(buzzer, HIGH);
  verzögern(150);
  digitalWrite(buzzer, LOW);
  verzögern(150);
  digitalWrite(buzzer, HIGH);
  verzögern(150);
  digitalWrite(buzzer, LOW);
  )

  void flashRed() // Blinkt die RGB-LED rot für 200/1000 Sekunden.
  {
  redValue = 255;
  greenValue = 0;
  blueValue = 0;
  analogWrite(LED_R, redValue);
  analogWrite(LED_G, greenValue);
  analogWrite(LED_B, blueValue);
  Verzögerung(200);
  redValue=0;
  analogWrite(LED_R, redValue);
  )

  void flashYellow() // Blinkt die RGB-LED 200/1000 Sekunden lang gelb.
  {
  redValue = 255;
  greenValue = 255;
  blueValue = 0;
  analogWrite(LED_R, redValue);
  analogWrite(LED_G, greenValue);
  analogWrite(LED_B, blueValue);
  Verzögerung(200);
  redValue = 0;
  greenValue = 0;
  analogWrite(LED_R, redValue);
  analogWrite(LED_G, greenValue);
  )

  void flashGreen() // Blinkt die RGB-LED grün für 200/1000 Sekunden.
  {
  redValue = 0;
  greenValue = 255;
  blueValue = 0;
  analogWrite(LED_R, redValue);
  analogWrite(LED_G, greenValue);
  analogWrite(LED_B, blueValue);
  Verzögerung(200);
  greenValue=0;
  analogWrite(LED_G, greenValue);
  )

  void flashBlue() // Blaues Blinken der RGB-LED für 200/1000 Sekunden
  {
  redValue = 0;
  greenValue = 0;
  blueValue = 255;
  analogWrite(LED_R, redValue);
  analogWrite(LED_G, greenValue);
  analogWrite(LED_B, blueValue);
  Verzögerung(200);
  blueValue=0;
  analogWrite(LED_B, blueValue);
  )

  void msSlow() // Setzt die Motorgeschwindigkeit MS auf langsam.
  {
  MS = 150;
  )

  void msMedium() // Setzt die Motorgeschwindigkeit MS auf mittel.
  {
  MS = 190;
  )

  void msFast() // Setzt die Motorgeschwindigkeit MS auf schnell.
  {
  MS = 230;
  )

  void forwardMS() // setzt die DC-Motoren so, dass sie sich mit der eingestellten "MS"-Geschwindigkeit vorwärts bewegen.
  {
  digitalWrite(L298N_F_IN1, HIGH); // Motoren einschalten
  digitalWrite(L298N_F_IN2, LOW);
  digitalWrite(L298N_F_IN3, LOW);
  digitalWrite(L298N_F_IN4, HIGH);
  digitalWrite(L298N_M_IN1, HIGH);
  digitalWrite(L298N_M_IN2, LOW);
  digitalWrite(L298N_M_IN3, LOW);
  digitalWrite(L298N_M_IN4, HIGH);
  digitalWrite(L298N_R_IN1, LOW);
  digitalWrite(L298N_R_IN2, HIGH);
  digitalWrite(L298N_R_IN3, HIGH);
  digitalWrite(L298N_R_IN4, LOW);
  analogWrite(L298N_F_ENA, MS); // Geschwindigkeit einstellen
  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() // Setzt die DC-Motoren so, dass sie sich mit der eingestellten "MS"-Geschwindigkeit rückwärts bewegen.
{
digitalWrite(L298N_F_IN1, LOW);
digitalWrite(L298N_F_IN2, HIGH);
digitalWrite(L298N_F_IN3, HIGH);
digitalWrite(L298N_F_IN4, LOW);
digitalWrite(L298N_M_IN1, LOW);
digitalWrite(L298N_M_IN2, HIGH);
digitalWrite(L298N_M_IN3, HIGH);
digitalWrite(L298N_M_IN4, LOW);
digitalWrite(L298N_R_IN1, HIGH);
digitalWrite(L298N_R_IN2, LOW);
digitalWrite(L298N_R_IN3, LOW);
digitalWrite(L298N_R_IN4, HIGH);
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() // Stoppen/Anhalten von DC-Motoren
{
analogWrite(L298N_F_ENA, 0);
analogWrite(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() // Drehe alle Servos nach vorne
{
servoLF.write(90);
servoRF.write(90);
servoLM.write(90);
servoRM.write(90);
servoLR.write(90);
servoRR.write(90);
delay(20); // Erlaubt dem Servo, dorthin zu gelangen.
)

void turnLeft() // Drehe die Servos, um eine Linkskurve zu machen
{
servoLF.write(60);
servoRF.write(60);
servoLM.write(90);
servoRM.write(90);
servoLR.write(120);
servoRR.write(120);
Verzögerung(20);
)

void turnRight() // Drehe alle Servos, um eine rechte Wendung zu machen
{
servoLF.write(120);
servoRF.write(120);
servoLM.write(90);
servoRM.write(90);
servoLR.write(60);
servoRR.write(60);
Verzögerung(20);
)

void doglegLeft() // Drehe alle Servos nach links im Dogleg-Stil
{
servoLF.write(60);
servoRF.write(60);
servoLM.write(60);
servoRM.write(60);
servoLR.write(60);
servoRR.write(60);
Verzögerung(20);
)

void doglegRight() // Drehe alle Servos nach rechts in einen Dogleg
{
servoLF.write(120);
servoRF.write(120);
servoLM.write(120);
servoRM.write(120);
servoLR.write(120);
servoRR.write(120);
Verzögerung(20);
)