Wall-E wecker/lampe/uhr

International Deutsch
1

Guten Tag,
Ich habe mein Erstes projekt gestartet und zwar dieses hier Printables
Ich bin auch ziemlich weit gekommen, allerdings zeigt mir der bildschirm ausschliesslich nur das bild solar energy und einen balken an.Das sytem zeigt aber keinen fehler an.Dennoch funktioniert die lampe nicht, und auch das display zeigt keine uhrzeit an. Es handelt sich um einen Wall-e wecker der die uhrzeit anzeigen soll und eine lampen funktion hat lg snow
Zusammenfassung: Display reagiert nicht auf touch.
Dadurch keine Funktion der Lampe.
System zeigt aber keinen Fehler an.
hier schicke ich mal einen link von meinem code rein: `

/*
 An example digital clock using a TFT LCD screen to show the time.
 Demonstrates use of the font printing routines. (Time updates but date does not.)

 It uses the time of compile/upload to set the time
 For a more accurate clock, it would be better to use the RTClib library.
 But this is just a demo...

 Make sure all the display driver and pin connections are correct by
 editing the User_Setup.h file in the TFT_eSPI library folder.

 #########################################################################
 ###### DON'T FORGET TO UPDATE THE User_Setup.h FILE IN THE LIBRARY ######
 #########################################################################

 Based on clock sketch by Gilchrist 6/2/2014 1.0

A few colour codes:

code	color
0x0000	Black
0xFFFF	White
0xBDF7	Light Gray
0x7BEF	Dark Gray
0xF800	Red
0xFFE0	Yellow
0xFBE0	Orange
0x79E0	Brown
0x7E0	Green
0x7FF	Cyan
0x1F	Blue
0xF81F	Pink

 */
#include "FS.h"
#include "TFT_eSPI.h"
#include "Bitmap.h"
#include "DFRobotDFPlayerMini.h"
#include "RTClib.h"

//================= USEFUL VARIABLES ==========================
uint16_t notification_volume = 25;             //Set volume value. From 0 to 30
#define CALIBRATION_FILE "/calibrationData11"  // This is the file name used to store the touch coordinate - Change the name to start a new calibration.

//=============================================================

TFT_eSPI tft = TFT_eSPI();  // Invoke custom library

// Set REPEAT_CAL to true instead of false to run calibration
// again, otherwise it will only be done once.
// Repeat calibration if you change the screen rotation.
#define REPEAT_CAL false
#define FPSerial Serial1

const byte RXD2 = 16;  // Connects to module's TX => 16
const byte TXD2 = 17;  // Connects to module's RX => 17

DFRobotDFPlayerMini myDFPlayer;
void printDetail(uint8_t type, int value);

RTC_DS3231 rtc;

byte omm = 99, oss = 99;
byte xcolon = 0, xsecs = 0;
unsigned int colour = 0;
int mode = 0;
int valide = 1;
int toggle_lamp = 0;
int toggle_alarm = 0;
int Play_finished = 0;
uint16_t calibrationData[5];
uint8_t calDataOK = 0;
int hour = 0;
int minute = 0;
int play = 0;
int alarm_set = 0;
int font_val = 7;
uint16_t x = 0, y = 0;
uint32_t targetTime = 0;
int hh;
int mm;
int ss;
int stop = 1;
int alarm_stop = 0;
int alarm_active = 0;
int valide_clock = 1;
int valide_volume = 1;

void setup(void) {

  pinMode(33, OUTPUT);
  pinMode(35, INPUT);

  Serial.begin(115200);
  Serial.println("let's go");

  tft.init();
  tft.setRotation(1);

  // call screen calibration
  touch_calibrate();

  //Fill the screen with black
  tft.fillScreen(TFT_BLACK);

  rtc.begin();
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  tft.setTextSize(1);
  tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
  tft.setTextColor(0xFDE0, TFT_BLACK);

  targetTime = millis() + 1000;
  delay(1000);
  FPSerial.begin(9600, SERIAL_8N1, RXD2, TXD2);

  Serial.println();
  Serial.println(F("DFRobot DFPlayer Mini Demo"));
  Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));

  if (!myDFPlayer.begin(FPSerial, /*isACK = */ true, /*doReset = */ true)) {  //Use serial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while (true) {
      delay(0);
    }
  }

  Serial.println(F("DFPlayer Mini online."));
  myDFPlayer.volume(notification_volume);
  myDFPlayer.setTimeOut(500);  // Définit un temps de time out sur la communication série à 500 ms
  Serial.println(myDFPlayer.readFileCounts());
  Serial.println(myDFPlayer.readCurrentFileNumber());

  delay(1000);
  myDFPlayer.playMp3Folder(1);  //Play the first mp3
}

void loop() {

  DateTime now = rtc.now();

  hh = now.hour();
  mm = now.minute();
  ss = now.second();

  // tft.fillRect(10, 200, 50, 40, TFT_BLACK);
  // Serial.println(analogRead(35));
  // tft.setTextColor(0xFFFF);
  // tft.drawNumber(analogRead(35), 20, 210, 2);

  if (alarm_active == 1) { alarm_rings(); }

  set_time();

  // Setup the alarm
  if (tft.getTouch(&x, &y)) {
    if ((x > 20) && (x < 165)) {
      if ((y > 150) && (y < 210)) {
        set_alarm();
        delay(200);
      }
    }
  }

  // Change the volume
  if (tft.getTouch(&x, &y)) {
    if ((x > 190) && (x < 320)) {
      if ((y > 30) && (y < 240)) {
        myDFPlayer.playMp3Folder(random(5, 9));
        delay(200);
        volume_notification();
      }
    }
  }

  // Switch on the bulb or stop the alarm
  if (tft.getTouch(&x, &y) && toggle_lamp == 0) {
    if ((x > 100) && (x < 170)) {
      if ((y > 50) && (y < 120)) {
        digitalWrite(33, HIGH);
        toggle_lamp = 1;
        delay(500);
        myDFPlayer.playMp3Folder(2);
        delay(200);
      }
    }
  }

  // Switch off the bulb or stop the alarm
  if (tft.getTouch(&x, &y) && toggle_lamp == 1) {
    if ((x > 100) && (x < 170)) {
      if ((y > 50) && (y < 120)) {
        digitalWrite(33, LOW);
        toggle_lamp = 0;
        delay(150);
      }
    }
  }
}

void volume_notification() {
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(0xFDE0);
  tft.drawString("Volume", 122, 10, 4);
  tft.drawRect(270, 190, 50, 50, 0xFDE0);
  tft.drawString("OK", 276, 205, 4);
  tft.fillTriangle(140, 80, 160, 40, 180, 80, 0xFDE0);
  tft.fillTriangle(140, 190, 160, 230, 180, 190, 0xFDE0);

  while (valide_volume) {

    tft.drawNumber(notification_volume, 125, 110, font_val);  // Draw volume value between 0 and 30

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 190) && (y < 240)) {
          valide_volume = 0;
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 120) && (x < 160)) {
        if ((y > 30) && (y < 100)) {
          notification_volume = notification_volume + 1;
          if (notification_volume > 30) { notification_volume = 30; }
          Serial.print("notification_volume : ");
          Serial.print(notification_volume);
          tft.fillRect(20, 100, 300, 80, TFT_BLACK);
          delay(50);
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 120) && (x < 160)) {
        if ((y > 180) && (y < 240)) {
          notification_volume = notification_volume - 1;
          if (notification_volume < 0) { notification_volume = 0; }
          Serial.print("notification_volume : ");
          Serial.print(notification_volume);
          tft.fillRect(20, 100, 300, 80, TFT_BLACK);
          delay(50);
        }
      }
    }
  }

  myDFPlayer.volume(notification_volume);
  valide_volume = 1;
  myDFPlayer.playMp3Folder(random(5, 9));
  delay(100);
  tft.fillScreen(TFT_BLACK);
  tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
  alarm_set = 1;
  set_time();
}

void alarm_rings() {
  if (hh == hour && mm == minute && play == 0) {
    myDFPlayer.playMp3Folder(random(3, 5));
    delay(200);
    while (stop) {
      // Switch on the bulb
      if (tft.getTouch(&x, &y)) {
        if ((x > 100) && (x < 170)) {
          if ((y > 50) && (y < 120)) {
            myDFPlayer.stop();
            delay(200);
            stop = 0;
          }
        }
      }
    }
    play = 1;
    stop = 1;
    Serial.println("boucle alarm rings");
    Serial.println(play);
  }
}

void battery_tester() {
  if (analogRead(35) > 2250) {
    for (int gap = 0; gap <= 135; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2250 && analogRead(35) > 2225) {
    tft.fillRect(195, 52, 113, 8, TFT_BLACK);

    for (int gap = 0; gap <= 120; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2225 && analogRead(35) > 2200) {

    for (int gap = 0; gap <= 15; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 105; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2200 && analogRead(35) > 2175) {

    for (int gap = 0; gap <= 30; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 90; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2175 && analogRead(35) > 2150) {

    for (int gap = 0; gap <= 45; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 75; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2150 && analogRead(35) > 2125) {

    for (int gap = 0; gap <= 60; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 60; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2125 && analogRead(35) > 2100) {

    for (int gap = 0; gap <= 75; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 30; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2100 && analogRead(35) > 2075) {

    for (int gap = 0; gap <= 90; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 15; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2075 && analogRead(35) > 2000) {

    for (int gap = 0; gap <= 105; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    tft.fillRect(195, 187, 113, 8, 0xFDE0);
  }

  if (analogRead(35) < 2000) {
    for (int gap = 0; gap <= 135; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }
  }
}

void set_alarm() {
  int triangle_w = 60;
  int triangle_h = 40;

  int triangle1_x = 50;
  int triangle1_y = 80;

  int triangle2_x = 200;
  int triangle2_y = 80;

  int triangle3_x = 50;
  int triangle3_y = 170;

  int triangle4_x = 200;
  int triangle4_y = 170;

  Serial.println("SET ALARM");
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(0xFDE0);
  tft.drawString("Alarm setup", 95, 10, 4);
  tft.drawRect(270, 190, 50, 50, 0xFDE0);
  tft.drawString("OK", 276, 205, 4);
  tft.drawRect(117, 200, 80, 30, 0xFDE0);

  tft.fillTriangle(triangle1_x, triangle1_y, triangle1_x + (triangle_w / 2), triangle1_y - triangle_h, triangle1_x + triangle_w, triangle1_y, 0xFDE0);
  tft.fillTriangle(triangle2_x, triangle2_y, triangle2_x + (triangle_w / 2), triangle2_y - triangle_h, triangle2_x + triangle_w, triangle2_y, 0xFDE0);
  tft.fillTriangle(triangle3_x, triangle3_y, triangle3_x + (triangle_w / 2), triangle3_y + triangle_h, triangle3_x + triangle_w, triangle3_y, 0xFDE0);
  tft.fillTriangle(triangle4_x, triangle4_y, triangle4_x + (triangle_w / 2), triangle4_y + triangle_h, triangle4_x + triangle_w, triangle4_y, 0xFDE0);

  tft.fillTriangle(280, 100, 310, 120, 280, 140, 0xFDE0);

  while (valide) {
    // Update digital time
    int x_alarm = 90;
    int y_alarm = 100;  // Top left corner ot clock text, about half way down
    // Draw hours and minutes
    if (hour < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add hours leading zero for 24 hr clock
    x_alarm += tft.drawNumber(hour, x_alarm, y_alarm, font_val);              // Draw hours
    xcolon = x_alarm;                                                         // Save colon coord for later to flash on/off later
    x_alarm += tft.drawChar(':', x_alarm, y_alarm, font_val);
    if (minute < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add minutes leading zero
    x_alarm += tft.drawNumber(minute, x_alarm, y_alarm, font_val);              // Draw minutes

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 190) && (y < 240)) {
          valide = 0;
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 30) && (y < 120)) {
          hour = hour + 1;
          Serial.print("hour : ");
          Serial.print(hour);
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);

          if (hour > 23) { hour = 0; }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 140) && (y < 240)) {
          hour = hour - 1;
          Serial.print("hour : ");
          Serial.print(hour);
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
          if (hour < 0) { hour = 23; }
        }
      }
    }
    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 260)) {
        if ((y > 30) && (y < 120)) {
          minute = minute + 1;
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
          if (minute > 59) { minute = 0; }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 240)) {
        if ((y > 140) && (y < 220)) {
          minute = minute - 1;
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
          if (minute < 0) { minute = 59; }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 110) && (x < 210)) {
        if ((y > 170) && (y < 240)) {
          if (alarm_active == 0) {
            alarm_active = 1;
            tft.fillRect(118, 201, 39, 28, TFT_BLACK);
            tft.fillRect(159, 201, 39, 28, 0xFDE0);
            delay(200);
          }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 110) && (x < 210)) {
        if ((y > 170) && (y < 240)) {
          if (alarm_active == 1) {
            alarm_active = 0;
            tft.fillRect(159, 201, 37, 28, TFT_BLACK);
            tft.fillRect(118, 201, 39, 28, 0x31A6);
            delay(200);
          }
        }
      }
    }

    if (alarm_active == 1) {
      tft.fillRect(118, 201, 39, 28, TFT_BLACK);
      tft.fillRect(159, 201, 39, 28, 0xFDE0);
    }

    if (alarm_active == 0) {
      tft.fillRect(159, 201, 37, 28, TFT_BLACK);
      tft.fillRect(118, 201, 39, 28, 0x31A6);
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 90) && (y < 140)) {
          clock_setup();
          valide = 0;
        }
      }
    }
  }

  Serial.println("Set alarm out");
  tft.fillScreen(TFT_BLACK);
  tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
  valide = 1;
  alarm_set = 1;
  set_time();
}

void set_time() {

  DateTime now = rtc.now();
  hh = now.hour();
  mm = now.minute();
  ss = now.second();

  if (targetTime < millis()) {
    // Set next update for 1 second later
    targetTime = millis() + 1000;

    // Adjust the time values by adding 1 second
    ss++;             // Advance second
    if (ss == 60) {   // Check for roll-over
      ss = 0;         // Reset seconds to zero
      omm = mm;       // Save last minute time for display update
      mm++;           // Advance minute
      if (mm > 59) {  // Check for roll-over
        mm = 0;
        hh++;           // Advance hour
        if (hh > 23) {  // Check for 24hr roll-over (could roll-over on 13)
          hh = 0;       // 0 for 24 hour clock, set to 1 for 12 hour clock
        }
      }
    }

    // Update digital time
    int xpos = 20;
    int ypos = 150;  // Top left corner ot clock text, about half way down
    int ysecs = ypos + 24;
    Serial.println("Entree set time");
    Serial.println(play);
    if (omm != mm || alarm_set == 1) {  // Redraw hours and minutes time every minute
      omm = mm;
      battery_tester();
      if (alarm_set == 1) { tft.fillRect(10, 150, 160, 50, TFT_BLACK); }
      if (play == 1) { delay(2000); }
      play = 0;
      alarm_set = 0;
      // Draw hours and minutes
      if (hh < 10) xpos += tft.drawChar('0', xpos, ypos, font_val);  // Add hours leading zero for 24 hr clock
      xpos += tft.drawNumber(hh, xpos, ypos, font_val);              // Draw hours
      xcolon = xpos;                                                 // Save colon coord for later to flash on/off later
      xpos += tft.drawChar(':', xpos, ypos, font_val);
      if (mm < 10) xpos += tft.drawChar('0', xpos, ypos, font_val);  // Add minutes leading zero
      xpos += tft.drawNumber(mm, xpos, ypos, font_val);              // Draw minutes
      xsecs = xpos;                                                  // Sae seconds 'x' position for later display updates
    }
    if (oss != ss) {  // Redraw seconds time every second
      oss = ss;
      xpos = xsecs;

      if (ss % 2) {                                 // Flash the colons on/off
        tft.setTextColor(TFT_BLACK, TFT_BLACK);     // Set colour to grey to dim colon
        tft.drawChar(':', xcolon, ypos, font_val);  // Hour:minute colon
        //xpos += tft.drawChar(':', xsecs, ysecs, 6); // Seconds colon
        tft.setTextColor(0xFDE0, TFT_BLACK);  // Set colour back to yellow

      } else {
        tft.drawChar(':', xcolon, ypos, font_val);  // Hour:minute colon
        // xpos += tft.drawChar(':', xsecs, ysecs, 6); // Seconds colon
      }

      //Draw seconds
      // if (ss < 10) xpos += tft.drawChar('0', xpos, ysecs, 6); // Add leading zero
      // tft.drawNumber(ss, xpos, ysecs, 6);                     // Draw seconds
    }
  }
}

void clock_setup() {

  int triangle_w = 60;
  int triangle_h = 40;

  int triangle1_x = 50;
  int triangle1_y = 80;

  int triangle2_x = 200;
  int triangle2_y = 80;

  int triangle3_x = 50;
  int triangle3_y = 170;

  int triangle4_x = 200;
  int triangle4_y = 170;

  DateTime now = rtc.now();

  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(0xFDE0);
  tft.drawString("Clock setup", 95, 10, 4);
  tft.drawRect(270, 190, 50, 50, 0xFDE0);
  tft.drawString("OK", 276, 205, 4);

  tft.fillTriangle(triangle1_x, triangle1_y, triangle1_x + (triangle_w / 2), triangle1_y - triangle_h, triangle1_x + triangle_w, triangle1_y, 0xFDE0);
  tft.fillTriangle(triangle2_x, triangle2_y, triangle2_x + (triangle_w / 2), triangle2_y - triangle_h, triangle2_x + triangle_w, triangle2_y, 0xFDE0);
  tft.fillTriangle(triangle3_x, triangle3_y, triangle3_x + (triangle_w / 2), triangle3_y + triangle_h, triangle3_x + triangle_w, triangle3_y, 0xFDE0);
  tft.fillTriangle(triangle4_x, triangle4_y, triangle4_x + (triangle_w / 2), triangle4_y + triangle_h, triangle4_x + triangle_w, triangle4_y, 0xFDE0);

  while (valide_clock) {
    // Update digital time
    int x_alarm = 90;
    int y_alarm = 100;  // Top left corner ot clock text, about half way down
    // Draw hours and minutes
    if (hh < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add hours leading zero for 24 hr clock
    x_alarm += tft.drawNumber(hh, x_alarm, y_alarm, font_val);              // Draw hours
    xcolon = x_alarm;                                                       // Save colon coord for later to flash on/off later
    x_alarm += tft.drawChar(':', x_alarm, y_alarm, font_val);
    if (mm < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add minutes leading zero
    x_alarm += tft.drawNumber(mm, x_alarm, y_alarm, font_val);              // Draw minutes

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 190) && (y < 240)) {
          valide_clock = 0;
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 30) && (y < 120)) {
          hh = hh + 1;
          if (hh > 23) { hh = 0; }
          Serial.print("hh : ");
          Serial.print(hh);
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 140) && (y < 240)) {
          hh = hh - 1;
          if (hh < 0) { hh = 23; }
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          Serial.print("hh : ");
          Serial.print(hh);
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }
    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 260)) {
        if ((y > 30) && (y < 120)) {
          mm = mm + 1;
          if (mm > 59) { mm = 0; }
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 240)) {
        if ((y > 140) && (y < 220)) {
          mm = mm - 1;
          if (mm < 0) { mm = 59; }
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }
  }

  valide_clock = 1;
}

void touch_calibrate() {
  uint16_t calData[5];
  uint8_t calDataOK = 0;

  // check file system exists
  if (!SPIFFS.begin()) {
    Serial.println("Formatting file system");
    SPIFFS.format();
    SPIFFS.begin();
  }

  // check if calibration file exists and size is correct
  if (SPIFFS.exists(CALIBRATION_FILE)) {
    if (REPEAT_CAL) {
      // Delete if we want to re-calibrate
      SPIFFS.remove(CALIBRATION_FILE);
    } else {
      File f = SPIFFS.open(CALIBRATION_FILE, "r");
      if (f) {
        if (f.readBytes((char *)calData, 14) == 14)
          calDataOK = 1;
        f.close();
      }
    }
  }

  if (calDataOK && !REPEAT_CAL) {
    // calibration data valid
    tft.setTouch(calData);
  } else {
    // data not valid so recalibrate
    tft.fillScreen(TFT_BLACK);
    tft.setCursor(20, 0);
    tft.setTextFont(2);
    tft.setTextSize(1);
    tft.setTextColor(TFT_WHITE, TFT_BLACK);

    tft.println("Touch corners as indicated");

    tft.setTextFont(1);
    tft.println();

    if (REPEAT_CAL) {
      tft.setTextColor(TFT_RED, TFT_BLACK);
      tft.println("Set REPEAT_CAL to false to stop this running again!");
    }

    tft.calibrateTouch(calData, TFT_MAGENTA, TFT_BLACK, 15);

    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.println("Calibration complete!");

    // store data
    File f = SPIFFS.open(CALIBRATION_FILE, "w");
    if (f) {
      f.write((const unsigned char *)calData, 14);
      f.close();
    }
  }
}

// Function to extract numbers from compile time string
static uint8_t conv2d(const char *p) {
  uint8_t v = 0;
  if ('0' <= *p && *p <= '9')
    v = *p - '0';
  return 10 * v + *++p - '0';
}

void printDetail(uint8_t type, int value) {
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      break;
    case DFPlayerUSBInserted:
      Serial.println("USB Inserted!");
      break;
    case DFPlayerUSBRemoved:
      Serial.println("USB Removed!");
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      Play_finished = 1;
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
}

void waitMilliseconds(uint16_t msWait) {
  uint32_t start = millis();

  while ((millis() - start) < msWait) {
    // calling mp3.loop() periodically allows for notifications
    // to be handled without interrupts
    delay(1);
  }
}

`

2

Setze Deinen Code bitte direkt ins Forum in Codetags. Wie das geht, steht hier.

Eine Klasse Printable gibt es bereits im Arduino Core, da könnte die Gefahr einer Verwechslung bestehen.

Gruß Tommy

3

Für ein erstes Projekt ist das ziemlich umfangreich und unübersichtlich. Kannst Du nicht die einzelnen Module separat testen, bevor Du alles zusammenwirfst? Zuerst also die Beispielprogramme zu den Bibliotheken zum Laufen bringen...

4

Ändere bitte deinen Titel und schreibe kurz, welches Problem du hast.
Dann wird deine Frage besser gefunden und du bekommst schneller Hilfe.
Das du Hilfe brauchst, erkennt man ja daran, dass du dich hier angemeldet hast.

5

Danke für die Antwort..in dem Video hat er es so leicht erklärt ich hab den Grund code ja auch von ihm übernommen. Das einzige was ich machen musste waren da diese 4 Bibliotheken Downloaden...laut system scheint es ja auch funktioniert zu haben...wie würde das denn gehen wenn ich alles einzeln testen würde..?

6

Link bitte zum Display.
Ist der Touch in der User_Setup.h aktiviert?
Was für ESP wird benutzt?

1 Like
7

Lasse die Beispiele zu den Bibliotheken laufen. Wenn die nicht funktionieren, dann weißt Du schon wo etwas faul ist.

8

ESP32
Screen 2.8" 240x320 with touch screen – jéjé l'ingé (jeje-linge.fr)
alle bauteile und die anleitung die ich genutzt habe sind in dem printebles link

9

Hast Glück habe den gleichen vor der Nase :wink:
Jetzt möchte ich die User_Setup.h sehen.
Habe keine Lust das alles auf der Seite durchlesen.

1 Like
10 
//                            USER DEFINED SETTINGS
//   Set driver type, fonts to be loaded, pins used and SPI control method etc.
//
//   See the User_Setup_Select.h file if you wish to be able to define multiple
//   setups and then easily select which setup file is used by the compiler.
//
//   If this file is edited correctly then all the library example sketches should
//   run without the need to make any more changes for a particular hardware setup!
//   Note that some sketches are designed for a particular TFT pixel width/height

// User defined information reported by "Read_User_Setup" test & diagnostics example
#define USER_SETUP_INFO "User_Setup"

// Define to disable all #warnings in library (can be put in User_Setup_Select.h)
//#define DISABLE_ALL_LIBRARY_WARNINGS

// ##################################################################################
//
// Section 1. Call up the right driver file and any options for it
//
// ##################################################################################

// Define STM32 to invoke optimised processor support (only for STM32)
//#define STM32

// Defining the STM32 board allows the library to optimise the performance
// for UNO compatible "MCUfriend" style shields
//#define NUCLEO_64_TFT
//#define NUCLEO_144_TFT

// STM32 8-bit parallel only:
// If STN32 Port A or B pins 0-7 are used for 8-bit parallel data bus bits 0-7
// then this will improve rendering performance by a factor of ~8x
//#define STM_PORTA_DATA_BUS
//#define STM_PORTB_DATA_BUS

// Tell the library to use parallel mode (otherwise SPI is assumed)
//#define TFT_PARALLEL_8_BIT
//#defined TFT_PARALLEL_16_BIT // **** 16-bit parallel ONLY for RP2040 processor ****

// Display type -  only define if RPi display
//#define RPI_DISPLAY_TYPE // 20MHz maximum SPI

// Only define one driver, the other ones must be commented out
#define ILI9341_DRIVER       // Generic driver for common displays
//#define ILI9341_2_DRIVER     // Alternative ILI9341 driver, see https://github.com/Bodmer/TFT_eSPI/issues/1172
//#define ST7735_DRIVER      // Define additional parameters below for this display
//#define ILI9163_DRIVER     // Define additional parameters below for this display
//#define S6D02A1_DRIVER
//#define RPI_ILI9486_DRIVER // 20MHz maximum SPI
//#define HX8357D_DRIVER
//#define ILI9481_DRIVER
//#define ILI9486_DRIVER
//#define ILI9488_DRIVER     // WARNING: Do not connect ILI9488 display SDO to MISO if other devices share the SPI bus (TFT SDO does NOT tristate when CS is high)
//#define ST7789_DRIVER      // Full configuration option, define additional parameters below for this display
//#define ST7789_2_DRIVER    // Minimal configuration option, define additional parameters below for this display
//#define R61581_DRIVER
//#define RM68140_DRIVER
//#define ST7796_DRIVER
//#define SSD1351_DRIVER
//#define SSD1963_480_DRIVER
//#define SSD1963_800_DRIVER
//#define SSD1963_800ALT_DRIVER
//#define ILI9225_DRIVER
//#define GC9A01_DRIVER

// Some displays support SPI reads via the MISO pin, other displays have a single
// bi-directional SDA pin and the library will try to read this via the MOSI line.
// To use the SDA line for reading data from the TFT uncomment the following line:

// #define TFT_SDA_READ      // This option is for ESP32 ONLY, tested with ST7789 and GC9A01 display only

// For ST7735, ST7789 and ILI9341 ONLY, define the colour order IF the blue and red are swapped on your display
// Try ONE option at a time to find the correct colour order for your display

//  #define TFT_RGB_ORDER TFT_RGB  // Colour order Red-Green-Blue
//  #define TFT_RGB_ORDER TFT_BGR  // Colour order Blue-Green-Red

// For M5Stack ESP32 module with integrated ILI9341 display ONLY, remove // in line below

// #define M5STACK

// For ST7789, ST7735, ILI9163 and GC9A01 ONLY, define the pixel width and height in portrait orientation
// #define TFT_WIDTH  80
// #define TFT_WIDTH  128
// #define TFT_WIDTH  172 // ST7789 172 x 320
// #define TFT_WIDTH  170 // ST7789 170 x 320
// #define TFT_WIDTH  240 // ST7789 240 x 240 and 240 x 320
// #define TFT_HEIGHT 160
// #define TFT_HEIGHT 128
// #define TFT_HEIGHT 240 // ST7789 240 x 240
// #define TFT_HEIGHT 320 // ST7789 240 x 320
// #define TFT_HEIGHT 240 // GC9A01 240 x 240

// For ST7735 ONLY, define the type of display, originally this was based on the
// colour of the tab on the screen protector film but this is not always true, so try
// out the different options below if the screen does not display graphics correctly,
// e.g. colours wrong, mirror images, or stray pixels at the edges.
// Comment out ALL BUT ONE of these options for a ST7735 display driver, save this
// this User_Setup file, then rebuild and upload the sketch to the board again:

// #define ST7735_INITB
// #define ST7735_GREENTAB
// #define ST7735_GREENTAB2
// #define ST7735_GREENTAB3
// #define ST7735_GREENTAB128    // For 128 x 128 display
// #define ST7735_GREENTAB160x80 // For 160 x 80 display (BGR, inverted, 26 offset)
// #define ST7735_ROBOTLCD       // For some RobotLCD Arduino shields (128x160, BGR, https://docs.arduino.cc/retired/getting-started-guides/TFT)
// #define ST7735_REDTAB
// #define ST7735_BLACKTAB
// #define ST7735_REDTAB160x80   // For 160 x 80 display with 24 pixel offset

// If colours are inverted (white shows as black) then uncomment one of the next
// 2 lines try both options, one of the options should correct the inversion.

// #define TFT_INVERSION_ON
// #define TFT_INVERSION_OFF


// ##################################################################################
//
// Section 2. Define the pins that are used to interface with the display here
//
// ##################################################################################

// If a backlight control signal is available then define the TFT_BL pin in Section 2
// below. The backlight will be turned ON when tft.begin() is called, but the library
// needs to know if the LEDs are ON with the pin HIGH or LOW. If the LEDs are to be
// driven with a PWM signal or turned OFF/ON then this must be handled by the user
// sketch. e.g. with digitalWrite(TFT_BL, LOW);

// #define TFT_BL   32            // LED back-light control pin
// #define TFT_BACKLIGHT_ON HIGH  // Level to turn ON back-light (HIGH or LOW)



// We must use hardware SPI, a minimum of 3 GPIO pins is needed.
// Typical setup for ESP8266 NodeMCU ESP-12 is :
//
// Display SDO/MISO  to NodeMCU pin D6 (or leave disconnected if not reading TFT)
// Display LED       to NodeMCU pin VIN (or 5V, see below)
// Display SCK       to NodeMCU pin D5
// Display SDI/MOSI  to NodeMCU pin D7
// Display DC (RS/AO)to NodeMCU pin D3
// Display RESET     to NodeMCU pin D4 (or RST, see below)
// Display CS        to NodeMCU pin D8 (or GND, see below)
// Display GND       to NodeMCU pin GND (0V)
// Display VCC       to NodeMCU 5V or 3.3V
//
// The TFT RESET pin can be connected to the NodeMCU RST pin or 3.3V to free up a control pin
//
// The DC (Data Command) pin may be labelled AO or RS (Register Select)
//
// With some displays such as the ILI9341 the TFT CS pin can be connected to GND if no more
// SPI devices (e.g. an SD Card) are connected, in this case comment out the #define TFT_CS
// line below so it is NOT defined. Other displays such at the ST7735 require the TFT CS pin
// to be toggled during setup, so in these cases the TFT_CS line must be defined and connected.
//
// The NodeMCU D0 pin can be used for RST
//
//
// Note: only some versions of the NodeMCU provide the USB 5V on the VIN pin
// If 5V is not available at a pin you can use 3.3V but backlight brightness
// will be lower.


// ###### EDIT THE PIN NUMBERS IN THE LINES FOLLOWING TO SUIT YOUR ESP8266 SETUP ######

// For NodeMCU - use pin numbers in the form PIN_Dx where Dx is the NodeMCU pin designation
#define TFT_MISO  PIN_D6  // Automatically assigned with ESP8266 if not defined
#define TFT_MOSI  PIN_D7  // Automatically assigned with ESP8266 if not defined
#define TFT_SCLK  PIN_D5  // Automatically assigned with ESP8266 if not defined

#define TFT_CS    PIN_D8  // Chip select control pin D8
#define TFT_DC    PIN_D3  // Data Command control pin
#define TFT_RST   PIN_D4  // Reset pin (could connect to NodeMCU RST, see next line)
//#define TFT_RST  -1     // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V


//#define TFT_BL PIN_D1  // LED back-light (only for ST7789 with backlight control pin)

//#define TOUCH_CS PIN_D2     // Chip select pin (T_CS) of touch screen

//#define TFT_WR PIN_D2       // Write strobe for modified Raspberry Pi TFT only


// ######  FOR ESP8266 OVERLAP MODE EDIT THE PIN NUMBERS IN THE FOLLOWING LINES  ######

// Overlap mode shares the ESP8266 FLASH SPI bus with the TFT so has a performance impact
// but saves pins for other functions. It is best not to connect MISO as some displays
// do not tristate that line when chip select is high!
// Note: Only one SPI device can share the FLASH SPI lines, so a SPI touch controller
// cannot be connected as well to the same SPI signals.
// On NodeMCU 1.0 SD0=MISO, SD1=MOSI, CLK=SCLK to connect to TFT in overlap mode
// On NodeMCU V3  S0 =MISO, S1 =MOSI, S2 =SCLK
// In ESP8266 overlap mode the following must be defined

//#define TFT_SPI_OVERLAP

// In ESP8266 overlap mode the TFT chip select MUST connect to pin D3
//#define TFT_CS   PIN_D3
//#define TFT_DC   PIN_D5  // Data Command control pin
//#define TFT_RST  PIN_D4  // Reset pin (could connect to NodeMCU RST, see next line)
//#define TFT_RST  -1  // Set TFT_RST to -1 if the display RESET is connected to NodeMCU RST or 3.3V


// ###### EDIT THE PIN NUMBERS IN THE LINES FOLLOWING TO SUIT YOUR ESP32 SETUP   ######

// For ESP32 Dev board (only tested with ILI9341 display)
// The hardware SPI can be mapped to any pins

#define TFT_MISO 19
#define TFT_MOSI 23
#define TFT_SCLK 18
#define TFT_CS   15  // Chip select control pin
#define TFT_DC    2  // Data Command control pin
#define TFT_RST   4  // Reset pin (could connect to RST pin)
//#define TFT_RST  -1  // Set TFT_RST to -1 if display RESET is connected to ESP32 board RST

// For ESP32 Dev board (only tested with GC9A01 display)
// The hardware SPI can be mapped to any pins

//#define TFT_MOSI 15 // In some display driver board, it might be written as "SDA" and so on.
//#define TFT_SCLK 14
//#define TFT_CS   5  // Chip select control pin
//#define TFT_DC   27  // Data Command control pin
//#define TFT_RST  33  // Reset pin (could connect to Arduino RESET pin)
//#define TFT_BL   22  // LED back-light

#define TOUCH_CS 5     // Chip select pin (T_CS) of touch screen

//#define TFT_WR 22    // Write strobe for modified Raspberry Pi TFT only

// For the M5Stack module use these #define lines
//#define TFT_MISO 19
//#define TFT_MOSI 23
//#define TFT_SCLK 18
//#define TFT_CS   14  // Chip select control pin
//#define TFT_DC   27  // Data Command control pin
//#define TFT_RST  33  // Reset pin (could connect to Arduino RESET pin)
//#define TFT_BL   32  // LED back-light (required for M5Stack)

// ######       EDIT THE PINs BELOW TO SUIT YOUR ESP32 PARALLEL TFT SETUP        ######

// The library supports 8-bit parallel TFTs with the ESP32, the pin
// selection below is compatible with ESP32 boards in UNO format.
// Wemos D32 boards need to be modified, see diagram in Tools folder.
// Only ILI9481 and ILI9341 based displays have been tested!

// Parallel bus is only supported for the STM32 and ESP32
// Example below is for ESP32 Parallel interface with UNO displays

// Tell the library to use 8-bit parallel mode (otherwise SPI is assumed)
//#define TFT_PARALLEL_8_BIT

// The ESP32 and TFT the pins used for testing are:
//#define TFT_CS   33  // Chip select control pin (library pulls permanently low
//#define TFT_DC   15  // Data Command control pin - must use a pin in the range 0-31
//#define TFT_RST  32  // Reset pin, toggles on startup

//#define TFT_WR    4  // Write strobe control pin - must use a pin in the range 0-31
//#define TFT_RD    2  // Read strobe control pin

//#define TFT_D0   12  // Must use pins in the range 0-31 for the data bus
//#define TFT_D1   13  // so a single register write sets/clears all bits.
//#define TFT_D2   26  // Pins can be randomly assigned, this does not affect
//#define TFT_D3   25  // TFT screen update performance.
//#define TFT_D4   17
//#define TFT_D5   16
//#define TFT_D6   27
//#define TFT_D7   14

// ######       EDIT THE PINs BELOW TO SUIT YOUR STM32 SPI TFT SETUP        ######

// The TFT can be connected to SPI port 1 or 2
//#define TFT_SPI_PORT 1 // SPI port 1 maximum clock rate is 55MHz
//#define TFT_MOSI PA7
//#define TFT_MISO PA6
//#define TFT_SCLK PA5

//#define TFT_SPI_PORT 2 // SPI port 2 maximum clock rate is 27MHz
//#define TFT_MOSI PB15
//#define TFT_MISO PB14
//#define TFT_SCLK PB13

// Can use Ardiuno pin references, arbitrary allocation, TFT_eSPI controls chip select
//#define TFT_CS   D5 // Chip select control pin to TFT CS
//#define TFT_DC   D6 // Data Command control pin to TFT DC (may be labelled RS = Register Select)
//#define TFT_RST  D7 // Reset pin to TFT RST (or RESET)
// OR alternatively, we can use STM32 port reference names PXnn
//#define TFT_CS   PE11 // Nucleo-F767ZI equivalent of D5
//#define TFT_DC   PE9  // Nucleo-F767ZI equivalent of D6
//#define TFT_RST  PF13 // Nucleo-F767ZI equivalent of D7

//#define TFT_RST  -1   // Set TFT_RST to -1 if the display RESET is connected to processor reset
                        // Use an Arduino pin for initial testing as connecting to processor reset
                        // may not work (pulse too short at power up?)

// ##################################################################################
//
// Section 3. Define the fonts that are to be used here
//
// ##################################################################################

// Comment out the #defines below with // to stop that font being loaded
// The ESP8366 and ESP32 have plenty of memory so commenting out fonts is not
// normally necessary. If all fonts are loaded the extra FLASH space required is
// about 17Kbytes. To save FLASH space only enable the fonts you need!

#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
//#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT
#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts

// Comment out the #define below to stop the SPIFFS filing system and smooth font code being loaded
// this will save ~20kbytes of FLASH
#define SMOOTH_FONT


// ##################################################################################
//
// Section 4. Other options
//
// ##################################################################################

// For RP2040 processor and SPI displays, uncomment the following line to use the PIO interface.
//#define RP2040_PIO_SPI // Leave commented out to use standard RP2040 SPI port interface

// For RP2040 processor and 8 or 16-bit parallel displays:
// The parallel interface write cycle period is derived from a division of the CPU clock
// speed so scales with the processor clock. This means that the divider ratio may need
// to be increased when overclocking. It may also need to be adjusted dependant on the
// display controller type (ILI94341, HX8357C etc.). If RP2040_PIO_CLK_DIV is not defined
// the library will set default values which may not suit your display.
// The display controller data sheet will specify the minimum write cycle period. The
// controllers often work reliably for shorter periods, however if the period is too short
// the display may not initialise or graphics will become corrupted.
// PIO write cycle frequency = (CPU clock/(4 * RP2040_PIO_CLK_DIV))
//#define RP2040_PIO_CLK_DIV 1 // 32ns write cycle at 125MHz CPU clock
//#define RP2040_PIO_CLK_DIV 2 // 64ns write cycle at 125MHz CPU clock
//#define RP2040_PIO_CLK_DIV 3 // 96ns write cycle at 125MHz CPU clock

// For the RP2040 processor define the SPI port channel used (default 0 if undefined)
//#define TFT_SPI_PORT 1 // Set to 0 if SPI0 pins are used, or 1 if spi1 pins used

// For the STM32 processor define the SPI port channel used (default 1 if undefined)
//#define TFT_SPI_PORT 2 // Set to 1 for SPI port 1, or 2 for SPI port 2

// Define the SPI clock frequency, this affects the graphics rendering speed. Too
// fast and the TFT driver will not keep up and display corruption appears.
// With an ILI9341 display 40MHz works OK, 80MHz sometimes fails
// With a ST7735 display more than 27MHz may not work (spurious pixels and lines)
// With an ILI9163 display 27 MHz works OK.

// #define SPI_FREQUENCY   1000000
// #define SPI_FREQUENCY   5000000
// #define SPI_FREQUENCY  10000000
// #define SPI_FREQUENCY  20000000
#define SPI_FREQUENCY  27000000
// #define SPI_FREQUENCY  40000000
// #define SPI_FREQUENCY  55000000 // STM32 SPI1 only (SPI2 maximum is 27MHz)
// #define SPI_FREQUENCY  80000000

// Optional reduced SPI frequency for reading TFT
#define SPI_READ_FREQUENCY  20000000

// The XPT2046 requires a lower SPI clock rate of 2.5MHz so we define that here:
#define SPI_TOUCH_FREQUENCY  2500000

// The ESP32 has 2 free SPI ports i.e. VSPI and HSPI, the VSPI is the default.
// If the VSPI port is in use and pins are not accessible (e.g. TTGO T-Beam)
// then uncomment the following line:
//#define USE_HSPI_PORT

// Comment out the following #define if "SPI Transactions" do not need to be
// supported. When commented out the code size will be smaller and sketches will
// run slightly faster, so leave it commented out unless you need it!

// Transaction support is needed to work with SD library but not needed with TFT_SdFat
// Transaction support is required if other SPI devices are connected.

// Transactions are automatically enabled by the library for an ESP32 (to use HAL mutex)
// so changing it here has no effect

// #define SUPPORT_TRANSACTIONS
11

Das ist schon Falsch tue das alles kommentieren ( mit // )Du nutz ja ESP32
ist der Touch CS mit GPIO 5 Verbunden?

1 Like
13

ja ist verbunden mit gpio 5

14

O waja das wird Schwierig, mach mall Foto wie das Display angeklemmt ist.
Habe auch gefragt was für ESP das ist.
Versuche mit Dir den Touch zum Laufen bringen, habe kein DFPlayer, mall schauen.

1 Like
15

Ok beim erstem Start sollte Display Kalibrierung erfolgen, war das so?

1 Like
16

ja das kam

IMG-20240530-WA0005
IMG-20240530-WA00051134×2016 343 KB

IMG-20240530-WA0006
IMG-20240530-WA00061134×2016 113 KB

IMG-20240530-WA0007
IMG-20240530-WA00071134×2016 149 KB

17

Dan sollte der Touch funktionieren :thinking:

1 Like
18

bei dem letzten bild sollte eigentlich noch die uhrzeit stehen und der reagiert nicht aufs anklicken
falls es dir hilft kann ich dir auch noch die 4 bibliotheken nennen die ich downloaden sollte?
(voller verzweiflung weil ich schon soweit gekommen bin und jetzt am ende scheiter :cry:

19

Nein, habe die bis auf DFPlayer,
tue mall das aufspielen

/*
  An example digital clock using a TFT LCD screen to show the time.
  Demonstrates use of the font printing routines. (Time updates but date does not.)

  It uses the time of compile/upload to set the time
  For a more accurate clock, it would be better to use the RTClib library.
  But this is just a demo...

  Make sure all the display driver and pin connections are correct by
  editing the User_Setup.h file in the TFT_eSPI library folder.

  #########################################################################
  ###### DON'T FORGET TO UPDATE THE User_Setup.h FILE IN THE LIBRARY ######
  #########################################################################

  Based on clock sketch by Gilchrist 6/2/2014 1.0

  A few colour codes:

  code  color
  0x0000  Black
  0xFFFF  White
  0xBDF7  Light Gray
  0x7BEF  Dark Gray
  0xF800  Red
  0xFFE0  Yellow
  0xFBE0  Orange
  0x79E0  Brown
  0x7E0 Green
  0x7FF Cyan
  0x1F  Blue
  0xF81F  Pink

*/
#include "FS.h"
#include "TFT_eSPI.h"
#include "Bitmap.h"
#include "DFRobotDFPlayerMini.h"
#include "RTClib.h"

//================= USEFUL VARIABLES ==========================
uint16_t notification_volume = 25;             //Set volume value. From 0 to 30
#define CALIBRATION_FILE "/calibrationData11"  // This is the file name used to store the touch coordinate - Change the name to start a new calibration.

//=============================================================

TFT_eSPI tft = TFT_eSPI();  // Invoke custom library

// Set REPEAT_CAL to true instead of false to run calibration
// again, otherwise it will only be done once.
// Repeat calibration if you change the screen rotation.
#define REPEAT_CAL false
#define FPSerial Serial1

const byte RXD2 = 16;  // Connects to module's TX => 16
const byte TXD2 = 17;  // Connects to module's RX => 17

DFRobotDFPlayerMini myDFPlayer;
void printDetail(uint8_t type, int value);

RTC_DS3231 rtc;

byte omm = 99, oss = 99;
byte xcolon = 0, xsecs = 0;
unsigned int colour = 0;
int mode = 0;
int valide = 1;
int toggle_lamp = 0;
int toggle_alarm = 0;
int Play_finished = 0;
uint16_t calibrationData[5];
uint8_t calDataOK = 0;
int hour = 0;
int minute = 0;
int play = 0;
int alarm_set = 0;
int font_val = 7;
uint16_t x = 0, y = 0;
uint32_t targetTime = 0;
int hh;
int mm;
int ss;
int stop = 1;
int alarm_stop = 0;
int alarm_active = 0;
int valide_clock = 1;
int valide_volume = 1;

void setup(void) {

  pinMode(33, OUTPUT);
  pinMode(35, INPUT);

  Serial.begin(115200);
  Serial.println("let's go");

  tft.init();
  tft.setRotation(1);

  // call screen calibration
  touch_calibrate();

  //Fill the screen with black
  tft.fillScreen(TFT_BLACK);

  rtc.begin();
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

  tft.setTextSize(1);
  tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
  tft.setTextColor(0xFDE0, TFT_BLACK);

  targetTime = millis() + 1000;
  delay(1000);
  FPSerial.begin(9600, SERIAL_8N1, RXD2, TXD2);

  Serial.println();
  Serial.println(F("DFRobot DFPlayer Mini Demo"));
  Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));

  if (!myDFPlayer.begin(FPSerial, /*isACK = */ true, /*doReset = */ true)) {  //Use serial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while (true) {
      delay(0);
    }
  }

  Serial.println(F("DFPlayer Mini online."));
  myDFPlayer.volume(notification_volume);
  myDFPlayer.setTimeOut(500);  // Définit un temps de time out sur la communication série à 500 ms
  Serial.println(myDFPlayer.readFileCounts());
  Serial.println(myDFPlayer.readCurrentFileNumber());

  delay(1000);
  myDFPlayer.playMp3Folder(1);  //Play the first mp3
}

void loop() {

  DateTime now = rtc.now();

  hh = now.hour();
  mm = now.minute();
  ss = now.second();
  Serial.print ("X = ");
  Serial.println(x);
  Serial.print ("Y = ");
  Serial.println(y);
  // tft.fillRect(10, 200, 50, 40, TFT_BLACK);
  // Serial.println(analogRead(35));
  // tft.setTextColor(0xFFFF);
  // tft.drawNumber(analogRead(35), 20, 210, 2);

  if (alarm_active == 1) {
    alarm_rings();
  }

  set_time();

  // Setup the alarm
  if (tft.getTouch(&x, &y)) {
    if ((x > 20) && (x < 165)) {
      if ((y > 150) && (y < 210)) {
        set_alarm();
        delay(200);
      }
    }
  }

  // Change the volume
  if (tft.getTouch(&x, &y)) {
    if ((x > 190) && (x < 320)) {
      if ((y > 30) && (y < 240)) {
        myDFPlayer.playMp3Folder(random(5, 9));
        delay(200);
        volume_notification();
      }
    }
  }

  // Switch on the bulb or stop the alarm
  if (tft.getTouch(&x, &y) && toggle_lamp == 0) {
    if ((x > 100) && (x < 170)) {
      if ((y > 50) && (y < 120)) {
        digitalWrite(33, HIGH);
        toggle_lamp = 1;
        delay(500);
        myDFPlayer.playMp3Folder(2);
        delay(200);
      }
    }
  }

  // Switch off the bulb or stop the alarm
  if (tft.getTouch(&x, &y) && toggle_lamp == 1) {
    if ((x > 100) && (x < 170)) {
      if ((y > 50) && (y < 120)) {
        digitalWrite(33, LOW);
        toggle_lamp = 0;
        delay(150);
      }
    }
  }
}

void volume_notification() {
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(0xFDE0);
  tft.drawString("Volume", 122, 10, 4);
  tft.drawRect(270, 190, 50, 50, 0xFDE0);
  tft.drawString("OK", 276, 205, 4);
  tft.fillTriangle(140, 80, 160, 40, 180, 80, 0xFDE0);
  tft.fillTriangle(140, 190, 160, 230, 180, 190, 0xFDE0);

  while (valide_volume) {

    tft.drawNumber(notification_volume, 125, 110, font_val);  // Draw volume value between 0 and 30

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 190) && (y < 240)) {
          valide_volume = 0;
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 120) && (x < 160)) {
        if ((y > 30) && (y < 100)) {
          notification_volume = notification_volume + 1;
          if (notification_volume > 30) {
            notification_volume = 30;
          }
          Serial.print("notification_volume : ");
          Serial.print(notification_volume);
          tft.fillRect(20, 100, 300, 80, TFT_BLACK);
          delay(50);
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 120) && (x < 160)) {
        if ((y > 180) && (y < 240)) {
          notification_volume = notification_volume - 1;
          if (notification_volume < 0) {
            notification_volume = 0;
          }
          Serial.print("notification_volume : ");
          Serial.print(notification_volume);
          tft.fillRect(20, 100, 300, 80, TFT_BLACK);
          delay(50);
        }
      }
    }
  }

  myDFPlayer.volume(notification_volume);
  valide_volume = 1;
  myDFPlayer.playMp3Folder(random(5, 9));
  delay(100);
  tft.fillScreen(TFT_BLACK);
  tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
  alarm_set = 1;
  set_time();
}

void alarm_rings() {
  if (hh == hour && mm == minute && play == 0) {
    myDFPlayer.playMp3Folder(random(3, 5));
    delay(200);
    while (stop) {
      // Switch on the bulb
      if (tft.getTouch(&x, &y)) {
        if ((x > 100) && (x < 170)) {
          if ((y > 50) && (y < 120)) {
            myDFPlayer.stop();
            delay(200);
            stop = 0;
          }
        }
      }
    }
    play = 1;
    stop = 1;
    Serial.println("boucle alarm rings");
    Serial.println(play);
  }
}

void battery_tester() {
  if (analogRead(35) > 2250) {
    for (int gap = 0; gap <= 135; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2250 && analogRead(35) > 2225) {
    tft.fillRect(195, 52, 113, 8, TFT_BLACK);

    for (int gap = 0; gap <= 120; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2225 && analogRead(35) > 2200) {

    for (int gap = 0; gap <= 15; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 105; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2200 && analogRead(35) > 2175) {

    for (int gap = 0; gap <= 30; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 90; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2175 && analogRead(35) > 2150) {

    for (int gap = 0; gap <= 45; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 75; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2150 && analogRead(35) > 2125) {

    for (int gap = 0; gap <= 60; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 60; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2125 && analogRead(35) > 2100) {

    for (int gap = 0; gap <= 75; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 30; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2100 && analogRead(35) > 2075) {

    for (int gap = 0; gap <= 90; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    for (int gap = 0; gap <= 15; gap = gap + 15) {
      tft.fillRect(195, 187 - gap, 113, 8, 0xFDE0);
    }
  }

  if (analogRead(35) < 2075 && analogRead(35) > 2000) {

    for (int gap = 0; gap <= 105; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }

    tft.fillRect(195, 187, 113, 8, 0xFDE0);
  }

  if (analogRead(35) < 2000) {
    for (int gap = 0; gap <= 135; gap = gap + 15) {
      tft.fillRect(195, 52 + gap, 113, 8, TFT_BLACK);
    }
  }
}

void set_alarm() {
  int triangle_w = 60;
  int triangle_h = 40;

  int triangle1_x = 50;
  int triangle1_y = 80;

  int triangle2_x = 200;
  int triangle2_y = 80;

  int triangle3_x = 50;
  int triangle3_y = 170;

  int triangle4_x = 200;
  int triangle4_y = 170;

  Serial.println("SET ALARM");
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(0xFDE0);
  tft.drawString("Alarm setup", 95, 10, 4);
  tft.drawRect(270, 190, 50, 50, 0xFDE0);
  tft.drawString("OK", 276, 205, 4);
  tft.drawRect(117, 200, 80, 30, 0xFDE0);

  tft.fillTriangle(triangle1_x, triangle1_y, triangle1_x + (triangle_w / 2), triangle1_y - triangle_h, triangle1_x + triangle_w, triangle1_y, 0xFDE0);
  tft.fillTriangle(triangle2_x, triangle2_y, triangle2_x + (triangle_w / 2), triangle2_y - triangle_h, triangle2_x + triangle_w, triangle2_y, 0xFDE0);
  tft.fillTriangle(triangle3_x, triangle3_y, triangle3_x + (triangle_w / 2), triangle3_y + triangle_h, triangle3_x + triangle_w, triangle3_y, 0xFDE0);
  tft.fillTriangle(triangle4_x, triangle4_y, triangle4_x + (triangle_w / 2), triangle4_y + triangle_h, triangle4_x + triangle_w, triangle4_y, 0xFDE0);

  tft.fillTriangle(280, 100, 310, 120, 280, 140, 0xFDE0);

  while (valide) {
    // Update digital time
    int x_alarm = 90;
    int y_alarm = 100;  // Top left corner ot clock text, about half way down
    // Draw hours and minutes
    if (hour < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add hours leading zero for 24 hr clock
    x_alarm += tft.drawNumber(hour, x_alarm, y_alarm, font_val);              // Draw hours
    xcolon = x_alarm;                                                         // Save colon coord for later to flash on/off later
    x_alarm += tft.drawChar(':', x_alarm, y_alarm, font_val);
    if (minute < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add minutes leading zero
    x_alarm += tft.drawNumber(minute, x_alarm, y_alarm, font_val);              // Draw minutes

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 190) && (y < 240)) {
          valide = 0;
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 30) && (y < 120)) {
          hour = hour + 1;
          Serial.print("hour : ");
          Serial.print(hour);
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);

          if (hour > 23) {
            hour = 0;
          }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 140) && (y < 240)) {
          hour = hour - 1;
          Serial.print("hour : ");
          Serial.print(hour);
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
          if (hour < 0) {
            hour = 23;
          }
        }
      }
    }
    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 260)) {
        if ((y > 30) && (y < 120)) {
          minute = minute + 1;
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
          if (minute > 59) {
            minute = 0;
          }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 240)) {
        if ((y > 140) && (y < 220)) {
          minute = minute - 1;
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
          if (minute < 0) {
            minute = 59;
          }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 110) && (x < 210)) {
        if ((y > 170) && (y < 240)) {
          if (alarm_active == 0) {
            alarm_active = 1;
            tft.fillRect(118, 201, 39, 28, TFT_BLACK);
            tft.fillRect(159, 201, 39, 28, 0xFDE0);
            delay(200);
          }
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 110) && (x < 210)) {
        if ((y > 170) && (y < 240)) {
          if (alarm_active == 1) {
            alarm_active = 0;
            tft.fillRect(159, 201, 37, 28, TFT_BLACK);
            tft.fillRect(118, 201, 39, 28, 0x31A6);
            delay(200);
          }
        }
      }
    }

    if (alarm_active == 1) {
      tft.fillRect(118, 201, 39, 28, TFT_BLACK);
      tft.fillRect(159, 201, 39, 28, 0xFDE0);
    }

    if (alarm_active == 0) {
      tft.fillRect(159, 201, 37, 28, TFT_BLACK);
      tft.fillRect(118, 201, 39, 28, 0x31A6);
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 90) && (y < 140)) {
          clock_setup();
          valide = 0;
        }
      }
    }
  }

  Serial.println("Set alarm out");
  tft.fillScreen(TFT_BLACK);
  tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
  valide = 1;
  alarm_set = 1;
  set_time();
}

void set_time() {

  DateTime now = rtc.now();
  hh = now.hour();
  mm = now.minute();
  ss = now.second();

  if (targetTime < millis()) {
    // Set next update for 1 second later
    targetTime = millis() + 1000;

    // Adjust the time values by adding 1 second
    ss++;             // Advance second
    if (ss == 60) {   // Check for roll-over
      ss = 0;         // Reset seconds to zero
      omm = mm;       // Save last minute time for display update
      mm++;           // Advance minute
      if (mm > 59) {  // Check for roll-over
        mm = 0;
        hh++;           // Advance hour
        if (hh > 23) {  // Check for 24hr roll-over (could roll-over on 13)
          hh = 0;       // 0 for 24 hour clock, set to 1 for 12 hour clock
        }
      }
    }

    // Update digital time
    int xpos = 20;
    int ypos = 150;  // Top left corner ot clock text, about half way down
    int ysecs = ypos + 24;
    Serial.println("Entree set time");
    Serial.println(play);
    if (omm != mm || alarm_set == 1) {  // Redraw hours and minutes time every minute
      omm = mm;
      battery_tester();
      if (alarm_set == 1) {
        tft.fillRect(10, 150, 160, 50, TFT_BLACK);
      }
      if (play == 1) {
        delay(2000);
      }
      play = 0;
      alarm_set = 0;
      // Draw hours and minutes
      if (hh < 10) xpos += tft.drawChar('0', xpos, ypos, font_val);  // Add hours leading zero for 24 hr clock
      xpos += tft.drawNumber(hh, xpos, ypos, font_val);              // Draw hours
      xcolon = xpos;                                                 // Save colon coord for later to flash on/off later
      xpos += tft.drawChar(':', xpos, ypos, font_val);
      if (mm < 10) xpos += tft.drawChar('0', xpos, ypos, font_val);  // Add minutes leading zero
      xpos += tft.drawNumber(mm, xpos, ypos, font_val);              // Draw minutes
      xsecs = xpos;                                                  // Sae seconds 'x' position for later display updates
    }
    if (oss != ss) {  // Redraw seconds time every second
      oss = ss;
      xpos = xsecs;

      if (ss % 2) {                                 // Flash the colons on/off
        tft.setTextColor(TFT_BLACK, TFT_BLACK);     // Set colour to grey to dim colon
        tft.drawChar(':', xcolon, ypos, font_val);  // Hour:minute colon
        //xpos += tft.drawChar(':', xsecs, ysecs, 6); // Seconds colon
        tft.setTextColor(0xFDE0, TFT_BLACK);  // Set colour back to yellow

      } else {
        tft.drawChar(':', xcolon, ypos, font_val);  // Hour:minute colon
        // xpos += tft.drawChar(':', xsecs, ysecs, 6); // Seconds colon
      }

      //Draw seconds
      // if (ss < 10) xpos += tft.drawChar('0', xpos, ysecs, 6); // Add leading zero
      // tft.drawNumber(ss, xpos, ysecs, 6);                     // Draw seconds
    }
  }
}

void clock_setup() {

  int triangle_w = 60;
  int triangle_h = 40;

  int triangle1_x = 50;
  int triangle1_y = 80;

  int triangle2_x = 200;
  int triangle2_y = 80;

  int triangle3_x = 50;
  int triangle3_y = 170;

  int triangle4_x = 200;
  int triangle4_y = 170;

  DateTime now = rtc.now();

  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(0xFDE0);
  tft.drawString("Clock setup", 95, 10, 4);
  tft.drawRect(270, 190, 50, 50, 0xFDE0);
  tft.drawString("OK", 276, 205, 4);

  tft.fillTriangle(triangle1_x, triangle1_y, triangle1_x + (triangle_w / 2), triangle1_y - triangle_h, triangle1_x + triangle_w, triangle1_y, 0xFDE0);
  tft.fillTriangle(triangle2_x, triangle2_y, triangle2_x + (triangle_w / 2), triangle2_y - triangle_h, triangle2_x + triangle_w, triangle2_y, 0xFDE0);
  tft.fillTriangle(triangle3_x, triangle3_y, triangle3_x + (triangle_w / 2), triangle3_y + triangle_h, triangle3_x + triangle_w, triangle3_y, 0xFDE0);
  tft.fillTriangle(triangle4_x, triangle4_y, triangle4_x + (triangle_w / 2), triangle4_y + triangle_h, triangle4_x + triangle_w, triangle4_y, 0xFDE0);

  while (valide_clock) {
    // Update digital time
    int x_alarm = 90;
    int y_alarm = 100;  // Top left corner ot clock text, about half way down
    // Draw hours and minutes
    if (hh < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add hours leading zero for 24 hr clock
    x_alarm += tft.drawNumber(hh, x_alarm, y_alarm, font_val);              // Draw hours
    xcolon = x_alarm;                                                       // Save colon coord for later to flash on/off later
    x_alarm += tft.drawChar(':', x_alarm, y_alarm, font_val);
    if (mm < 10) x_alarm += tft.drawChar('0', x_alarm, y_alarm, font_val);  // Add minutes leading zero
    x_alarm += tft.drawNumber(mm, x_alarm, y_alarm, font_val);              // Draw minutes

    if (tft.getTouch(&x, &y)) {
      if ((x > 270) && (x < 320)) {
        if ((y > 190) && (y < 240)) {
          valide_clock = 0;
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 30) && (y < 120)) {
          hh = hh + 1;
          if (hh > 23) {
            hh = 0;
          }
          Serial.print("hh : ");
          Serial.print(hh);
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 40) && (x < 110)) {
        if ((y > 140) && (y < 240)) {
          hh = hh - 1;
          if (hh < 0) {
            hh = 23;
          }
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          Serial.print("hh : ");
          Serial.print(hh);
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }
    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 260)) {
        if ((y > 30) && (y < 120)) {
          mm = mm + 1;
          if (mm > 59) {
            mm = 0;
          }
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }

    if (tft.getTouch(&x, &y)) {
      if ((x > 180) && (x < 240)) {
        if ((y > 140) && (y < 220)) {
          mm = mm - 1;
          if (mm < 0) {
            mm = 59;
          }
          rtc.adjust(DateTime(now.year(), now.month(), now.day(), hh, mm, 0));
          tft.fillRect(20, 90, 300, 60, TFT_BLACK);
          delay(50);
        }
      }
    }
  }

  valide_clock = 1;
}

void touch_calibrate() {
  uint16_t calData[5];
  uint8_t calDataOK = 0;

  // check file system exists
  if (!SPIFFS.begin()) {
    Serial.println("Formatting file system");
    SPIFFS.format();
    SPIFFS.begin();
  }

  // check if calibration file exists and size is correct
  if (SPIFFS.exists(CALIBRATION_FILE)) {
    if (REPEAT_CAL) {
      // Delete if we want to re-calibrate
      SPIFFS.remove(CALIBRATION_FILE);
    } else {
      File f = SPIFFS.open(CALIBRATION_FILE, "r");
      if (f) {
        if (f.readBytes((char *)calData, 14) == 14)
          calDataOK = 1;
        f.close();
      }
    }
  }

  if (calDataOK && !REPEAT_CAL) {
    // calibration data valid
    tft.setTouch(calData);
  } else {
    // data not valid so recalibrate
    tft.fillScreen(TFT_BLACK);
    tft.setCursor(20, 0);
    tft.setTextFont(2);
    tft.setTextSize(1);
    tft.setTextColor(TFT_WHITE, TFT_BLACK);

    tft.println("Touch corners as indicated");

    tft.setTextFont(1);
    tft.println();

    if (REPEAT_CAL) {
      tft.setTextColor(TFT_RED, TFT_BLACK);
      tft.println("Set REPEAT_CAL to false to stop this running again!");
    }

    tft.calibrateTouch(calData, TFT_MAGENTA, TFT_BLACK, 15);

    tft.setTextColor(TFT_GREEN, TFT_BLACK);
    tft.println("Calibration complete!");

    // store data
    File f = SPIFFS.open(CALIBRATION_FILE, "w");
    if (f) {
      f.write((const unsigned char *)calData, 14);
      f.close();
    }
  }
}

// Function to extract numbers from compile time string
static uint8_t conv2d(const char *p) {
  uint8_t v = 0;
  if ('0' <= *p && *p <= '9')
    v = *p - '0';
  return 10 * v + *++p - '0';
}

void printDetail(uint8_t type, int value) {
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      break;
    case DFPlayerUSBInserted:
      Serial.println("USB Inserted!");
      break;
    case DFPlayerUSBRemoved:
      Serial.println("USB Removed!");
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      Play_finished = 1;
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
}

void waitMilliseconds(uint16_t msWait) {
  uint32_t start = millis();

  while ((millis() - start) < msWait) {
    // calling mp3.loop() periodically allows for notifications
    // to be handled without interrupts
    delay(1);
  }
}

und Sreib was im Serial Monitor unter
Serial.print ("X = ");
Serial.println(x);
Serial.print ("Y = ");
Serial.println(y);
zu sehen ist.
Die vier Zeilen sollen zeigen ob der Touch funktioniert.
Wen es tut dann werden die weg geschmissen.

1 Like
20

was soll ich bei serial.print("X schreiben? oder soll ich es so wie es ist drauf spielen? er zeigt mir da jetzt diesen fehler an C:\Users\User\AppData\Local\Temp.arduinoIDE-unsaved2024430-27092-1wn1fv1.7r06\sketch_may30a\sketch_may30a.ino: In function 'void setup()':
C:\Users\User\AppData\Local\Temp.arduinoIDE-unsaved2024430-27092-1wn1fv1.7r06\sketch_may30a\sketch_may30a.ino:110:24: error: 'epd_bitmap_Interface_2' was not declared in this scope
110 | tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
| ^~~~~~~~~~~~~~~~~~~~~~
C:\Users\User\AppData\Local\Temp.arduinoIDE-unsaved2024430-27092-1wn1fv1.7r06\sketch_may30a\sketch_may30a.ino: In function 'void volume_notification()':
C:\Users\User\AppData\Local\Temp.arduinoIDE-unsaved2024430-27092-1wn1fv1.7r06\sketch_may30a\sketch_may30a.ino:265:24: error: 'epd_bitmap_Interface_2' was not declared in this scope
265 | tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
| ^~~~~~~~~~~~~~~~~~~~~~
C:\Users\User\AppData\Local\Temp.arduinoIDE-unsaved2024430-27092-1wn1fv1.7r06\sketch_may30a\sketch_may30a.ino: In function 'void set_alarm()':
C:\Users\User\AppData\Local\Temp.arduinoIDE-unsaved2024430-27092-1wn1fv1.7r06\sketch_may30a\sketch_may30a.ino:545:24: error: 'epd_bitmap_Interface_2' was not declared in this scope
545 | tft.drawBitmap(0, 0, epd_bitmap_Interface_2, 320, 240, 0xFDE0);
| ^~~~~~~~~~~~~~~~~~~~~~

exit status 1

Compilation error: 'epd_bitmap_Interface_2' was not declared in this scope`

21

Kopiere das noch mall habe den Fehler selber gemacht. Jetzt sollte Kompilieren sauber wie vorher

1 Like