Road-Train Dekoder für Beier SM-IR-16-2 mit Arduino

Racker

Hallo,

heute möchte ich euch den Roadtrain-Dekoder für das Beier SM-IR-16-2 vorstellen. Der Roadtrain Dekoder basiert auf dem SM-IR-16-2 Dekoder und nutzt die Ausgänge 13 und 14 zur Adressierung für 3 Anhänger/Auflieger („Trailer“).

Benötigt werden je Auflieger/Anhänger:

Beier Electronic SM-IR-16-2 Lichtmodul
Beier Electronic IR-RTA Road-Train-Adapter
Arduino Nano v3 (empfohlen)
Akku 6-12V
BEC (wenn Servos angeschlossen werden)
Platine „Die Schwarze“ (optional)

Der Roadtrain-Dekoder gibt bis zu 2 Schaltausgänge und 2 Servos des SM-IR-16 frei oder sperrt diese in Abhängigkeit von der adressierten ID, welche über den Sender mit den Funktionen „IR: Lauflicht“ (Trailer-ID 1) bzw. „IR: Blitzer/Blinker“ (Trailer-ID 2) ausgewählt wird. Trailer-ID 0 ist immer dann aktiv, wenn keine der beiden anderen IDs ausgewählt wurde.

Für Details zur Auswertung der beiden Ausgänge siehe den Link oben.

Die Schaltausgänge am SM-IR-16-2 müssen mit 100% Helligkeit geschaltet werden und werden entsprechend auch nur als HIGH oder LOW ausgegeben. Die beiden Schaltausgänge könnten z.B. für eine Umpolschaltung mit Relais zur Stützen- oder Rampensteuerung dienen, ein Servo für Bremse und ein Servo für Sattelplatte oder Kupplung.

Für die Servos stehen Ausgänge mit normalem und invertiertem Signal zur Verfügung (natürlich kann man den Sketch auch ändern um 2 Servos synchron zu betreiben).

Es müssen nicht alle Eingänge und damit nicht alle Ausgänge verschaltet werden, noch müssen die Schalt- oder Servosignale zwingend vom SM-IR-16-2 kommen.

Der Sketch ist für die Platine "Die Schwarze" gedacht, kann aber natürlich auch mit eigenen Platinen und anderer Pin-Konfiguration verwendet werden.

Zu beachten ist aber, das der 2. Steuereingang an D3 einen Hardware-Interrupt nutzt. Die PWM Signale für die Servos werden über Pin Change Interrupts an Pin A0 und A1 berechnet.

Über zwei Jumper/Lötbrücken (Pin A2 und A3) wird die Trailer-ID 0 bis 2 festgelegt, welche beim Start des Arduino einmalig eingelesen und kalkuliert wird. Die Trailer-ID is binär kodiert:

Beide Jumper offen = Trailer-ID 0

Jumper 1 geschlossen und Jumper 2 offen = Trailer-ID 1
Jumper 1 offen und Jumper 2 geschlossen = Trailer-ID 2
Jumper 1 geschlossen und Jumper 2 geschlossen = nicht erlaubt

Die Pins A2 und A3 sind als INPUT_PULLUP deklariert, ein geschlossener Jumper zieht den entsprechenden Eingang auf GND (Masse). Daher wird beim Einlesen der Zustand mit „!“ invertiert, somit ergibt „00“ = TrailerID 0, „01“ = TrailerID 1 und „10“ = TrailerID 2.

Die Trailer-ID wird mit der über das SM-IR-16-2 ausgegebenen ID verglichen um zu entscheiden, welcher Trailer freigeschaltet wird. Andere Trailer werden gesperrt.

Trailer-ID 0 ist immer aktiv, wenn keiner der beiden anderen Trailer ausgewählt ist. Wird z.B. Trailer-ID 1 ausgewählt, dann werden die Signale beim Trailer 1 freigeschaltet und bei Trailer 0 sowie 2 gesperrt. D.h. Änderungen für die Schaltausgänge und Servos werden in Trailer 0 und 2 nicht mehr weitergegeben, der vorherige Zustand bleibt erhalten.

Änderungen im Zustand der Schaltausgänge und der Servosignale bei gesperrten Trailern werden nach deren Aktivierung sofort weitergegeben. Es sollte also darauf geachtet werden, daß die Schaltausgänge und Servos sich im gewünschten Zustand bzw. der richtigen Position befinden bevor ein anderer Trailer adressiert wird, insbesondere bei Trailer 0 der durch Deaktivierung von Trailer 1 und 2 automatisch freigeschaltet wird.

Die externe LED ist mit der LED auf dem Arduino-Board an Pin D13 verbunden und zeigt die folgende Zustände an

... wenn kein Trailer adressiert wurde:

Sehr schnelles Blinken: Trailer-ID 0 / freigeschaltet
Schnelles Blinken: Trailer-ID 1
Doppel-Blinken: Trailer-ID 2

… wenn Trailer 1 oder 2 addressiert wurde:

An: Trailer-ID wurde ausgewählt / freigeschaltet
Aus: anderer Trailer ausgewählt / gesperrt

Die externe LED ist optional, je nach Einbau-Position reicht u.U. die LED auf dem Arduino-Board zur Anzeige aus; diese ist vielleicht auch weniger störend als eine zusätzliche LED.

Racker

Pin-Belegung des Arduino

A0 PWM-Eingang für Servo 1 (Pull-Down Widerstand empfohlen); Pin Change Interrupt

A1 PWM-Eingang für Servo 2 (Pull-Down Widerstand empfohlen); Pin Change Interrupt

A2 Eingang 1 (Lötbrücke) zur Einstellung der Trailer-ID

A3 Eingang 2 (Lötbrücke) zur Einstellung der Trailer-ID

D2 Steuereingang 1, verbunden mit SM-IR-16-2 Ausgang 13

D3 Steuereingang 2, verbunden mit SM-IR-16-2 Ausgang 14; Hardware Interrupt

D5 PWM-Ausgang Servo1a

D6 PWM-Ausgang Servo1b (invertiert zu 1a)

D7 Eingang 1 für Schaltausgang X vom SM-IR-16-2

D8 Eingang 2 für Schaltausgang Y vom SM-IR-16-2

D9 PWM-Ausgang Servo2a

D10 PWM-Ausgang Servo2b (invertiert zu 2a)

D11 Schaltausgang 1 (= X wenn freigeschaltet)

D12 Schaltausgang 2 (= Y wenn freigeschaltet)

D13 LED (optional, Vorwiderstand nötig)

Andere I/O Pins auf der Platine „Die Schwarze“ werden nicht benutzt, dementsprechend werden auch die Bauteile wie Taster oder Poti für den Road-Train Dekoder nicht benötigt.

Stromversorgung des Arduino

Bei Verwendung der Platine „Die Schwarze“ kann der Arduino wie folgt mit Strom versorgt werden:

Mit 5V der Servoausgänge des SM-IR-16-2 über A0 und/oder A1; in dem Fall sollten Servos am Arduino mit einem externen BEC (5-7,4V*) versorgt werden. Die Lötbrücke „5Ven“ darf dann nicht geschlossen werden!
Über Vin mit 7-12V; in dem Fall sollten Servos am Arduino mit einem externen BEC (5-7,4V*) versorgt werden. Die Lötbrücke „5Ven“ darf dann nicht geschlossen werden!
Über ein externes BEC mit exakt 5V am Anschluß „BEC“. Das BEC speist dann auch die Servos mit 5V. Die Lötbrücke „5Ven“ muß in dem Fall geschlossen werden. Die rote Ader der Kabel zwischen A0 / A1 und SM-IR-16-2 Servo-Ausgang 1 / 2 muß dann unbedingt aus dem Stecker gezogen und isoliert werden!

* Spannung abhängig von den verwendeten Servos

Verkabelung zwischen SM-IR-16-2 und Arduino

SMR-IR-16-2	Arduino	Kabel-Typ
Plus	5V	Über Servo-Patchkabel an X5/1 oder X5/2 *
Minus	GND	Über Servo-Patchkabel an X5/1 oder X5/2
Servo 1 (X5/1)	A0	Servo-Patchkabel
Servo 2 (X5/2)	A1	Servo-Patchkabel
Ausgang 13	D2	Schaltlitze einadrig **
Ausgang 14	D3	Schaltlitze einadrig **
Ausgang X	D7	Schaltlitze einadrig **
Ausgang Y	D8	Schaltlitze einadrig **

* Hinweise zur Stromversorgung des Arduino beachten!

** Servo-Kabel möglich: gelb/weiß D2 bzw. D7 - rot D3 bzw. D8 - braun/schwarz nicht belegt bzw. Minus wenn kein Kabel an A0 und A1.

Racker

Und hier der Sketch:

C

// Road-Train Dekoder für Beier SM-IR-16-2 IR Modul v1
//
// Dekodiert das Lichtmuster an Ausgang 13 und 14 und schaltet in Abhängigkeit
// von der Jumper-Einstellung "Trailer-ID" zwei Schaltausgänge und die Servos
// vom SM-IR-16-2 frei oder sperrt diese
//
// Trailer Auswahl über Funktion "IR: Blitzer/Blinker" und "IR: Lauftlicht"
// SM-IR-16-2 Ausgang 13 mit D2 und Ausgang 14 mit D3 verbinden
//
// v1 erste Version (basierend auf sketch_smir162_decoder_v4)
//
// Für Arduino UNO und NANO
// Letzte Änderung 24.11.2021

#include <Servo.h>                                // Servo-Bibliothek laden

Servo Servo1a;                                    // Servo-Objekt 1a anlegen
Servo Servo1b;                                    // Servo-Objekt 1b anlegen
Servo Servo2a;                                    // Servo-Objekt 2a anlegen
Servo Servo2b;                                    // Servo-Objekt 2b anlegen

byte ZaehlerB = 1;                                // Zaehler für LEDblink()
byte Zaehler1 = 0;                                // Zaehler für Trailer 1 Erkennung
byte Zaehler2 = 0;                                // Zaehler für Trailer 2 Erkennung

byte TRID1 = 1;                                   // Variable zum Einlesen Trailer-Identifikation 1 über JumperTRID1
byte TRID2 = 1;                                   // Variable zum Einlesen Trailer-Identifikation 2 über JumperTRID2
byte TRAW1 = 1;                                   // Variable für Trailer-Auswahl 1 über EingangTRAW1
byte TRAW2 = 1;                                   // Variable für Trailer-Auswahl 2 über EingangTRAW2

byte TrailerID = 0;                               // Trailer Identifikation (0-2) aus TRID1 und TRID2
byte AuswahlID = 0;                               // Ausgewählte Trailer-ID (0-2) aus TRAW1 und TRAW2

const byte Zaehler1min = 10;                      // Mindestanzahl von Wiederholungen für Trailer 1 (typ. 10)
const byte Zaehler2min = 20;                      // Mindestanzahl von Wiederholungen für Trailer 2 (typ. 20)

const byte Servo1PinA = 5;                        // PWM-Pin für Servo 1 (D5)
const byte Servo1PinB = 6;                        // PWM-Pin für Servo 1 invertiert (D6)
const byte Servo2PinA = 9;                        // PWM-Pin für Servo 2 (D9)
const byte Servo2PinB = 10;                       // PWM-Pin für Servo 2 invertiert (D10)
const byte EingangPWM1 = A0;                      // PWM Eingang für Servo 1 (mit Pull-Down Widerstand) (A0)
const byte EingangPWM2 = A1;                      // PWM Eingang für Servo 2 (mit Pull-Down Widerstand) (A1)
const byte JumperTRID1 = A2;                      // Eingang für Trailer-ID Kodierung 1 (A2)
const byte JumperTRID2 = A3;                      // Eingang für Trailer-ID Kodierung 2 (A3)

const byte EingangTRAW1 = 2;                      // Eingang Trailer-Auswahl 1 für SM-IR-16-2 Ausgang 13 (D2)
const byte EingangTRAW2 = 3;                      // Eingang Trailer-Auswahl 2 für SM-IR-16-2 Ausgang 14 (D3)
const byte EingangDIGI1 = 7;                      // Eingang für geschaltetes Signal 1 (D7)
const byte EingangDIGI2 = 8;                      // Eingang für geschaltetes Signal 2 (D8)
const byte AusgangDIGI1 = 11;                     // Ausgang für geschaltetes Signal 1 (D11)
const byte AusgangDIGI2 = 12;                     // Ausgang für geschaltetes Signal 2 (D12)

const byte LED = LED_BUILTIN;                     // Interne LED an Ausgang 13

word ZeitInterval = 500;                          // Variable zur Berechnung Zeitinterval für LED Blinken
word ZeitIntervalA = 500;                         // Haltezeit in ms (500-1000, typ. 500)
word ZeitIntervalB = 500;                         // Zeitinterval für LED Blinken in ms (0-65 535, typ. 500)

word PWMausS1;                                    // Variable zur Berechnung PWM Signal Servo 1 in µs
word PWMausS2;                                    // Variable zur Berechnung PWM Signal Servo 2 in µs

const word PWMeinS1min = 700;                     // Untere Grenze des Eingang-Signals für Servo 1 in µs (500 bis 1000)
const word PWMeinS1max = 2300;                    // Obere Grenze des Eingang-Signals für Servo 1 in µs (2000 bis 2500)
const word PWMeinS2min = 700;                     // Untere Grenze des Eingang-Signals für Servo 2 in µs (500 oder 1000)
const word PWMeinS2max = 2300;                    // Obere Grenze des Eingang-Signals für Servo 2 in µs (2000 oder 2500)
const word PWMausS1min = 700;                     // Minimum Impulslänge Servo1 bei Drehung Links (>= 544 und < 1500)
const word PWMausS1max = 2300;                    // Maximum Impulslänge Servo1 bei Drehung Rechts (> 1500 und <= 2500)
const word PWMausS2min = 700;                     // Minimum Impulslänge Servo2 bei Drehung Links (>= 544 und < 1500)
const word PWMausS2max = 2300;                    // Maximum Impulslänge Servo2 bei Drehung Rechts (> 1500 und <= 2500)

unsigned long vorherigeZeitA = 0;                 // Vorherige Zeit für Prüfung der Trailer Auswahl
unsigned long vorherigeZeitB = 0;                 // Vorherige Zeit für LED Blinken

unsigned long timer[4];
byte last_channel[4];
int PWMein[4];

void setup() {
  Serial.begin(2000000);

  // Servo-Objekte mit Pin verbinden
  Servo1a.attach(Servo1PinA);
  Servo1b.attach(Servo1PinB);
  Servo2a.attach(Servo2PinA);
  Servo2b.attach(Servo2PinB);

  // Pins als Ein- oder Ausgang deklarieren
  pinMode(EingangPWM1, INPUT);
  pinMode(EingangPWM2, INPUT);

  pinMode(EingangTRAW1, INPUT_PULLUP);
  pinMode(EingangTRAW2, INPUT_PULLUP);
  pinMode(EingangDIGI1, INPUT_PULLUP);
  pinMode(EingangDIGI2, INPUT_PULLUP);

  pinMode(JumperTRID1, INPUT_PULLUP);
  pinMode(JumperTRID2, INPUT_PULLUP);

  pinMode(AusgangDIGI1, OUTPUT);
  pinMode(AusgangDIGI2, OUTPUT);
  pinMode(LED, OUTPUT);

  // Hardware Interrupt für Pin D3
  EIFR = 1;
  attachInterrupt(digitalPinToInterrupt(EingangTRAW2), hwinterrupt, FALLING);

  // Pin Change Interrupt für Pin A0 und A1 (PWM Eingänge)
  PCMSK1 |= (1 << PCINT8);                                  // Interrupt8 = Pin A0
  PCMSK1 |= (1 << PCINT9);                                  // Interrupt9 = Pin A1
  PCIFR |= (1 << PCIF1);                                    // Interrupts löschen
  PCICR |= (1 << PCIE1);                                    // Pin Change Interrupt einschalten

  // Jumper (Lötbrücken) an A2/A3 sowie A4/A5 einlesen und auswerten
  TRID1 = !digitalRead(JumperTRID1);
  TRID2 = !digitalRead(JumperTRID2);

  Serial.print("TRID1:  ");
  Serial.print(TRID1);
  delay(10);
  Serial.print("   TRID2:  ");
  Serial.print(TRID2);
  delay(10);

  if (TRID1 == 0 && TRID2 == 0) {
    TrailerID = 0;
  } else if (TRID1 == 1 && TRID2 == 0) {
    TrailerID = 1;
  } else if (TRID1 == 0 && TRID2 == 1) {
    TrailerID = 2;
  }

  Serial.print("   -> TrailerID:  ");
  Serial.println(TrailerID);

  digitalWrite(LED, LOW);
  digitalWrite(AusgangDIGI1, HIGH);
  digitalWrite(AusgangDIGI2, HIGH);

  delay(100);
}

void loop() {

  if (TRAW1 == 1 && TRAW2 == 0) {
    TRAWlesen();
    Zaehler1++;
    if (Zaehler1 == Zaehler1min) {
      AuswahlID = 1;
      Zaehler1 = 0;
      Zaehler2 = 0;
      Zeitaktualisierung();
    }
  }

  if (TRAW1 == 0 && TRAW2 == 0) {
    TRAWlesen();
    Zaehler2++;
    if (Zaehler2 == Zaehler2min) {
      AuswahlID = 2;
      Zaehler1 = 0;
      Zaehler2 = 0;
      Zeitaktualisierung();
    }
  }

  Zeitpruefen();

  if (AuswahlID == 0) {
    LEDblink();
  }

  if (AuswahlID == TrailerID) {
    if (AuswahlID != 0) {
    digitalWrite(LED, HIGH);
    }
    SchaltAusgang1();
    SchaltAusgang2();
    Servo1Position();
    Servo2Position();
  }
}

void hwinterrupt() {
  noInterrupts();
  TRAWlesen();
  EIFR = 1;
  interrupts();
}

ISR(PCINT1_vect) {
  timer[0] = micros();

  // Kanal 1 (A0) ----------------
  if (last_channel[0] == 0 && PINC & B00000001) {
    last_channel[0] = 1;
    timer[1] = timer[0];
  }
  else if (last_channel[0] == 1 && !(PINC & B00000001) ) {
    last_channel[0] = 0;
    PWMein[0] = timer[0] - timer[1];
  }

  // Kanal 2 (A1) ----------------
  if (last_channel[1] == 0 && PINC & B00000010) {
    last_channel[1] = 1;
    timer[2] = timer[0];
  }
  else if (last_channel[1] == 1 && !(PINC & B00000010) ) {
    last_channel[1] = 0;
    PWMein[1] = timer[0] - timer[2];
  }
}

void TRAWlesen() {
  TRAW1 = digitalRead(EingangTRAW1);
  TRAW2 = digitalRead(EingangTRAW2);
}

void SchaltAusgang1() {
  digitalWrite(AusgangDIGI1, digitalRead(EingangDIGI1));
}

void SchaltAusgang2() {
  digitalWrite(AusgangDIGI2, digitalRead(EingangDIGI2));
}

void Servo1Position() {

  if (PWMein[0] > 0)  {
    if ((PWMein[0] >= PWMeinS1min) && (PWMein[0] <= PWMeinS1max)) {
      PWMausS1 = map(PWMein[0], PWMeinS1min, PWMeinS1max, PWMausS1min, PWMausS1max);
      Servo1a.writeMicroseconds(PWMausS1);
      PWMausS1 = map(PWMein[0], PWMeinS1min, PWMeinS1max, PWMausS1max, PWMausS1min);
      Servo1b.writeMicroseconds(PWMausS1);
    }
    else if (PWMein[0] < PWMeinS1min) {
      Servo1a.writeMicroseconds(PWMausS1min);
      Servo1b.writeMicroseconds(PWMausS1max);
    }

    else if (PWMein[0] > PWMeinS1max) {
      Servo1a.writeMicroseconds(PWMausS1max);
      Servo1b.writeMicroseconds(PWMausS1min);
    }
  }
}

void Servo2Position() {

  if (PWMein[1] > 0)  {
    if ((PWMein[1] >= PWMeinS2min) && (PWMein[1] <= PWMeinS2max)) {
      PWMausS2 = map(PWMein[1], PWMeinS2min, PWMeinS2max, PWMausS2min, PWMausS2max);
      Servo2a.writeMicroseconds(PWMausS2);
      PWMausS2 = map(PWMein[1], PWMeinS2min, PWMeinS2max, PWMausS2max, PWMausS2min);
      Servo2b.writeMicroseconds(PWMausS2);
    }
    else if (PWMein[1] < PWMeinS2min) {
      Servo2a.writeMicroseconds(PWMausS2min);
      Servo2b.writeMicroseconds(PWMausS2max);
    }

    else if (PWMein[1] > PWMeinS2max) {
      Servo2a.writeMicroseconds(PWMausS2max);
      Servo2b.writeMicroseconds(PWMausS2min);
    }
  }
}

void Zeitaktualisierung() {

  unsigned long aktuelleZeitA;
  aktuelleZeitA = millis();
  vorherigeZeitA = aktuelleZeitA;
}

void Zeitpruefen() {

  unsigned long aktuelleZeitA;

  aktuelleZeitA = millis();

  if (aktuelleZeitA - vorherigeZeitA >= ZeitIntervalA) {

    vorherigeZeitA = aktuelleZeitA;
    AuswahlID = 0;
    digitalWrite(LED, LOW);

  }
  else {
    //    Serial.println("ZEIT läuft   ");
  }
}

void LEDblink() {

  unsigned long aktuelleZeitB = millis();

  if (aktuelleZeitB - vorherigeZeitB >= ZeitInterval) {
    digitalWrite(LED, HIGH);
    delay(50);

    if (ZaehlerB < TrailerID) {

      vorherigeZeitB = aktuelleZeitB;
      ZeitInterval = ZeitIntervalB;
      ZaehlerB++;
    }

    else {
      ZaehlerB = 1;
      vorherigeZeitB = aktuelleZeitB;
      if (TrailerID == 0) {
        return;
      }
      ZeitInterval = ZeitIntervalB + ZeitIntervalB;
    }
  }

  else {
    digitalWrite(LED, LOW);
  }
}

Alles anzeigen

gismow

Moin Reiner,

da steckt ja eniges an Gehirnschmalz drin. Ich habe für meine Roadtrain Ansteuerung 2 Lichtausgänge genutzt, so konnte ich alle 4 Trailer bzw. den Dolly realisieren.

Das Modul in den Trailern bietet noch 2 Servoausgänge, einer für ein propertionales Signal (z. B. Stützen) und ein Ausgang der nur auf/zu kennt (z. B. für eine Sattelplatte oder ein Zugmaul). Neben diesen Trailer ID Kanälen werte ich noch einen Servokanal (Proportionalkanal) aus. Wird er einmal kurz nach oben getippt, dann schaltet der "Auf/Zu" Servo in die andere Position. Wird der kanal länger als 750 ms aus dem Nullbereich hinaus bewegt, dann wird dieses Servosignal an den Proportionalkanal des Trailers durchgeschleift, die Stützen fahren hoch bzw. runter.

Im Gegensatz zu deiner Lösung gehen mir zwar 2 Lichtausgänge verloren, aber dafür ist die Auswertung um ein Vielfaches einfacher und es würde auch z. B. an den neuen Trailermodulen funktionieren.

Hut ab vor dem was du da mit deinen Platinen geschaffen hast.

Racker

Hallo Peter,

vielen Dank. Die Idee ist schon etwas älter und ich wollte den Dekoder erst aus Hardware bauen (ein paar Logik-Gatter, retriggerbare Monoflops und Transitorstufen für die Schaltausgänge), aber dann überlegt, daß es mit dem Arduino wohl einfacher und flexibler ist. Mit der Hardware-Lösung wäre ich wahrscheinlich auch wegen der kurzen, unerwünschten Signale auf die Nase gefallen - das Auge kann halt nicht so schnell sehen, wie der Arduino die Steuereingänge einliest ...

Ich hatte vor einiger Zeit über deine Lösung schon mal was gelesen aber damals nicht registriert, das du das Servosignal des Lichtmoduls auswertest und den Arduino das Servo direkt steuern lässt statt nur das Signal durchzuschalten - dabei ist die Idee so offensichtlich wie genial. Danke für den Denkanstoß, das birgt ungeahnte Möglichkeiten!

Im Dolly baue ich ein LM-16-IR-4 ein, dort werde ich die Sattelplatte über Servo 3 oder 4 betätigen. Somit bin ich von der Roadtrain-Konfiguration unabhängig, d.h. die Betätigung von Servo 1 oder 2 hat dann keinen Einfluß auf den Dolly und eine RT-Adressierung des LM selbst ist dann auch nicht nötig, da die SM-IR-16-2 Module die Signale für Servo 3 und 4 immer ignorieren. Außerdem ist der Platz etwas knapp, meiner hat nur 2 Achsen, und die Beleuchtung sorgt schon für genügend Kabelsalat.

Road-Train Dekoder für Beier SM-IR-16-2 mit Arduino

Jetzt mitmachen!

Tags