Lösungen

// Bibliothek LedControl einbinden
#include "LedControl.h"

/*
   Pinbelegung
   VCC -> 5V
   GND
   Pin 12 -> DATA IN-pin
   Pin 11 -> CLK-pin
   Pin 10 -> CS-pin
*/

LedControl LEDMatrix = LedControl(12, 11, 10, 1);
int Zeit = 50;

void setup()
{
  // Matrix "aufwecken"
  LEDMatrix.shutdown(0, false);

  //  mittlere Helligkeit setzen
  LEDMatrix.setIntensity(0, 2);
}

void loop()
{
  /*
    setRow/setColumn erwartet drei Parameter:
    - die Addresse der LED-Matrix ⇒  0
    - die Angabe der Zeile
    - den Wert der LED 1 = an, 0 = aus
  */

  // spaltenweise
  for (int i = 0; i < 7; i++)
  {
    // alle an
    LEDMatrix.setColumn(0, i, B11111111);
    delay(100);
    // alle aus
    LEDMatrix.setColumn(0, i, B00000000);
    delay(100);
  }

  // und zurück
  for (int i = 7; i >= 0; i--)
  {
    // alle an
    LEDMatrix.setColumn(0, i, B11111111);
    delay(100);
    // alle aus
    LEDMatrix.setColumn(0, i, B00000000);
    delay(100);
  }

  // zeilenweise
  for (int i = 0; i < 7; i++)
  {
    // alle an
    LEDMatrix.setRow(0, i, B11111111);
    delay(100);

    // alle aus
    LEDMatrix.setRow(0, i, B00000000);
    delay(100);
  }

  // und zurück
  for (int i = 7; i >= 0; i--)
  {
    // alle an
    LEDMatrix.setRow(0, i, B11111111);
    delay(100);

    // alle aus
    LEDMatrix.setRow(0, i, B00000000);
    delay(100);
  }
}

Letzte Aktualisierung:

byte Zahlen[10] =
{
  B11101011, // 9
  B11101111, // 8
  B11100000, // 7
  B10101111, // 6
  B10101011, // 5
  B01100011, // 4
  B11101001, // 3
  B11001101, // 2
  B01100000, // 1
  B11101110, // 0
};

int TASTER = 13;
int LAUTSPRECHER = 10;

int Minimum = 500;
int Maximum = 2000;

void setup()
{
  // Pins auf OUTPUT setzen
  for (int i = 2; i <= 9; i++)
  {
    pinMode(i, OUTPUT);
  }

  Serial.begin(9600);
  pinMode(TASTER, INPUT_PULLUP);

  // Zufallsgenerator starten
  randomSeed(analogRead(A0));

  // A (B11100111) anzeigen
  ZahlZeigen(B11100111);
}

void loop()
{
  int TasterLesen = digitalRead(TASTER);
  if (!TasterLesen)
  {
    for (int i = 0; i <= sizeof(Zahlen) - 1; i++)
    {
      // aktuelles Array i (Zahlen als Bytes) an Funktion ZahlZeigen übergeben
      ZahlZeigen(Zahlen[i]);
      tone(LAUTSPRECHER, 1000, 10);
      delay(1000);
    }

    // Countdown abgelaufen
    // zufällige Tonfolge spielen
    for (int i = 0; i < 10; i++)
    {
      tone(LAUTSPRECHER, random(Minimum, Maximum), 500);
      delay(200);
    }

    // A (B11100111) anzeigen
    ZahlZeigen(B11100111);

  }
}

void ZahlZeigen(byte ArrayZahl)
{
  // aktuelles Byte anzeigen
  Serial.println(ArrayZahl, BIN);

  // Bits des Arrays ArrayZahl prüfen
  for (int i = 2; i <= 9; i++)
  {
    /*
      vergleicht das Byte ArrayZahl mit dem Byte B10000000
      befindet sich an beiden Positionen eine 1
      das Ergebnis der Prüfung ist also nicht 0
      -> Segment einschalten
      ist eine der Positionen eine 0
      das Ergebnis der Prüfung ist 0
      -> Segment ausschalten
      1 Bit nach links schieben -> nächstes Bit prüfen
      nach 8 Durchläufen sind alle Segmente richtig geschaltet
    */
    if ((ArrayZahl & B10000000) != 0) digitalWrite(i, HIGH);
    else  digitalWrite(i, LOW);

    ArrayZahl = ArrayZahl << 1;
  }
}

Letzte Aktualisierung:

#include "SoftwareSerial.h"

// TX -> 2, RX -> 3
SoftwareSerial BTSerial(2, 3);

int LED[5] = {4, 5, 6, 7, 8};

// über Bluetooth vom Smartphone gesendeter Wert
char btDaten;

void setup()
{
  BTSerial.begin(9600);
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // pinMode LEDs
  for (int i = 0; i <= 4; i++)
  {
    pinMode(LED[i], OUTPUT);
  }

  // Menü im Seriellen Monitor
  Serial.println("Men\u00fc:");
  Serial.println("1 -> Lauflicht vor");
  Serial.println("2 -> Lauflicht zur\u00fcck");
  Serial.println("3 -> alle an");
  Serial.println("4 -> blinkende LEDs");
  Serial.println("8 -> alle aus");
}

void loop()
{
  // vom Smartphone gesendeten Wert lesen
  btDaten = BTSerial.read();

  switch (btDaten)
  {
    case '1':
    {
      BTSerial.println("Lauflicht rechts");
      BTSerial.println("Neue Aktion: 8 -> alle aus");

      // Status true übergeben
      LauflichtVor(true);
      break;
    }
    
    case '2':
    {
      BTSerial.println("Lauflicht links");
      BTSerial.println("Neue Aktion: 8 -> alle aus");

      // Status true übergeben
      LauflichtZurueck(true);
      break;
    }
    
    case '3':
    {
      BTSerial.println("alle an");
      BTSerial.println("Neue Aktion: 8 -> alle aus");

      AlleLEDAus();
      AlleLEDAn();
      break;
    }
    case '4':
    {
      BTSerial.println("alle blinken");
      BTSerial.println("Neue Aktion: 8 -> alle aus");
      
      // Status true übergeben
      LEDBlinken(true);
      break;
    }

    case '8':
    {
      BTSerial.println("alle aus");
      AlleLEDAus();
      break;
    }
  }
}

void LauflichtVor(bool Status)
{
  // Status ist true
  while (Status)
  {
    for (int i = 0; i <= 4; i++)
    {
      /*
        Eingabe Smartphone abfragen
        wenn Wert 8 (ausschalten):
        -> for-Schleife unterbrechen
        -> Status auf false setzen,
        -> while wird unterbrochen
      */
      btDaten = BTSerial.read();

      if (btDaten == '8')
      {
        Status = !Status;
        BTSerial.println("alle aus");
        AlleLEDAus();
        break;
      }

      // aktuelle LED i einschalten
      digitalWrite(LED[i], HIGH);
      delay(100);
      
      // aktuelle LED i ausschalten
      digitalWrite(LED[i], LOW);
    }
  }
}

void LauflichtZurueck(bool Status)
{
  // Status ist true
  while (Status)
  {
    for (int i = 4; i >= 0; i --)
    {
      btDaten = BTSerial.read();
      if (btDaten == '8')
      {
        Status = !Status;
        BTSerial.println("alle aus");
        AlleLEDAus();
        break;
      }

      // aktuelle LED i einschalten
      digitalWrite(LED[i], HIGH);
      delay(100);

      // aktuelle LED i ausschalten
      digitalWrite(LED[i], LOW);
    }
  }
}

void AlleLEDAn()
{
  for (int i = 0; i <= 4; i++)
  {
    // aktuelle LED i einschalten
    digitalWrite(LED[i], HIGH);
  }
}

void LEDBlinken(bool Status)
{
  // Status ist true
  while (Status)
  {
    for (int i = 0; i <= 4; i++)
    {
      btDaten = BTSerial.read();
      if (btDaten == '8')
      {
        Status = !Status;
        BTSerial.println("alle aus");
        AlleLEDAus();
        break;
      }

      // aktuelle LED i einschalten
      digitalWrite(LED[i], HIGH);
    }
    delay(100);

    for (int i = 0; i <= 4; i++)
    {
      btDaten = BTSerial.read();
      if (btDaten == '8')
      {
        Status = !Status;
        BTSerial.println("alle aus");
        AlleLEDAus();
        break;
      }

      // aktuelle LED i ausschalten
      digitalWrite(LED[i], LOW);
    }
    delay(100);
  }
}

void AlleLEDAus()
{
  for (int i = 0; i <= 4; i++)
  {
    // aktuelle LED i ausschalten
    digitalWrite(LED[i], LOW);
  }
}

Letzte Aktualisierung:

#include "Servo.h"
#include "LiquidCrystal_I2C.h"
#include "Bounce2.h"

LiquidCrystal_I2C lcd(0x27, 20, 4);

// Bezeichnung des Motors
Servo Motor;

int TASTER = 7;

/*
  das LCD ist auf 20 Zeichen begrenzt
  um einen unerwünschten Zeilenumbruch zu verhindern,
  müssen für die Fragen zwei Arrays erstellt werden
*/

// 1. Zeile der Frage
String FragenErstezeile[10] = 
{
  // mit Leerzeichen bis 20 auffüllen
  { "Wird der BVB        " },
  { "Scheint morgen      " },
  { "Wird Deutschland    " },
  { "Habe ich 6 Richtige " },
  { "Gibt es den         " },
  { "Gibt es UFOs und    " },
  { "Sollte ich mal      " },
  { "Bekomme ich bald    " },
  { "K\357nnen Schweine     " },
  { "Wird es morgen      " },
};

// 2. Zeile der Frage
String FragenZweiteZeile[10] = 
{
  { "Deutscher Meister?   " },
  { "die Sonne?           " },
  { "Fu\342ball-Weltmeister?" },
  { "im Lotto?            " },
  { "Weihnachtsmann?      " },
  { "Au\342erirdische?      " },
  { "Lotto spielen?       " },
  { "mehr Gehalt?          " },
  { "fliegen?             " },
  { "regnen?              " },
};

// Bibliothek Bounce2
// "Prellverhinderer" für den Taster starten
Bounce Start = Bounce();

void setup() 
{
  // Motor an Pin 9 angeschlossen (attach)
  Motor.attach(9);
  Serial.begin(9600);

  // Motor in die Mittelposition fahren
  Motor.write(90);

  // Zufallsgenerator starten
  randomSeed(analogRead(A0));

  // LCD starten
  lcd.init();
  lcd.backlight();
  
  pinMode(TASTER, INPUT_PULLUP);

  // Instanz des Objekts Bounce für den Taster zuordnen
  // Zeitintervall einstellen
  Start.attach(TASTER);
  Start.interval(20);
}

void loop() 
{
  // Taster abfragen
  if (Start.update()) 
  {
    if (Start.read() == LOW) 
    {
      // Zufallszahl zwischen 0 und der Länge des Arrays
      int Zahl = random(0, sizeof(FragenErstezeile) / sizeof(FragenErstezeile[0]));
      Serial.println(Zahl);

      lcd.setCursor(0, 0);
      lcd.print(FragenErstezeile[Zahl]);
      
      lcd.setCursor(0, 1);
      lcd.print(FragenZweiteZeile[Zahl]);
      delay(1000);

      // Bewegung des Motors zur Simulation der "Entscheidung"
      Motor.write(180);
      delay(500);
      Motor.write(0);
      delay(500);

      // 0 = ja/1 = vielleicht/2 = nein
      Zahl = random(0, 3);
      Serial.println(Zahl);
      if (Zahl == 0) Motor.write(180);
      if (Zahl == 1) Motor.write(90);
      if (Zahl == 2) Motor.write(0);
    }
  }
}

Letzte Aktualisierung:

#include "Stepper.h"
#include "LiquidCrystal_I2C.h"
#include "Bounce2.h"

LiquidCrystal_I2C lcd(0x27, 20, 4);

// Schritte pro Umdrehung.
int SchritteDrehung = 2048;

/*
 Zuordnung der Pins
  entweder 4, 6, 5, 7
  oder 5, 7, 4, 6
  diejenige auswählen, bei der die Drehung
  im Uhrzeigersinn ausgeführt wird
*/
Stepper Motor(SchritteDrehung, 4, 6, 5, 7);
int TASTER = 10;

// die Farben
int Rot = 0;
int Blau = 0;
int Gelb = 0;
int Gruen = 0;

// Bibliothek Bounce2
// "Prellverhinderer" für den Taster starten
Bounce Start = Bounce();

void setup()
{
  // Instanz des Objekts Bounce dem Taster zuordnen
  // Zeitintervall einstellen
  Start.attach(TASTER);
  Start.interval(20);

  pinMode(TASTER, INPUT_PULLUP);

  // LCD einschalten
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Gl\365cksrad");

  // Zufallsgenerator starten
  randomSeed(analogRead(A0));

  // Geschwindigkeit des Motors
  Motor.setSpeed(15);
}

void loop()
{
  // Taster gedrückt
  if (Start.update())
  {
    if (Start.read() == LOW)
    {
      int Minimum = 1;
      int Maximum = SchritteDrehung;
      int Position =  random(Minimum, Maximum);

      // Motor auf zufällige Position fahren
      Motor.step(Position);

      // Ergebnis auf LCD anzeigen
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Position: " + String(Position));
      lcd.setCursor(0, 1);

      // Farbe je nach Position bestimmen
      if (Position > 0 && Position < 512)
      {
        lcd.print("Gelb");
        Gelb ++;
      }

      if (Position > 512 && Position < 1024)
      {
        lcd.print("Gr\365n:");
        Gruen ++;
      }

      if (Position > 1024 && Position < 1536)
      {
        lcd.print("Rot:");
        Rot ++;
      }

      if (Position > 1536 && Position < 2048)
      {
        lcd.print("Blau");
        Blau ++;
      }

      // Statistik anzeigen
      lcd.setCursor(0, 2);
      lcd.print("Rot:  " + String(Rot));
      lcd.setCursor(10, 2);
      lcd.print("Blau: " + String(Blau));
      lcd.setCursor(0, 3);
      lcd.print("Gelb: " + String(Gelb));
      lcd.setCursor(10, 3);
      lcd.print("Gr\365n: " + String(Gruen));
      delay(1000);

      // Motor an den Ausgangspunkt zurückfahren
      Motor.step(-Position);
    }
  }
}

// Array für die Artikel vor dem Substantiv und das Substantiv
// jeweils 6 Elemente -> Zählung beginnt mit 0
String Artikel_Substantiv [6] [6] =
{
  {"Der ", "Das ", "Die ", "Das ", "Das ", "Der "},
  {"Bus ", "Auto ", "U-Bahn ", "Fahrrad ", "Motorrad ", "Lastwagen "},
};

// eindimensionales Array für die Eigenschaften
String Eigenschaft [6] = {"rasant ", "im Zeitlupentempo ", "schnell ", "langsam ", "zügig ", "im Schritttempo "};

// Array für Verb und das Objekt
String Verb_Objekt [6] [6] =
{
  {"rollt ", "saust ", "rast ", "schleicht ", "fährt ", "bummelt "},
  {"auf die Autobahn. ", "ans Ende der Welt.", "um die Ecke.", "zum Bahnhof.", "zur Haltestelle.", "in die Garage."}
};

// Bereich der zufällig erzeugten Zahlen
int Minimum = 0;
int Maximum = 6;

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

  // auf serielle Verbindung warten
  while (!Serial) {;}
  delay(500);
  Serial.println("s = neuer Satz");
}

void loop()
{
 // auf serielle Eingabe warten 
  while (Serial.available() > 0)  
  {  
    // Eingabe im Seriellen Monitor lesen 
    char Zeichen = Serial.read();

    // wenn s eingegeben wurde
    if (Zeichen == 's')
    {
      int Position =  random(Minimum, Maximum);
      
      /*
        Bestimmung des Artikels und des Substantivs 
        entsprechend der Position im Array Artikel_Substantiv
        0 -> Artikel
        1 -> Substantiv
      */
      Serial.print(Artikel_Substantiv[0] [Position]);
      Serial.print(Artikel_Substantiv[1] [Position]);
      
      // Bestimmung des Verbs -> Position 0 im Array Verb_Objekt
      Position =  random(Minimum, Maximum);
      Serial.print(Verb_Objekt[0] [Position]);
      
      // Festlegung der Eigenschaft
      Position =  random(Minimum, Maximum);
      Serial.print(Eigenschaft[Position]);

      // Objekt auswählen -> Position 1 im Array Verb_Objekt
      Position =  random(Minimum, Maximum);
      Serial.println(Verb_Objekt[1] [Position]);
    }
  }
}

#include "Bounce2.h"
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd(0x27, 20, 4);

struct Laenderdaten
{
  String Name;
  float Einwohner;
  long Groesse;
  String Hauptstadt;
};

Laenderdaten Deutschland =
{
  "Deutschland",
  83.01,
  357578,
  "Berlin"
};

Laenderdaten Frankreich =
{
  "Frankreich",
  66.99,
  543965,
  "Paris"
};

Laenderdaten Belgien =
{
  "Belgien",
  11.37,
  30688,
  "Br\365ssel"
};

Laenderdaten Niederlande =
{
  "Niederlande",
  17.29,
  41543,
  "Amsterdam"
};

/*
  Anschlüsse von links nach rechts
  GND D4 D5 D7 D6
*/
int TASTER1 = 5;  // Taste 1
int TASTER2 = 4;  // Taste 2
int TASTER3 = 7;  // Taste 3
int TASTER4 = 6;  // Taste 4

// Bibliothek Bounce2
// "Prellverhinderer" für die Tasten starten
Bounce Land1 = Bounce();
Bounce Land2 = Bounce();
Bounce Land3 = Bounce();
Bounce Land4 = Bounce();


void setup()
{
  // Instanzen des Objekts Bounce für jede Taste zuordnen
  // Zeitintervall einstellen
  Land1.attach(TASTER1);
  Land1.interval(20);
  Land2.attach(TASTER2);
  Land2.interval(20);
  Land3.attach(TASTER3);
  Land3.interval(20);
  Land4.attach(TASTER4);
  Land4.interval(20);

  // INPUT_PULLUP -> Eingangspegel auf HIGH setzen
  pinMode(TASTER1, INPUT_PULLUP);
  pinMode(TASTER2, INPUT_PULLUP);
  pinMode(TASTER3, INPUT_PULLUP);
  pinMode(TASTER4, INPUT_PULLUP);

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("1 = Deutschland");
  lcd.setCursor(0, 1);
  lcd.print("2 = Frankreich");
  lcd.setCursor(0, 2);
  lcd.print("3 = Belgien");
  lcd.setCursor(0, 3);
  lcd.print("4 = Niederlande");
}

void loop()
{
  // Taste 1 gedrückt
  if (Land1.update())
  {
    if (Land1.read() == LOW)
    {
      ZeigeDaten(Deutschland);
    }
  }

  // Taste 2 gedrückt
  if (Land2.update())
  {
    if (Land2.read() == LOW)
    {
      ZeigeDaten(Frankreich);
    }
  }
  
  if (Land3.update())
  {
    if (Land3.read() == LOW)
    {
      ZeigeDaten(Belgien);
    }
  }
  
  if (Land4.update())
  {
    if (Land4.read() == LOW)
    {
      ZeigeDaten(Niederlande);
    }
  }
}

void ZeigeDaten(struct Laenderdaten Land)
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(Land.Name);

  // bei der Einwohnerzahl . durch , ersetzen
  String Einwohner =  String(Land.Einwohner);
  Einwohner.replace(".", ",");
  lcd.setCursor(0, 1);

  lcd.print(Einwohner + " Millionen");
  lcd.setCursor(0, 2);

  lcd.print("Fl\341che " + String(Land.Groesse) + " qkm");
  lcd.setCursor(0, 3);

  lcd.print("Hauptstadt " );
  lcd.print(Land.Hauptstadt);
  lcd.setCursor(0, 0);
}

Letzte Aktualisierung:

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

  // auf serielle Verbindung warten
  while (!Serial) {;}

  Serial.println("Eingabe der Zahlen:");
  Serial.println("Zahlenraum,minimaler-maximaler Teiler:");
  Serial.println("Beispiel: 100,15-19");
  Serial.println("Zahlenraum muss < 500 sein!");
  Serial.println("---------------------------------------------------");
}

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // solange lesen, bis return eingegeben wurde
    String Eingabe = Serial.readStringUntil('\n');

    // das letzte Zeichen ist return -> soll entfernt werden
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // das Komma suchen
    int SucheKomma = Eingabe.indexOf(",");

    // in der Eingabe fehlt das Komma
    if (SucheKomma == -1) Serial.println("Komma fehlt!");
    else
    {
      // String nach dem Komma -> Teiler Min/Max bestimmen
      int SucheMinus = Eingabe.indexOf("-");

      // Eingabe der Teiler ist unvollständig
      if (SucheMinus == -1) Serial.println("Festlegung der Teiler fehlt!");
      else
      {
        // String bis zum Komma -> Festlegung des Zahlenraums
        String ZahlenRaum = Eingabe.substring(0, SucheKomma);

        // Zählung des Arrays beginnt mit 0
        // -> Array muss um 1 größer als die gewünschte Zahl sein
        int ZahlMax = ZahlenRaum.toInt() + 1;

        // verhindern, dass Zahlen >500 eingegeben werden
        if (ZahlMax > 500) Serial.println("Der Zahlenraum muss < 500 sein!");
        else
        {
          String EingabeMin = Eingabe.substring(SucheKomma + 1, SucheMinus);
          String EingabeMax = Eingabe.substring(SucheMinus + 1, Eingabe.length());
          int MinDivisor = EingabeMin.toInt();
          int MaxDivisor = EingabeMax.toInt();

          // Array definieren
          int Zahlen [ZahlMax];

          // Länge des Arrays bestimmen
          int Laenge = sizeof(Zahlen) / sizeof(Zahlen[0]);

          // Array mit Zahlen füllen
          for (int i = 2; i <= Laenge; i++)
          {
            Zahlen[i] = i;
          }

          // Hinweis auf den Zahlenraum und den maximalen Teiler
          Serial.println("Im Zahlenraum bis " + String(ZahlMax - 1) + " durch " + 
          String(MinDivisor)  + " bis " + String(MaxDivisor) + " teilbare Zahlen: ");
          Serial.println("-------------------------------------------------- -");

          /*
            Ergebnisse mit der Funktion ErgebnisAnzeigen anzeigen
            übergebene Parameter:
            Array Zahlen
            Divisor -> i
            Länge des Arrays -> Laenge
          */
          for (int i = MinDivisor; i <= MaxDivisor; i++)
          {
            ErgebnisAnzeigen(Zahlen, i, Laenge);
          }
          Serial.println("----------------------------------------------------");
        }
      }
    }
  }
}

void ErgebnisAnzeigen(int Zahlen[], int Divisor, int Laenge)
{
  Serial.print("Durch " + String(Divisor) + " teilbare Zahlen: ");
  int Anzahl = 0;
  /*
    mit Hilfe der Funktion modulo wird ermittelt,
    ob die Zahl durch den Divisor teilbar ist
    Start mit dem aktuellen Wert für Divisor
  */
  for (int i = Divisor; i < Laenge; i++)
  {
    // Zahl ist teilbar -> Zahl anzeigen
    if (Zahlen[i] % Divisor == 0)
    {
      Serial.print(String(Zahlen[i]) + ", ");
      Anzahl++;
    }
  }

  // Anzahl der teilbaren Zahlen anzeigen
  Serial.print(" (" + String(Anzahl) + ")");
  Serial.println();
}

struct Stadt
{
  int Platz;
  String Name;
  String KFZ_Kennzeichen;
  float Einwohner;
  String Vorwahl;
  int Hoehe;
  String Land;
};

const int MAX = 4;
/*
  \u00e4d = ä
  \u00df = ß
  \u00fc = ü
  \u00f6 = ö
*/
// Array definieren
Stadt Namen[MAX] =
{
  {1, "Berlin", "B", 3.64, "030", 30, "Berlin"},
  {2, "Hamburg", "HH", 1.84, "040", 6, "Hamburg"},
  {3, "M\u00fcnchen", "M", 1.47, "089", 519, "Bayern"},
  {4, "K\u00f6ln", "K", 1.04, "0221", 53, "NRW"}
};

void setup()
{
  // Zufallsgenerator starten
  randomSeed(analogRead(A0));
  Serial.begin(115200);
  
  // auf serielle Verbindung warten
  while (!Serial) {;}

  // Info
  Serial.println("Liste der Gro\u00dfst\u00e4dte mit mehr als 1 Mio Einwohner");
  Serial.println("----------------------------------------------------------------------------------");
  Serial.println("1 = Berlin");
  Serial.println("2 = Hamburg");
  Serial.println("3 = M\u00fcnchen");
  Serial.println("4 = K\u00f6ln");
  Serial.println("5 = Zufall");
  Serial.println("----------------------------------------------------------------------------------");
  Serial.println("Platz\tStadt\t\tKFZ\tEinw. in Mio.\tH\u00f6he\tVorwahl\t\tBundesland");
}

void loop()
{
  // auf serielle Eingabe warten
  while (Serial.available() > 0)
  {
    // Eingabe im Seriellen Monitor lesen
    String Eingabe = Serial.readStringUntil(char(13));
   
    // String Eingabe nach int umwandeln
    // die Funktion ZeigeDaten kann dann direkt aufgerufen werden
    int Auswahl = Eingabe.toInt();

    // wenn Auswahl > 0 und < 5
    // weil das Array mit 0 beginnt, 1 abziehen
    if (Auswahl > 0 && Auswahl < 5) ZeigeDaten(Auswahl - 1);

    // zufällige Auswahl
    if (Auswahl == 5)
    {
      int Minimum = 0;
      int Maximum = 4;
      int Zahl =  random(Minimum, Maximum);
      ZeigeDaten(Zahl);
    }
  }
}

void ZeigeDaten(int i)
{
  // bei der Einwohnerzahl . durch , ersetzen
  String Einwohner =  String(Namen[i].Einwohner);
  Einwohner.replace(".", ",");

  // Daten anzeigen, mit Tabulator (\t) formatieren
  Serial.print(String(Namen[i].Platz) + "\t");
  Serial.print(Namen[i].Name + "\t\t");
  Serial.print(Namen[i].KFZ_Kennzeichen + "\t\t");
  Serial.print(Einwohner + "\t");
  Serial.print(String(Namen[i].Hoehe) + "\t");
  Serial.print(Namen[i].Vorwahl + "\t\t");
  Serial.println(Namen[i].Land);
}

Letzte Aktualisierung: