4-Digit-Display TM1637

Das ist ein Programm mit dem 4-Digit-Display TM1637. Als Contoller dient ein ESP32. Im Display wird die Uhrzeit von einem NTP-Server, das Datum und die Temperatur von einem DHT11 abwechselnd angezeigt.

Hardware

Die Hardware für dieses Projekt:

• 1 x ESP32
• 1 x 4 Digit-Display TM1637
• 1 x DHT11

Programm

C++ Code für das 4-Digit-Display

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: TM1637 Uhr, Datum und Temperatur
**************************************************************************************************
Version: 21.05.2022
**************************************************************************************************
Board: ESP32vn IoT UNO
**************************************************************************************************
Libraries:
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A159 TM1637 Clock-DHT11\libraries
DHT11
TM1637
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************/

#include <WiFi.h>
#include "time.h"
#include <TM1637Display.h>

#include <Adafruit_Sensor.h>
#include <DHT.h>


const char* ssid = "xxx";
const char* password = "xxx";
const char* ntp_server = "de.pool.ntp.org";

// lokale Zeitzone definieren
// https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
#define TIMEZONE "CET-1CEST,M3.5.0/02,M10.5.0/03"

#define CLK_PIN 18
#define DIO_PIN 5
TM1637Display display(CLK_PIN, DIO_PIN);  // Datenstruktur für Display


#define DHTPIN 4
int temperature_celsius;
int temperature_fahrenheit;

// Celsius Symbol:
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};

// Fahrenheit Symbol:
const uint8_t fahrenheit[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_E | SEG_F | SEG_G   // F
};

#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)
DHT dht = DHT(DHTPIN, DHTTYPE);

void setup() {
  struct tm tdata;

  Serial.begin(115200);

  // mit dem WLAN verbinden; nach Ermitteln der Zeit kann die
  // Verbindung wieder getrennt werden
  Serial.printf("Verbindung herstellen mit %s ", ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
  }
  Serial.println(" Verbunden!");

  // Zeit vom NTP-Server holen
  configTime(0, 0, ntp_server);
  // vor Trennung des WLANs einmal getLocalTime()
  // aufrufen; sonst wird die Zeit nicht übernommen
  getLocalTime(&tdata);
  setenv("TZ", TIMEZONE, 1);  // Zeitzone einstellen

  // WLAN trennen
  WiFi.disconnect(true);
  WiFi.mode(WIFI_OFF);

  // Display auf mittl. Helligkeit einstellen 0-7
  display.setBrightness(1);

  display.clear();
  // Setup Sensor:
  dht.begin();

}

void loop() {
  struct tm tdata;

  if (!getLocalTime(&tdata)) {
    Serial.println("Fehler beim Ermitteln der Zeit");
    delay (10000);
  } else {
    // Zeit als Zahl HHMM mit Doppelpunkt in der Mitte und führenden Nullen
    // (sonst werden Zeiten in der ersten Stunde als xx statt 00:xx angezeigt)
    display.showNumberDecEx((tdata.tm_hour)*100 + tdata.tm_min, 0b01000000, true);
    delay(3000);
    // Datum als Zahl TTMM mit führender Null
    display.showNumberDec(tdata.tm_mday*100 + tdata.tm_mon+1, true);
    delay(3000);

  // Temperature einlesen:
  temperature_celsius = dht.readTemperature();
  temperature_fahrenheit = dht.readTemperature(true);



  // Serieller Monitor:
  Serial.print("Temperatur: ");
  Serial.print(temperature_celsius);
  Serial.println ("°C");

  Serial.print("Uhrzeit: ");
  Serial.print(tdata.tm_hour);
  Serial.print(":");
  Serial.println(tdata.tm_min);

  //Serial.println(temperature_fahrenheit);


  // Temperatur am TM1637 display:
  display.showNumberDec(temperature_celsius, false, 2, 0);
  display.setSegments(celsius, 2, 2);

  delay(3000);
/*
  display.showNumberDec(temperature_fahrenheit, false, 2, 0);
  display.setSegments(fahrenheit, 2, 2);

  delay(2000);
*/
 }
}

RAW code

Digitaluhr mit wechselnder Anzeige

Wechselnde Anzeige im 4-Digit-Display TM1637

C++ UNO RTC-Clock

In diesem Projekt wird im drei Sekunden Wechsel die Uhrzeit und die Temperatur auf einem 4-Digit-Display ausgegeben. Optional ist der Anschluss eines RGB-LED-Strips möglich.

Hardware

Die Hardware für die RTC-Clock

• 1 x UNO/NANO
• 1 x 4-Digit-Display TM1637
• 1 x RTC-Modul DS3231 I2C
• 1 x WS2812B RGB-LED Stripe

Verdrahtung

Die Verdrahtung für die DCF77 Clock:

• RTC Modul -> 5V und GND
• RTC Modul SDL -> UNO A4
• RTC Modul SDA -> UNO A5
• Display -> 5V und GND
• Display CLK -> UNO 2
• Display DIO -> UNO 3
• WS2812B -> 5V und GND
• WS2812B DIN-> UNO 7

Programm

C++ RTC Clock

// TM1637 4 digit PINS
#define CLK 2
#define DIO 3

// Display Objekt
RTC_DS3231 rtc;
TM1637Display display = TM1637Display(CLK, DIO);

//*********** NEOPIXEL******************************************
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 7
Adafruit_NeoPixel strip = Adafruit_NeoPixel(20, PIN, NEO_GRB + NEO_KHZ800);

//*********************************************************************************

// Celsius Symbol:
const uint8_t celsius[] = {
  SEG_A | SEG_B | SEG_F | SEG_G,  // Circle
  SEG_A | SEG_D | SEG_E | SEG_F   // C
};


void setup() {

  Serial.begin(115200);

  // RTC Check
  if (! rtc.begin()) {
    Serial.println("RTC-Fehler!");
    while (1);
  }
  // Überprüfe, ob die RTC Stromversorgung ok ist und stelle die Zeit ein:
  if (rtc.lostPower()) {
    Serial.println("RTC Batterie Fehler, stelle die Zeit ein:");
    // Die folgende Zeile setzt die RTC auf das Datum und die Uhrzeit:
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // Diese Zeile setzt die RTC mit einem expliziten Datum & Uhrzeit, z.B. um
    // Jahr, Monat, Tag, Stunde, Minute, Sekunde
    //rtc.adjust(DateTime(2023, 1, 05, 15, 57, 0));
  }

  // Display Helligkeit (0-7):
  display.setBrightness(1);
  // Lösche Display:
  display.clear();
  //*********** NEOPIXEL******************************************
#if defined (__AVR_ATtiny85__)
  if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif

  strip.begin();
  strip.setBrightness(50); //0-255
  strip.show();
  //****************************************************************

  //*********** NEOPIXEL******************************************
  colorWipe(strip.Color(  0,   255, 125)     , 0); // R G B Türkis
  //**************************************************************
}


void loop() {
  // Lese Datum und Zeit
  DateTime now = rtc.now();

  // Zeitformat
  int displaytime = (now.hour() * 100) + now.minute();
  Serial.println(displaytime);
  Serial.print(rtc.getTemperature() - 2); //-2°C Korrektur
  Serial.println(" °C");

  // Anzeige der aktuellen Uhrzeit im 24-Stunden-Format mit aktivierten führenden Nullen und einem Doppelpunkt:
  display.showNumberDecEx(displaytime, 0b11100000, true);

  // Entferne die Codezeilen, wenn  du einen statischen anstelle eines blinkenden Zwischenpunkts wünscht:
  // delay(500);
  // display.showNumberDec(displaytime, true); // Prints displaytime without center colon.
  delay(3000);

  display.showNumberDec(rtc.getTemperature() - 2, false, 2, 0); //-2°C Korrektur
  display.setSegments(celsius, 2, 2);
  delay(3000);

  //*********** NEOPIXEL******************************************
  /*
    // Some example procedures showing how to display to the pixels:
    colorWipe(strip.Color(255, 0, 0), 50); // Red
    colorWipe(strip.Color(0, 255, 0), 50); // Green
    colorWipe(strip.Color(0, 0, 255), 50); // Blue
    //colorWipe(strip.Color(0, 0, 0, 255), 50); // White RGBW
    // Send a theater pixel chase in...
    theaterChase(strip.Color(127, 127, 127), 50); // White
    theaterChase(strip.Color(127, 0, 0), 50); // Red
    theaterChase(strip.Color(0, 0, 127), 50); // Blue
  */

  // rainbow(50);
  // rainbowCycle(10);
  // theaterChaseRainbow(50);
  //***************************************************************

}
//*********** ENDE LOOP *******************************************


  //*********** NEOPIXEL******************************************
// Füllee die LEDs nacheinander mit einer Farbe
void colorWipe(uint32_t c, uint8_t wait) {
  for (uint16_t i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}
/*
  void rainbow(uint8_t wait) {
  uint16_t i, j;

  for (j = 0; j < 256; j++) {
    for (i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i + j) & 255));
    }
    strip.show();
    delay(wait);
  }
  }

  // Slightly different, this makes the rainbow equally distributed throughout
  void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for (j = 0; j < 1 * 5; j++) { // 5 cycles of all colors on wheel
    for (i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
  }

  //Theatre-style crawling lights.
  void theaterChase(uint32_t c, uint8_t wait) {
  for (int j = 0; j < 10; j++) { //do 10 cycles of chasing
    for (int q = 0; q < 3; q++) {
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, c);  //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, 0);      //turn every third pixel off
      }
    }
  }
  }

  //Theatre-style crawling lights with rainbow effect
  void theaterChaseRainbow(uint8_t wait) {
  for (int j = 0; j < 256; j++) {   // cycle all 256 colors in the wheel
    for (int q = 0; q < 3; q++) {
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, Wheel( (i + j) % 255)); //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, 0);      //turn every third pixel off
      }
    }
  }
  }

  // Input a value 0 to 255 to get a color value.
  // The colours are a transition r - g - b - back to r.
  uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  }
*/

RAW code

Set Time RAW code

RTC:

nach oben