Lösungen

#include "Adafruit_NeoPixel.h"

int PinLEDStick = 7;

// Anzahl der LEDs -> muss angepasst werden
int AnzahlLED = 8;

/*
  Initialisierung des LED-Sticks
  Parameter:
  LEDStick -> Name des LED-Sticks
  AnzahlLED -> Anzahl der LEDs
  PinLEDStick -> verwendeter Pin
  NEO_GRB + NEO_KHZ800 -> Typ des verwendeten LED-Streifens
*/
Adafruit_NeoPixel LEDStick = Adafruit_NeoPixel(AnzahlLED, PinLEDStick, NEO_GRB + NEO_KHZ800);

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

  // setBrightness(0..255)
  LEDStick.setBrightness(100);
}

void loop()
{
  // Zählung beginnt oben
  // rot ein
  for (int LEDNummer = AnzahlLED; LEDNummer > 4; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(255, 0, 0));
    LEDStick.show();
  }
  delay(3000);

  // gelb an
  for (int LEDNummer = 4; LEDNummer > 2; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(255, 255, 0));
    LEDStick.show();
  }
  delay(1000);

  // rot aus
  for (int LEDNummer = AnzahlLED; LEDNummer > 4; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(0, 0, 0));
    LEDStick.show();
  }

  // gelb aus
  for (int LEDNummer = 4; LEDNummer > 2; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(0, 0, 0));
    LEDStick.show();
  }

  // grün an
  for (int LEDNummer = 2; LEDNummer >= 0; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(0, 255, 0));
    LEDStick.show();
  }
  delay(3000);

  // grün aus
  for (int LEDNummer = 2; LEDNummer >= 0; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(0, 0, 0));
    LEDStick.show();
  }

  // gelb an
  for (int LEDNummer = 4; LEDNummer > 2; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(255, 255, 0));
    LEDStick.show();
  }
  delay(1000);

  // gelb aus
  for (int LEDNummer = 4; LEDNummer > 2; LEDNummer--)
  {
    LEDStick.setPixelColor(LEDNummer, LEDStick.Color(0, 0, 0));
    LEDStick.show();
  }
}

Letzte Aktualisierung:

#include "SdFat.h"
#include "DHT.h"

// Bezeichnung der SD-Karte
SdFat SD;

// Pin des DHT-Sensors
int SENSOR_DHT = 8;

// Sensortyp festlegen
// DHT22 oder DHT11
#define SensorTyp DHT11

// Sensor DHT einen Namen zuweisen
DHT dht(SENSOR_DHT, SensorTyp);

// Bibliothek für das RTC-Modul
#include <RTClib.h>
RTC_DS3231 rtc;

// Bezeichnung der Textdatei
File Temperaturmessung;

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

// Datenpin für das Datenlogger-Shield
// int DatenPin = 10;

String AktuellesDatum;
String AktuelleZeit;

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

  // auf serielle Verbindung warten
  while (!Serial) {;}
  
  Serial.println(F("Initialisiere SD-Karte"));
  if (!SD.begin(DatenPin))
  {
    Serial.println(F("Initialisierung fehlgeschlagen!"));
  }
  else Serial.println(F("Initialisierung abgeschlossen"));
  rtc.begin();
  
  /*
    wenn Datum und Zeit nicht korrekt ⇒ Datum/Zeit setzen
    Jahr, Monat, Tag, Stunde, Minute, Sekunde
    rtc.adjust(DateTime(2023, 8, 6, 10, 30, 30));
  */

  // Sensor DHT starten
  dht.begin();
}

void loop()
{
  DateTime aktuell = rtc.now();
 
  // Daten lesen
  float Temperatur = dht.readTemperature();
  float Luftfeuchtigkeit = dht.readHumidity();

  // Funktion aufrufen
  ZeitAusgeben(aktuell);

  // in Strings umwandeln, . durch , ersetzen
  String AnzeigeTemperatur = String(Temperatur);
  AnzeigeTemperatur.replace(".", ",");
  String AnzeigeLuftfeuchtigkeit = String(Luftfeuchtigkeit);
  AnzeigeLuftfeuchtigkeit.replace(".", ",");
  Serial.print(F("Temperatur:\t\t"));
  Serial.println(AnzeigeTemperatur);
  Serial.print(F("Luftfeuchtigkeit in %:\t"));
  Serial.println(AnzeigeLuftfeuchtigkeit);
  
  /*
    in Datei schreiben
    O_CREAT -> Datei erstellen, wenn sie nicht existiert
    O_WRITE -> in die Datei schreiben
    O_AT_END -> Startposition zum Schreiben an das Ende der Datei setzen
  */
  if (!Temperaturmessung.open("Messung.csv", O_CREAT | O_WRITE | O_AT_END))
  {
    Serial.print(F("Datei kann nicht ge\u00f6ffnet werden!"));
  }
  // wenn die Datei geöffnet werden konnte ...
  if (Temperaturmessung)
  {
    Serial.println(F("Schreibe Messdaten in die Datei Messung.csv ... "));
    Serial.println(F("-----------------------------------"));

    // Überschrift in Datei schreiben
    // Funktion aufrufen
    schreibeUeberschrift();
    Temperaturmessung.print(AktuellesDatum + ";");
    Temperaturmessung.print(AktuelleZeit + ";");
    Temperaturmessung.print(AnzeigeTemperatur + ";");
    Temperaturmessung.print(AnzeigeLuftfeuchtigkeit);
    Temperaturmessung.println();

    // Schreibfehler abfragen
    if (!Temperaturmessung.sync() || Temperaturmessung.getWriteError())
    {
      Serial.print(F("Schreibfehler!"));
    }
    else
    {
      // Datei schließen
      Temperaturmessung.close();
      Serial.println(F("Abgeschlossen."));
      Serial.println();
    }
  }

  // Zeit bis zur nächsten Messung (eine Minute)
  delay(60000);
}

void ZeitAusgeben(DateTime aktuell)
{
  char Datum[] = "DD.MM.YYYY";
  AktuellesDatum = aktuell.toString(Datum);
  char Zeit[] = "Uhrzeit: hh:mm:ss";
  AktuelleZeit = aktuell.toString(Zeit);
  Serial.println(AktuellesDatum + " " + AktuelleZeit);
}

void schreibeUeberschrift()
{
  Temperaturmessung.println();
  Temperaturmessung.print(F("Datum"));

  // ; als Trennzeichen für die CSV-Datei
  Temperaturmessung.print(";");
  Temperaturmessung.print(F("Zeit"));
  Temperaturmessung.print(";");
  Temperaturmessung.print(F("Temperatur in °C"));
  Temperaturmessung.print(";");
  Temperaturmessung.print(F("Luftfeuchtigkeit in %"));
  Temperaturmessung.println();
}

Letzte Aktualisierung:

Für die Dar­stel­lung im Brow­ser ist in Zei­le 202 eine Ände­rung nötig:

#include "DHT.h"
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"

// Name des OLED festlegen (oled)
SSD1306AsciiWire oled;

// Adresse I2C
#define I2C_ADDRESS 0x3C

// Pin des DHT-Sensors
int SENSOR_DHT = 9;

// Sensortyp festlegen
// DHT22 oder DHT11
#define SensorTyp DHT22

// Sensor DHT einen Namen zuweisen
DHT dht(SENSOR_DHT, SensorTyp);

int AnzahlMessungen = 0;

// Array für die Anzahl der Messungen
float Messung[5];

// Variable für die Berechnung der Durchschnittstemperatur
float Durchschnitt;

// Länge des Arrays Messung
int Anzahl = sizeof(Messung) / sizeof(Messung[0]);

void setup()
{
  // Sensor DHT starten
  dht.begin();

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

  // Schriftart bestimmen
  oled.setFont(Callibri11);
  oled.clear();
}

float DurchschnittBerechnen(float Messung[], int Anzahl)
{
  float Durchschnitt = 0;
  for (int i = 0; i < Anzahl; i++)
  {
    Durchschnitt = Durchschnitt + Messung[i];
    // Funktion PunktErsetzen -> , durch . ersetzen
    String AnzeigeDurchschnitt = PunktErsetzen(String(Messung[i]));
    // aktuelle Messung anzeigen
    Serial.println("Messung " + String(i + 1) + ": " + AnzeigeDurchschnitt);
  }
  // Durchschnitt berechnen
  Durchschnitt = Durchschnitt / Anzahl;
  return Durchschnitt;
}

String PunktErsetzen(String ErsatzString)
{
  ErsatzString.replace(".", ",");
  return ErsatzString;
}

void loop()
{
  float Temperatur;
  float Luftfeuchtigkeit;

  // Daten lesen
  Temperatur = dht.readTemperature();
  Luftfeuchtigkeit = dht.readHumidity();

  Serial.println("Messung: " + String(AnzahlMessungen + 1));
  
  // . durch , ersetzen
  String AnzeigeTemperatur = PunktErsetzen(String(Temperatur));
  String AnzeigeLuftfeuchtigkeit = PunktErsetzen(String(Luftfeuchtigkeit));
  
  // Ausgabe im Seriellen Monitor mit Tabstopps formatieren
  Serial.print("Temperatur: \t\t");
  Serial.println(AnzeigeTemperatur + " °C");
  Serial.print("Luftfeuchtigkeit: \t");
  Serial.println(AnzeigeLuftfeuchtigkeit + " %");
  Serial.println("---------------------------------------");

  // Ausgabe auf dem OLED
  oled.setCursor(0, 0);
  oled.print("Temperatur: ");
  oled.print(AnzeigeTemperatur + " Grad");
  oled.println();
  oled.print("Feuchtigkeit: ");
  oled.println(AnzeigeLuftfeuchtigkeit + " %");

  // aktuelle Temperatur in das Array Messung schreiben
  Messung[AnzahlMessungen] = Temperatur;
  AnzahlMessungen ++;

  // wenn jeweils Anzahl Messungen erfolgt sind
  // AnzahlMessungen lässt sich ohne Rest durch Anzahl teilen
  if (AnzahlMessungen % Anzahl == 0)
  {
    /*
     Durchschnitt berechnen
     der Funktion DurchschnittBerechnen wird das Array Messung
     und die Länge des Arrays Messung (Anzahl übergeben
    */
    Durchschnitt = DurchschnittBerechnen(Messung, Anzahl);
  
    // . durch , ersetzen
    String AnzeigeDurchschnitt = PunktErsetzen(String(Durchschnitt));
  
    // Ausgabe der Durchschnittstemperatur Serieller Monitor
    Serial.print("Durchschnitt der letzten " + String(Anzahl));
    Serial.println(" Messungen: " + AnzeigeDurchschnitt + " °C");
    Serial.println("---------------------------------------");
  
    // Ausgabe der Durchschnittstemperatur OLED
    oled.println("------------------------------");
    oled.print("Durchschnitt: " + AnzeigeDurchschnitt + " Grad");
    AnzahlMessungen = 0;
  }
  
  // mindestens 2 Sekunden Pause
  delay(2000);
}

Letzte Aktualisierung:

// TMP36 am analogen Pin A0
int TEMPERATURSENSOR = A0;

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

void loop()
{
  // Spannung am Eingang A0 messen
  float SensorWert = analogRead(TEMPERATURSENSOR);

  float gemesseneSpannung = SensorWert * 5000 / 1023;
  
  /*
    1 Grad = 10 mV 
    Versatz von 500 mV von der gemessenen Spannung abziehen
    und durch 10 = 1 Grad teilen
  */
  float gemesseneTemperatur = (gemesseneSpannung - 500.0) / 10.0;

  // Ausgabe im Seriellen Monitor
  Serial.print("Temperatur: ");

  // gemesseneTemperatur von float zu String umwandeln
  String AnzeigeTemperatur = String(gemesseneTemperatur);

  // replace ->  . durch , ersetzen
  AnzeigeTemperatur.replace(".", ",");

  // Temperatur anzeigen
  Serial.print(AnzeigeTemperatur);

  // \u00b0 = °
  Serial.print(" \u00b0");
  Serial.println("C");
  
  // Wartezeit bis zur nächsten Messung
  delay(2000);
}

Letzte Aktualisierung:

// Senden und Empfangen 
#define SENDEN 9
#define ECHO 8

// Ampel
#define ROT 5
#define GELB 6
#define GRUEN 7

long Zeit = 0;
long Entfernung = 0;

void setup()
{
  pinMode(SENDEN, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(ROT, OUTPUT);
  pinMode(GELB, OUTPUT);
  pinMode(GRUEN, OUTPUT);
}

void loop()
{
  digitalWrite(ROT, HIGH);

  // Funktion aufrufen
  Entfernung = EntfernungMessen();
  
  // Ampel schalten
  if (Entfernung < 10)
  {
    AmpelSchalten();
  }
}

int EntfernungMessen()
{
  long Entfernung = 0;
  
  // Sender kurz ausschalten um Störungen des Signal zu vermeiden
  digitalWrite(SENDEN, LOW);
  delay(5);

  // Signal senden
  digitalWrite(SENDEN, HIGH);
  delayMicroseconds(10);
  digitalWrite(SENDEN, LOW);
  
  // pulseIn -> Zeit messen, bis das Signal zurückkommt
  long Zeit = pulseIn(ECHO, HIGH);

  // Entfernung in cm berechnen
  Entfernung = (Zeit / 2) * 0.03432;
  return Entfernung;
}

void AmpelSchalten()
{
  delay(1000);
  digitalWrite(GELB, HIGH);
  delay(1000);
  digitalWrite(GELB, LOW);
  digitalWrite(ROT, LOW);
  digitalWrite(GRUEN, HIGH);
  delay(3000);
  digitalWrite(GRUEN, LOW);
  digitalWrite(GELB, HIGH);
  delay(1000);
  digitalWrite(GELB, LOW);
  digitalWrite(ROT, HIGH);
}

Letzte Aktualisierung:

int SENSOR = 7;
int LED = 6;
int SensorLesen;

/*
   setzt den Status der LED
   LED_an true ->  LED an
   LED_an false -> LED  aus
*/
bool LED_an = false;

void setup()
{
  pinMode(LED, OUTPUT);
  pinMode(SENSOR, INPUT);
}

void loop()
{
  SensorLesen = digitalRead(SENSOR);
  if (SensorLesen == HIGH)
  {
    delay(200);

    // LED ist aus ⇒ Status == false
    if (LED_an == false)
    {
      digitalWrite(LED, HIGH);

      // LED_an auf true (an) setzen
      LED_an = true;
    }

    // LED ist an -> LED_an == true
    else
    {
      digitalWrite(LED, LOW);
      
      // Status auf false (aus) setzen
      LED_an = false;
    }
  }
}

Letzte Aktualisierung:

#define LAUTSPRECHER 4
#define LED 5
#define SENDEN 7
#define ECHO 6

void setup()
{
  pinMode(SENDEN, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(LAUTSPRECHER, OUTPUT);
  pinMode(LED, OUTPUT);
}

void loop()
{
  // Funktion aufrufen
  long Entfernung = EntfernungMessen();

  // versuchen Messfehler auszuschließen
  if (Entfernung < 100)
  {
    switch (Entfernung)
    {
      case 13 ... 15:
        tone(LAUTSPRECHER, 1000, 2);
        digitalWrite(LED, HIGH);
        delay(50);
        digitalWrite(LED, LOW);
        delay(500);
        break;

      case 11 ... 12:
        tone(LAUTSPRECHER, 1000, 2);
        digitalWrite(LED, HIGH);
        delay(50);
        digitalWrite(LED, LOW);
        delay(400);
        break;

      case 9 ... 10:
        tone(LAUTSPRECHER, 1000, 2);
        digitalWrite(LED, HIGH);
        delay(50);
        digitalWrite(LED, LOW);
        delay(300);
        break;

       case 7 ... 8:
         tone(LAUTSPRECHER, 1000, 2);
         digitalWrite(LED, HIGH);
         delay(50);
         digitalWrite(LED, LOW);
         delay(200);
         break;

       case 5 ... 6:
         tone(LAUTSPRECHER, 1000, 2);
         digitalWrite(LED, HIGH);
         delay(50);
         digitalWrite(LED, LOW);
         delay(100);
         break;

       case 2 ... 4:
         tone(LAUTSPRECHER, 1000);
         digitalWrite(LED, HIGH);
         break;
    }
  }
}

int EntfernungMessen()
{
  long Entfernung = 0;

  // Sender kurz ausschalten um Störungen des Signal zu vermeiden
  digitalWrite(SENDEN, LOW);
  delay(5);

  // Signal senden
  digitalWrite(SENDEN, HIGH);
  delayMicroseconds(10);
  digitalWrite(SENDEN, LOW);

  // pulseIn -> Zeit messen, bis das Signal zurückkommt
  long Zeit = pulseIn(ECHO, HIGH);

  // Entfernung in cm berechnen
  // Zeit/2 -> nur eine Strecke
  Entfernung = (Zeit / 2) * 0.03432;
  return Entfernung;
}

Letzte Aktualisierung:

#define SENDEN 9
#define ECHO 8
#define LAUTSPRECHER 7

// Variable für Zeit und Entfernung initialisieren 
long Zeit;
long Entfernung;

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

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

  pinMode(SENDEN, OUTPUT); 
  pinMode(ECHO, INPUT); 
} 

void loop() 
{  
  // Sender kurz ausschalten um Störungen des Signals zu vermeiden   
  digitalWrite(SENDEN, LOW);
  delay(10); 

  // Signal für 10 Mikrosekunden senden 
  digitalWrite(SENDEN, HIGH); 
  delayMicroseconds(10);

  // Sender ausschalten
  digitalWrite(SENDEN, LOW); 

  // pulseIn ⇒ Zeit messen, bis das Signal zurückkommt 
  Zeit = pulseIn(ECHO, HIGH);

  /*
    Entfernung in cm berechnen   
    Zeit/2 ⇒ nur eine Strecke soll berechnet werden      
    Umrechnung in cm  
  */ 
  Entfernung = (Zeit / 2) * 0.03432;   

  if (Entfernung < 200) 
  {  
    // Ausgabe auf dem Seriellen Monitor 
    Serial.print ("Entfernung: ");     
    Serial.print(Entfernung); 
    Serial.println(" cm"); 
    delay(500);  
    tone(LAUTSPRECHER, map(Entfernung, 1, 200, 200, 1000), 500);
  }
}

Letzte Aktualisierung: