Lösungen

Ampel­an­la­ge

#include "U8g2lib.h"

// 0,96 Zoll SSD1306
U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);

// Bildschirmgröße
int BildschirmBreite = oled.getDisplayWidth();
int BildschirmHoehe = oled.getDisplayHeight();

//  Pins für die Ampeln
enum Ampel 
{
  // Startwert Pin 3
  FAHRBAHN_ROT_LINKS = 3,
  FAHRBAHN_GELB_LINKS,       // 4
  FAHRBAHN_GRUEN_LINKS,      // 5
  FUSSGAENGER_ROT_LINKS,     // 6
  FUSSGAENGER_GRUEN_LINKS,   // 7
  FAHRBAHN_ROT_RECHTS,       // 8
  FAHRBAHN_GELB_RECHTS,      // 9
  FAHRBAHN_GRUEN_RECHTS,     // 10
  FUSSGAENGER_ROT_RECHTS,    // 11
  FUSSGAENGER_GRUEN_RECHTS,  // 12
};

int LAUTSPRECHER = 13;

// angezeigte Zahl Fahrbahnampel
int NummerFahrbahnampel = 9;

// angezeigte Zahl Fußgängerampel
int NummerFussgaengerampel = 4;

// Sekunden der Grün-Phase Fahrbahnampel
int SekundenGruenFahrbahn = 6;
int SekundenGruenFussgaenger = 4;

void setup() 
{
  // pinModes der LEDs
  for (int i = FAHRBAHN_ROT_LINKS; i <= FUSSGAENGER_GRUEN_RECHTS; i++) 
  {
    pinMode(i, OUTPUT);
  }
  // Display starten
  oled.begin();

  // Kontrast maximal 255
  oled.setContrast(200);

  // Schriftart setzen
  oled.setFont(u8g2_font_logisoso62_tn);
}

void loop() 
{
  // Fahrbahnampeln rot
  // links
  digitalWrite(FAHRBAHN_ROT_LINKS, HIGH);
  digitalWrite(FAHRBAHN_ROT_RECHTS, HIGH);

  digitalWrite(FUSSGAENGER_ROT_LINKS, LOW);
  digitalWrite(FUSSGAENGER_ROT_RECHTS, LOW);
  digitalWrite(FUSSGAENGER_GRUEN_LINKS, HIGH);
  digitalWrite(FUSSGAENGER_GRUEN_RECHTS, HIGH);

  oled.firstPage();
  do 
  {
    oled.setCursor(50, BildschirmHoehe);
    oled.print(NummerFussgaengerampel);
  } 
  while (oled.nextPage());

  // Grünphase Fußgängerampel
  for (int i = 0; i < SekundenGruenFussgaenger; i++) 
  {
    // Variable herunterzählen
    NummerFussgaengerampel--;
    delay(1000);

    oled.firstPage();
    do 
    {
      oled.setCursor(50, BildschirmHoehe);
      oled.print(NummerFussgaengerampel);
    } 
    while (oled.nextPage());
  }

  // OLED löschen
  oled.clearDisplay();
  // Fußgängerampeln von grün auf rot geschaltet
  digitalWrite(FUSSGAENGER_GRUEN_LINKS, LOW);
  digitalWrite(FUSSGAENGER_ROT_LINKS, HIGH);

  digitalWrite(FUSSGAENGER_GRUEN_RECHTS, LOW);
  digitalWrite(FUSSGAENGER_ROT_RECHTS, HIGH);

  tone(LAUTSPRECHER, 1000, 10);
  delay(1000);
  tone(LAUTSPRECHER, 1000, 10);

  // Anzeige der Sekunden Fahrbahnampel
  oled.firstPage();
  do 
  {
    oled.setCursor(50, BildschirmHoehe);
    oled.print(NummerFahrbahnampel);
  } 
  while (oled.nextPage());

  // Fahrbahnampeln auf rot-gelb und dann auf grün schalten
  digitalWrite(FAHRBAHN_GELB_LINKS, HIGH);
  digitalWrite(FAHRBAHN_GELB_RECHTS, HIGH);

  // Variable herunterzählen
  NummerFahrbahnampel--;
  delay(1000);

  oled.firstPage();
  do 
  {
    oled.setCursor(50, BildschirmHoehe);
    oled.print(NummerFahrbahnampel);
  } 
  while (oled.nextPage());

  digitalWrite(FAHRBAHN_ROT_LINKS, LOW);
  digitalWrite(FAHRBAHN_GELB_LINKS, LOW);
  digitalWrite(FAHRBAHN_GRUEN_LINKS, HIGH);

  digitalWrite(FAHRBAHN_ROT_RECHTS, LOW);
  digitalWrite(FAHRBAHN_GELB_RECHTS, LOW);
  digitalWrite(FAHRBAHN_GRUEN_RECHTS, HIGH);

  // Grünphase der Fahrbahnampeln
  for (int i = 0; i < SekundenGruenFahrbahn; i++) 
  {
    NummerFahrbahnampel--;
    delay(1000);
    oled.firstPage();
    do 
    {
      oled.setCursor(50, BildschirmHoehe);
      oled.print(NummerFahrbahnampel);
    } 
    while (oled.nextPage());
  }

  // Fahrbahnampeln auf gelb schalten
  digitalWrite(FAHRBAHN_GRUEN_LINKS, LOW);
  digitalWrite(FAHRBAHN_GELB_LINKS, HIGH);

  digitalWrite(FAHRBAHN_GRUEN_RECHTS, LOW);
  digitalWrite(FAHRBAHN_GELB_RECHTS, HIGH);

  delay(1000);
  NummerFahrbahnampel--;

  oled.firstPage();
  do 
  {
    oled.setFontDirection(0);
    oled.setCursor(50, BildschirmHoehe);
    oled.print(NummerFahrbahnampel);
  } 
  while (oled.nextPage());

  // Fahrbahnampeln gelb aus
  digitalWrite(FAHRBAHN_GELB_LINKS, LOW);
  digitalWrite(FAHRBAHN_GELB_RECHTS, LOW);

  digitalWrite(FUSSGAENGER_ROT_RECHTS, HIGH);
  digitalWrite(FUSSGAENGER_ROT_LINKS, HIGH);

  digitalWrite(FAHRBAHN_ROT_RECHTS, HIGH);
  digitalWrite(FAHRBAHN_ROT_LINKS, HIGH);
  oled.firstPage();
  do 
  {
    oled.setFontDirection(0);
    oled.setCursor(50, BildschirmHoehe);
    oled.print(NummerFahrbahnampel);
  } 
  while (oled.nextPage());
  delay(1000);
  // Wert für die Anzeige der Sekunden zurücksetzen
  NummerFahrbahnampel = 9;
  NummerFussgaengerampel = 4;

  // OLED löschen
  oled.clearDisplay();
}

Letzte Aktualisierung:

Mor­se­ge­rät mit Sensorshield

int LED = 8;
int TASTER = 9;
int LAUTSPRECHER = 10;

// der auszulesende Zustand des Tasters wird als Variable definiert
int TasterLesen;

void setup()
{
  pinMode(TASTER, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}

void loop()
{
  TasterLesen = digitalRead(TASTER);
  if (TasterLesen == LOW)
  {
    // Lautsprecher einschalten
    tone(LAUTSPRECHER, 1000);

    // LED einschalten
    digitalWrite(LED, HIGH);
  }

  // wenn der Taster losgelassen wurde
  else
  {
    // Lautsprecher ausschalten
    noTone(LAUTSPRECHER);

    // LED ausschalten
    digitalWrite(LED, LOW);
  }
}

Letzte Aktualisierung:

LEDs mit Joy­stick-Shield schalten

Inhalts­ver­zeich­nis

LED leuch­tet, wenn der Tas­ter gedrückt wird

// Array Taster
// Reihenfolge A B C D
byte Taster[] = { 2, 3, 4, 5, 8 };

// analoge Pins Joystick
byte XAchse = A0;
byte YAchse = A1;

// Array für die LEDs
byte LED[5] = { 9, 10, 11, 12 };

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

  // pinMode der 4 Taster festlegen: sizeof = Größe des Arrays
  // INPUT_PULLUP -> Eingangspegel auf HIGH setzen
  for (int i = 0; i <= sizeof(Taster); i++)
  {
    // INPUT_PULLUP -> Eingangspegel auf HIGH setzen
    pinMode(Taster[i], INPUT_PULLUP);
  }

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

void loop()
{
  // Zustand der Taster der Reihe nach abfragen
  for (int i = 0; i < sizeof(Taster); i++)
  {
    // wenn der jeweilige Taster gedrückt wird
    // wird der Zustand der jeweiligen LED true
    // -> LED wird eingschaltet
    if (digitalRead(Taster[i]) == LOW)
    {
      digitalWrite(LED[i], HIGH);
      Serial.println("Taste: " + String(Taster[i]));
    }
    // wenn der Taster nicht gedrückt wurde
    // -> LED bleibt ausgeschaltet
    else digitalWrite(LED[i], LOW);
  }

  // Bewegung der Y-Achse lesen
  int PositionX = analogRead(XAchse);

  // Bewegung X-Achse nach links
  // Lauflicht nach links,
  // for-Schleife läuft rückwärts
  if (PositionX > 600)
  {
    for (int i = 0; i < sizeof(LED); i++)
    {
      digitalWrite(LED[i], HIGH);
      delay(200);
      digitalWrite(LED[i], LOW);
    }
  }

  // Bewegung X-Achse nach links
  // Lauflicht nach links
  if (PositionX < 300)
  {
    for (int i = sizeof(LED); i >= 0; i--)
    {
      digitalWrite(LED[i], HIGH);
      delay(200);
      digitalWrite(LED[i], LOW);
    }
  }
}

Tas­ter funk­tio­niert als Ein-/Aus­schal­ter der LED

#include "Bounce2.h"

// Array für die LEDs
byte LED[5] = { 9, 10, 11, 12 };

// Taster
int TasterA = 2;
int TasterB = 3;
int TasterC = 4;
int TasterD = 5;
int TasterJoystick = 8;

// analoge Pins Joystick
byte XAchse = A0;
byte YAchse = A1;

// Bibliothek Bounce2
// "Prellverhinderer" für die Tasten starten
Bounce A = Bounce();
Bounce B = Bounce();
Bounce C = Bounce();
Bounce D = Bounce();
Bounce JoystickKnopf = Bounce();

/*
  Array für den Zustand der LEDs
  false = ausgeschaltet
  true = eingeschaltet
*/
bool Status[5] = { false, false, false, false, false };

void setup() {
  // pinMode der LEDs festlegen
  for (int i = 0; i <= sizeof(LED); i++) {
    pinMode(LED[i], OUTPUT);
  }

  // Vorwiderstand der Taster aktivieren
  pinMode(TasterA, INPUT_PULLUP);
  pinMode(TasterB, INPUT_PULLUP);
  pinMode(TasterC, INPUT_PULLUP);
  pinMode(TasterD, INPUT_PULLUP);
  pinMode(TasterJoystick, INPUT_PULLUP);

  // attach -> Bounce für jede Taste zuordnen
  A.attach(TasterA);
  B.attach(TasterB);
  C.attach(TasterC);
  D.attach(TasterD);
  JoystickKnopf.attach(TasterJoystick);
}

void loop() 
{
  // Taster A
  if (A.update()) {
    if (A.read() == LOW) 
    {
      // LED Pin 3 Status[0]
      Status[0] = !Status[0];
      digitalWrite(LED[0], Status[0]);
    }
    digitalWrite(LED[4], LOW);
  }

  // Taster B
  if (B.update()) {
    if (B.read() == LOW) 
    {      
      // LED Pin 4 Status[1]
      Status[1] = !Status[1];
      digitalWrite(LED[1], Status[1]);
    }
  }

  // Taster C
  if (C.update()) 
  {
    if (C.read() == LOW) 
    {
      // LED Pin 5 Status[2]
      Status[2] = !Status[2];
      digitalWrite(LED[2], Status[2]);
    }
  }

  // Taster D
  if (D.update()) 
  {
    if (D.read() == LOW) 
    {
      // LED Pin 6 Status[3]
      Status[3] = !Status[3];
      digitalWrite(LED[3], Status[3]);
    }
  }

  // Taster Joystick
  if (JoystickKnopf.update()) 
  {
    if (JoystickKnopf.read() == LOW) 
    {
      // alle LEDs einschalten und Status aller LEDs auf true (ein) setzen
      for (int i = 0; i <= sizeof(LED); i++) 
      {
        Status[i] = true;
        digitalWrite(LED[i], Status[i]);     
      }
    }
  }

  // Bewegung der Y-Achse lesen
  int PositionX = analogRead(XAchse);

  // Bewegung X-Achse nach rechts
  // Lauflicht nach rechts
  if (PositionX < 300) 
  {
    for (int i = 0; i < sizeof(LED); i++) 
    {
      digitalWrite(LED[i], HIGH);
      delay(200);
      digitalWrite(LED[i], LOW);
    }
  }

  // Bewegung X-Achse nach links
  // Lauflicht nach links, for-Schleife läuft rückwärts
  if (PositionX > 600) 
  {
    for (int i = sizeof(LED); i >= 0; i--) 
    {
      digitalWrite(LED[i], HIGH);
      delay(200);
      digitalWrite(LED[i], LOW);
    }
  }
}

Letzte Aktualisierung:

Glücks­rad LED-Ring OLED

// benötigte Bibliotheken einbinden
#include "Adafruit_NeoPixel.h"
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"

// Adresse I2C
#define I2C_ADDRESS 0x3C

// Name des OLED festlegen
SSD1306AsciiWire oled;

// digitaler Pin LED-Ring
#define RING 7

// digitaler Pin des Lautsprechers
#define LAUTSPRECHER 8

// Anzahl der LEDs -> muss an den verwendeten LED-Ring angepasst werden
#define AnzahlLED 32

// LED-Ring -> Name des LED-Rings
Adafruit_NeoPixel LEDRing = Adafruit_NeoPixel(AnzahlLED, RING, NEO_GRB + NEO_KHZ800);

// Status entscheidet, ob das Glücksrad läuft oder gestoppt wird
// false -> Glücksrad läuft beim Start
volatile bool Status = false;

// true -> Lautsprecher ein
// false -> Lautsprecher aus
bool Toene = true;

// true -> zufällige Farbe nach jeder Runde wechseln
// false -> Farbwechsel nach jedem Pixel
bool FarbWechselRunde = false;

// Definition der Farben
int ROT, GRUEN, BLAU;

// Taster am Interrupt-Port definieren
#define TASTER 2

// Variablen für die mit millis() ermittelte Zeit
// damit nur jeweils ein Tasterdruck erkannt wird
static unsigned long GesicherteStartZeit = 0;
unsigned long Startzeit;

int Punkte;

// Zeit zwischen den Bewegungen der LED
int WarteZeit = 100;

void setup()
{
  Serial.begin(9600);
  // NeoPixel Bibliothek initialisieren
  LEDRing.begin();

  // setBrightness(0..255)
  LEDRing.setBrightness(250);

  // pinMode des Tasters mit eingeschaltetem Vorwiderstand
  pinMode(TASTER, INPUT_PULLUP);

  // Interrupt dem Taster zuordnen und die Funktion LEDSchalten aufrufen
  attachInterrupt(digitalPinToInterrupt(TASTER), LEDSchalten, FALLING);

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

  // OLED starten
  Wire.begin();
  Wire.setClock(400000L);
  oled.begin(&Adafruit128x64, I2C_ADDRESS);

  // Schriftart festlegen
  oled.setFont(TimesNewRoman16);
}

void loop()
{
  // LED-Ring ausschalten
  LEDRing.clear();

  // zufällige Farbwerte Wechsel nach jeder 360° Drehung
  // -> FarbWechselRunde true
  if (FarbWechselRunde)
  {
    ROT = ZufallsFarbe();
    GRUEN = ZufallsFarbe();
    BLAU = ZufallsFarbe();
  }

  // wenn Status false -> Glücksrad läuft
  if (!Status)
  {
    if (Toene) tone(LAUTSPRECHER, 1000, 5);

    // Start der Drehung mit LED 0
    // Ende mit Anzahl der LEDs
    for (int i = 0; i < LEDRing.numPixels(); i++)
    {
      // zufällige Farbwerte: Wechsel nach jeder LED
      // -> FarbWechselRunde false
      if (!FarbWechselRunde)
      {
        ROT = ZufallsFarbe();
        GRUEN = ZufallsFarbe();
        BLAU = ZufallsFarbe();
      }

      // Farbe für die aktuelle LED
      LEDRing.setPixelColor(i, ROT, GRUEN, BLAU);

      // LEDs einschalten
      LEDRing.show();

      /*
        Taster gedrückt: Status = true -> Glücksrad stoppen
        break -> for-Schleife verlassen
      */
      if (Status)
      {
        if (Toene) tone(LAUTSPRECHER, 1000, 500);

        // Punkte ermitteln 32 LEDs, jeweils 4 pro Feld
        
        // 40 Punkte
        if (i >= 0  && i <= 3) Punkte = Punkte + 40;

        // 100 Punkte
        if (i >= 4 && i <= 7) Punkte = Punkte + 100;

        // 20 Punkte
        if (i > 9 && i <= 12) Punkte = Punkte + 20;

        // 60 Punkte
        if (i > 12 && i <= 16) Punkte = Punkte + 60;

        // 120 Punkte
        if (i > 16 && i <= 20) Punkte = Punkte + 120;

        // 160 Punkte
        if (i > 20 && i <= 24) Punkte = Punkte + 160;

        // 80 Punkte
        if (i > 24 && i <= 28) Punkte = Punkte + 80;

        // 140 Punkte
        if (i > 28 && i <= 32) Punkte = Punkte + 140;

        // Punktestand OLED anzeigen
        oled.setCursor(2, 1);
        oled.print("Punktestand:");
        oled.setCursor(2, 4);
        oled.print(String(Punkte) + " Punkte");

        // for-Schleife verlassen
        break;
      }

      // Wartezeit bis zur nächsten LED
      delay(WarteZeit);

      // aktuell eingeschaltete LEDs ausschalten
      LEDRing.setPixelColor(i, 0);

      // wenn nur eine LED "laufen" soll, der Schalter EineLED false ist
      // if (!EineLED) LEDRing.setPixelColor(i + 1, 0);
    }
  }
}

void LEDSchalten()
{
  // aktuelle Zeit sichern
  Startzeit = millis();

  /*
    bei mehr als 250 Millisekunden Differenz
    zwischen der aktuellen und der gesicherten Zeit
    -> Status umdrehen
    aus false wird true -> Glücksrad stoppen
    aus true wird false -> Glücksrad starten
  */
  if (Startzeit - GesicherteStartZeit > 250)
  {
    Status = !Status;
  }

  GesicherteStartZeit = Startzeit;
}

int ZufallsFarbe()
{
  int Farbe = random(0, 255);
  return Farbe;
}

Tem­pe­ra­tur mit LM35 mes­sen und im Seri­el­len Moni­tor anzeigen

// LM35 am analogen Eingang A0
int LM35 = A0;

/*
  Variablen:
  SensorWert -> gelesener Wert des analogen Eingangs A0
  genmesseneSpannung berechnen:
  - 5V (5000 mV) = Arduino Spannung
  - 1500 mV (150° maximaler Messwert LM35) 
  gemesseneTemperatur -> Ergebnis der Messung in °C
  TemperaturSumme -> Summe der Temperaturen nach 5 Messungen
  DurchschnittsTemperatur -> berechnete Durchschnitts-Temperatur
*/
float SensorWert;
float gemesseneSpannung;
float gemesseneTemperatur;
float TemperaturSumme;
float DurchschnittsTemperatur;

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

void loop() 
{
  // nächste Berechnung -> TemperaturSumme wieder auf 0 setzen
  TemperaturSumme = 0;

  // 5 Messungen im Abstand con 500 ms
  for (int i = 1; i <= 5; i++) 
  {
    // Sensorwert an A0 lesen
    SensorWert = analogRead(LM35);

    // richtiges Verhältnis zwischen 5V (= 5000 mV Spannung Arduino)
    // und maximal möglicher Spannung LM35 1500 mV herstellen 
    gemesseneSpannung = (SensorWert * 5000.0) / 1500.0;

    // ...und durch 10 dividieren
    // -> Spannung in Grad Celsius umwandeln
    gemesseneTemperatur = gemesseneSpannung / 10.0;
    
    // einzelne Werte anzeigen
    // Serial.println(gemesseneTemperatur);
    TemperaturSumme = TemperaturSumme + gemesseneTemperatur;

    delay(500);
  }

  // Durchschnitt der 5 Messungen berechnen
  DurchschnittsTemperatur = TemperaturSumme / 5.0;

  // Temperatur in String umwandeln
  String AnzeigeTemperatur = String(DurchschnittsTemperatur);
  
  // replace: . durch , ersetzen
  AnzeigeTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.print("Temperatur: " + AnzeigeTemperatur);
 
  // \u00b0 = Grad-Zeichen
  Serial.print(" \u00b0");
  Serial.println("C");
}

Letzte Aktualisierung:

Tem­pe­ra­tur mit LM35 mes­sen Anzei­ge im Seri­el­len Moni­tor und LCD

Inhalts­ver­zeich­nis

Aus­ga­be im Seri­el­len Monitor:

// LM35 am analogen Eingang A0
int LM35 = A0; 

/*
  Variablen:
  SensorWert -> gelesener Wert des analogen Eingangs A0
  genmesseneSpannung berechnen
  5V (5000 mV) = Arduino Spannung
  1500mV (150° maximaler Messwert LM35) 
  Maximalwert analoger Eingang
  Temperatur -> berechneter Wert der Temperatur
*/
float SensorWert;
float gemesseneSpannung;
float Temperatur;

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

void loop() 
{
  SensorWert = analogRead(LM35);

  // richtiges Verhältnis zwischen 5V (= 5000mV Spannung Arduino)
  // und maximal mögliche Spannung 1500mV herstellen
  gemesseneSpannung = (SensorWert * 5000) / 1500;
 
  // 10 mV = 1 Grad Celsius
  // gemesseneSpannung / 10 -> Spannung in Grad Celsius umwandeln
  Temperatur = gemesseneSpannung / 10.0;

  // float in String umwandeln, damit der . ersetzt werden kann
  String AnzeigeTemperatur = String(Temperatur);

  // replace: . durch , ersetzen
  AnzeigeTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.print("Temperatur: ");
  Serial.println(AnzeigeTemperatur + " Grad");
 
  delay(2000);
}

Aus­ga­be auf einem 4-zei­li­ges LCD mit I²C-Schnittstelle:

#include "LiquidCrystal_I2C.h"

// LCD einen Namen zuweisen
LiquidCrystal_I2C lcd(0x27, 20, 4);

// LM35 am analogen Eingang A0
int LM35 = A0; 

/*
  Variablen:
  SensorWert -> gelesener Wert des analogen Eingangs A0
  genmesseneSpannung berechnen
  5V (5000 mV) = Arduino Spannung
  1500mV (150° maximaler Messwert LM35) 
  Maximalwert analoger Eingang
  Temperatur -> berechneter Wert der Temperatur
*/
float SensorWert;
float gemesseneSpannung;
float Temperatur;

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

  // LCD einschalten
  lcd.init();
  lcd.backlight();
}

void loop() 
{
  SensorWert = analogRead(LM35);

  // richtiges Verhältnis zwischen 5V (= 5000mV Spannung Arduino)
  // und maximal mögliche Spannung 1500mV herstellen
  gemesseneSpannung = (SensorWert * 5000) / 1500;
 
  // 10 mV = 1 Grad Celsius
  // gemesseneSpannung / 10 -> Spannung in Grad Celsius umwandeln
  Temperatur = gemesseneSpannung / 10.0;

  // float in String umwandeln, damit der . ersetzt werden kann
  String AnzeigeTemperatur = String(Temperatur);

  // replace: . durch , ersetzen
  AnzeigeTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.print("Temperatur: ");
  Serial.println(AnzeigeTemperatur + " Grad");

  // Anzeige LCD
  lcd.setCursor(0, 0);
  lcd.print("Temperatur: ");
  lcd.setCursor(0, 1);

  // \337C -> °   
  lcd.print(AnzeigeTemperatur + " \337C -> LM35");
 
  delay(2000);
}

Letzte Aktualisierung:

Glücks­rad LED-Ring

#include "Adafruit_NeoPixel.h"

// digitaler Pin LED-Ring
#define RING 7

// digitaler Pin des Lautsprechers
#define LAUTSPRECHER 8

// Anzahl der LEDs -> muss an den verwendeten Neopixel-Ring angepasst werden
#define AnzahlLED 16

// LED-Ring -> Name des LED-Rings
Adafruit_NeoPixel LEDRing = Adafruit_NeoPixel(AnzahlLED, RING, NEO_GRB + NEO_KHZ800);

// Status entscheidet, ob das Glücksrad läuft oder gestoppt wird
// false -> Glücksrad läuft beim Start
volatile bool Status = false;

// true -> Lautsprecher ein
// false -> Lautsprecher aus
bool Toene = true;

// true -> zufällige Farbe nach jeder Runde wechseln
// false -> Farbwechsel nach jedem Pixel
bool FarbWechselRunde = false;

// Definition der Farben
int ROT, GRUEN, BLAU;

// Taster am Interrupt-Pin definieren
#define TASTER 3

// Variablen für die mit millis() ermittelte Zeit
// damit nur jeweils ein Tasterdruck erkannt wird
static unsigned long GesicherteStartZeit = 0;
unsigned long Startzeit;

// Zeit zwischen den Bewegungen der LED
int WarteZeit = 50;

void setup()
{
  // NeoPixel Bibliothek initialisieren
  LEDRing.begin();

  // setBrightness(0..255)
  LEDRing.setBrightness(250);

  // Eingangspegel auf HIGH setzen
  pinMode(TASTER, INPUT_PULLUP);

  // Interrupt dem Taster zuordnen und die Funktion LEDSchalten aufrufen
  attachInterrupt(digitalPinToInterrupt(TASTER), LEDSchalten, FALLING);

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

void loop()
{
  // LED-Ring ausschalten
  LEDRing.clear();

  // zufällige Farbwerte Wechsel nach jeder 360° Drehung
  // -> FarbWechselRunde true
  if (FarbWechselRunde)
  {
    ROT = ZufallsFarbe();
    GRUEN = ZufallsFarbe();
    BLAU = ZufallsFarbe();
  }

  // wenn Status false -> Glücksrad läuft
  if (!Status)
  {
    if (Toene) tone(LAUTSPRECHER, 1000, 5);

    // Start der Drehung mit LED 0
    // Ende mit Anzahl der LEDs
    for (int i = 0; i < LEDRing.numPixels(); i++)
    {
      // zufällige Farbwerte: Wechsel nach jeder LED
      // -> FarbWechselRunde false
      if (!FarbWechselRunde)
      {
        ROT = ZufallsFarbe();
        GRUEN = ZufallsFarbe();
        BLAU = ZufallsFarbe();
      }

      // Farbe für die aktuelle LED
      LEDRing.setPixelColor(i, ROT, GRUEN, BLAU);

      // LEDs einschalten
      LEDRing.show();

      /*
        Taster gedrückt: Status = true -> Glücksrad stoppen
        break -> for-Schleife verlassen
      */
      if (Status)
      {
        if (Toene) tone(LAUTSPRECHER, 1000, 500);
        break;
      }

      // Wartezeit bis zur nächsten LED
      delay(WarteZeit);

      // aktuell eingeschaltete LEDs ausschalten
      LEDRing.setPixelColor(i, 0);
    }
  }
}

void LEDSchalten()
{
  // aktuelle Zeit sichern
  Startzeit = millis();

  /*
    bei mehr als 250 Millisekunden Differenz
    zwischen der aktuellen und der gesicherten Zeit
    -> Status umdrehen
    aus false wird true -> Glücksrad stoppen
    aus true wird false -> Glücksrad starten
  */
  if (Startzeit - GesicherteStartZeit > 250)
  {
    Status = !Status;
  }
  GesicherteStartZeit = Startzeit;
}

int ZufallsFarbe()
{
  int Farbe = random(0, 255);
  return Farbe;
}

Letzte Aktualisierung:

LED Fern­be­die­nung schalten

#include "IRremote.hpp"
int EmpfaengerPin = 11;
int LED = 7; 

void setup() 
{
  IrReceiver.begin(EmpfaengerPin);
  pinMode(LED, OUTPUT);
}

void loop() 
{
  // Daten lesen
  if (IrReceiver.decode()) 
  {
    // nächsten Wert lesen
    IrReceiver.resume();

    if (IrReceiver.decodedIRData.address == 0) 
    {
      // Taste 1 -> gelesener Deizimalwert 22 -> LED einschalten
      if (IrReceiver.decodedIRData.command == 22) digitalWrite(LED, HIGH);

      // Taste 2 -> gelesener Deizimalwert 25 -> LED ausschalten
      if (IrReceiver.decodedIRData.command == 25) digitalWrite(LED, LOW);
    }
  }
}

Letzte Aktualisierung:

Zeit­er­fas­sung RFID

#include "MFRC522.h"
#include "SPI.h"
#include "SdFat.h"
#include "RTClib.h"
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"

// Name des RTC-Moduls (rtc)
RTC_DS3231 rtc;

// mögliche Adressen I2C: 0X3C+SA0  0x3C or 0x3D
#define I2C_ADDRESS 0x3C

// Name des OLED festlegen
SSD1306AsciiWire oled;

// Bezeichnung der SD-Karte
// entfällt bei der Bibliothek SD
SdFat SD;

// Bezeichnung der CSV-Datei
File Zeiterfassung;

// Anschlüsse RFID definieren
#define SDA 7
#define RST 9

// RFID-Empfänger benennen
MFRC522 mfrc522(SDA, RST);

// Datenpin für das SD-Kartenmodul
// int DatenPin= 4;

// Daten-Logger-Shield
int DatenPin = 10;

// Trennzeichen für die CSV-Datei
const String TrennZeichen = ",";

String Mitarbeiter;

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

  // OLED mit 128x64 Pixeln starten
  Wire.begin();
  oled.begin(&Adafruit128x64, I2C_ADDRESS);

  // Schriftart festlegen
  oled.setFont(Arial14);
  oled.println(F("Zeiterfassung"));

  // Initialisierung des RFID-Empfängers
  mfrc522.PCD_Init();

  /*
    wenn Datum und Zeit nicht korrekt -> Datum/Zeit setzen
    Jahr, Monat, Tag, Stunde, Minute, Sekunde
    Beispiel:  2022 August 31. 10 Uhr 30 Minuten 30 Sekunden
    rtc.adjust(DateTime(2022, 8, 31, 10, 31, 30));
 */
  // RTC-Modul starten
  rtc.begin();

  // SD-Karte starten
  if (!SD.begin(DatenPin)) 
  {
    Serial.println(F("Initialisierung fehlgeschlagen!"));
  } 
  else Serial.println(F("SD-Karte gestartet!"));

  // rtc.now() -> aktuelle Zeit holen
  DateTime aktuell = rtc.now();

  // Format des Datums festlegen
  char Datum[] = "DD.MM.YYYY";

  // Datum in Zeichenkette (String) umwandeln und anzeigen
  Serial.print(aktuell.toString(Datum));

  // Format der Zeitangabe festlegen
  char Zeit[] = "hh:mm:ss";

  // Zeitangabe in Zeichenkette (String) umwandeln und anzeigen
  Serial.print(aktuell.toString(Zeit));
}

void loop() 
{  
  // vom RFID ermittelter Wert der Karte als Folge von Dezimalzahlen
  String WertDEZ;

  // String Mitarbeiter löschen, damit falsche Karte erkannt wird
  Mitarbeiter = "";

  // Wenn keine Karte in Reichweite ist ..
  if (!mfrc522.PICC_IsNewCardPresent()) 
  {
    // .. wird die Abfrage wiederholt.
    return;
  }

  // Wenn kein RFID-Sender ausgewählt wurde ..
  if (!mfrc522.PICC_ReadCardSerial()) 
  {
    // .. wird die Abfrage wiederholt.
    return;
  }
  Serial.println(F("Karte entdeckt!"));
  // Dezimal-Werte in String WertDEZ schreiben
  for (byte i = 0; i < mfrc522.uid.size; i++) 
  {
    WertDEZ = WertDEZ + String(mfrc522.uid.uidByte[i], DEC) + " ";
  }

  // dezimalen Wert anzeigen
  Serial.println("Wert in dezimal: " + WertDEZ);

  // Leerzeichen am Ende entfernen
  WertDEZ.trim();

  /*
    Karten abfragen und Namen der Mitarbeiter*innen zuordnen
    Dezimal-Werte durch die eigenen Werte ersetzen
  */  
  if (WertDEZ == "195 106 18 23") Mitarbeiter = "Klaus Drolshagen";
  if (WertDEZ == "227 77 233 22") Mitarbeiter = "Eva Hilger";
  if (WertDEZ == "131 125 21 23") Mitarbeiter = "Claudia Kruse";

  /*
    Namen abfragen
    wenn (if) Mitarbeiter == Klaus Drolshagen oder (||) Mitarbeiter == Eva Hilger || . . 
    werden Die Daten angezeigt und in die Datei geschrieben
  */ 
  if (Mitarbeiter == "Klaus Drolshagen" || Mitarbeiter == "Eva Hilger" || Mitarbeiter == "Claudia Kruse") 
  {
    // Daten in die Datei schreiben
    DatenSchreiben();
  }

  // falsche Karte
  else 
  {
    Serial.println(F("Falsche Karte!"));
    oled.clear();
    oled.print(F("Falsche Karte!"));
  } 
  
  // Pause, damit die Daten nicht mehrfach in die Datei geschrieben werden
  delay(1000);
}

void DatenSchreiben() 
{
  // Meldungen im Seriellen Monitor
  Serial.println("Schreibe Daten in Zeiterfassung.csv ... ");

  // Name der Mitarbeiterin/des Mitarbeiters
  Serial.println("Mitarbeiter*in: " + Mitarbeiter);
  Serial.println(F("-----------------------------"));

  // rtc.now() -> aktuelle Zeit holen
  DateTime aktuell = rtc.now();
  char Datum[] = "DD.MM.YYYY ";

  // Datum in Zeichenkette (String) umwandeln und anzeigen
  Serial.print(aktuell.toString(Datum));

  // Format der Zeitangabe festlegen
  char Zeit[] = "hh:mm:ss";

  // Zeitangabe in Zeichenkette (String) umwandeln und anzeigen
  Serial.println(aktuell.toString(Zeit));

  // Ausgabe OLED
  oled.clear();
  oled.println(Mitarbeiter);
  oled.println(aktuell.toString(Datum));
  oled.println(aktuell.toString(Zeit));
  
  /*
    Zeiterfassung ist das Datei-Objekt
    FILE_WRITE -> Datei zum Schreiben öffnen
    wenn die Datei noch nicht existiert, wird sie neu erstellt
    ansonsten werden die neuen Daten ans Ende angehängt
  */
  Zeiterfassung = SD.open("Zeiterfassung.csv", FILE_WRITE);
  if (Zeiterfassung) 
  {
    // Überschrift nach jedem Datensatzwiederholen 
    Zeiterfassung.print(F("Mitarbeiter*in:"));
    Zeiterfassung.print(TrennZeichen);
    Zeiterfassung.print(F("Datum:"));
    Zeiterfassung.print(TrennZeichen);
    Zeiterfassung.print(F("Zeit"));
    Zeiterfassung.println();

    // Daten in die Datei schreiben: Mitarbeiter*in, Datum und Zeit
    Zeiterfassung.print(Mitarbeiter);
    Zeiterfassung.print(TrennZeichen);
    Zeiterfassung.print(Datum);
    Zeiterfassung.print(TrennZeichen);
    Zeiterfassung.print(Zeit);
    Zeiterfassung.println();
    Zeiterfassung.println();
  }

  // Datei schließen
  Zeiterfassung.close();
  Serial.println(F("Speichern abgeschlossen."));
  Serial.println();
}

Letzte Aktualisierung: