Akkorduhr

Stunden:




void printStdSchritt( byte schritt ) {
  static const char *schrittTexte[] = {"REF_CHK_STD_SCHLITTEN", "REF_FAHRT_STD", "REF_FREI_STD", "STD_GEFUNDEN", "STD_REFERENZ", "WARTEN_STD",  "S_ZEIT", "STD_KLANG" };
  debug( "Std: "); debugln( schrittTexte[schritt] );
}

// Rückgabe wert ist die aktuelle Position ( wenn im Zustand WARTEN )
// oder -1 wenn in Bewegung
int stundenSchlitten() {
  byte minute, hour;
  static byte altStunden = 12, posStunden = 0;
  enum class Schritt : byte {REF_CHK_STD_SCHLITTEN, REF_FAHRT_STD,  REF_FREI_STD, STD_GEFUNDEN, STD_REFERENZ, WARTEN_STD, STD_ZEIT_FAHRT};
  static Schritt schritt = Schritt::REF_CHK_STD_SCHLITTEN, altSchritt = Schritt::STD_REFERENZ;
#ifdef DEBUG
  if ( schritt != altSchritt ) {
    // Debugging: Ausgabe wenn Statuswechsel
    printStdSchritt((byte)schritt);
    altSchritt = schritt;
  }
#endif

  // REFERENZIERUNG DES STUNDENSCHLITTENS

  // Erkennen der Referenzpunkte ( unabhängig von der FSM )

  if (Taster.pressed(refStdPin)) {                   // Wenn Referenzpunkt erreicht, Nullpunkt setzen.
    StepStunden.setZero(NULLPOSSTUNDEN);          // Nullpunkt etwas hinter den referenzpunkt setzen, um ihn auch bei Schrittverlusten sicher zu erreichen
    StepStunden.writeSteps(-1500);
    debugln("Referenz Stunden gefunden");
  }

  switch (schritt) {

    case Schritt::REF_CHK_STD_SCHLITTEN:


      if ( Taster.state(refStdPin ) ) {             // Prüfen ob Schlitten in der Lichtschranke steht
        debugln(F("Std LS freifahren"));
        StepStunden.writeSteps(-5000);              //  aus LS ausfahren


        schritt = Schritt::REF_FREI_STD;
      }
      else {

        schritt = Schritt::REF_FAHRT_STD;
      }
      break;

    case Schritt::REF_FREI_STD:

      if ( Taster.released(refStdPin) )  {
        StepStunden.writeSteps(-3000 );            // etwas über LS Grenze hinausfahren
        debugln(F("Stunde über LS hinausfahren"));
      }
      if (!StepStunden.moving()) {
        debugln(F("Std frei gefahren"));
        schritt = Schritt::REF_FAHRT_STD;

      }
      break;

    case Schritt::REF_FAHRT_STD:

      StepStunden.writeSteps(80000);      // Referenzfahrt des STD-Schlitten starten

      schritt = Schritt::STD_GEFUNDEN;

      break;

    case   Schritt::STD_GEFUNDEN:

      if (Taster.state(refStdPin)) {       // Schlitten hat Referenzposition gefunden
        debugln(F("Std Referenzpunkt gefunden"));
        {
          schritt = Schritt::STD_REFERENZ;

          break;

        case    Schritt::STD_REFERENZ:

          if (Taster.pressed(refStdPin)) {
            StepStunden.setZero(NULLPOSSTUNDEN);
            StepStunden.writeSteps(-1500);         //  Schlitten Fährt zur Grundposition
            debugln(F("Stunden Referenzierung"));

          }

          schritt = Schritt::WARTEN_STD;;
        }
        break;

      //  SCHLITTENFAHRT FÜR UHR-ZEIT STUNDEN


      case Schritt::WARTEN_STD:

        //debugln(F("warten Stunden"));

        if ( stellenAktiv ) {
          // im Einstellmodus wird das vorrücken über den Stelltaster ausgelöst
          posStunden = altStunden + Taster.clicked(stellStd); // Bei einfach Klick wird eins, bei Doppelklick 2 addiert
          if ( posStunden > 11 ) posStunden = 0;
        } else {

          // im Normalbetrieb die Uhr abfragen
          readDS3231time(minute, hour);
          posStunden = hour > 11 ? hour - 12 : hour;     //posStunden = minute > 11 ? minute - 12 : minute; // nur zum Testen
        }
        if (altStunden != posStunden) {
          debug( "Std: "); displayTime(0, minute, hour);
          debug("altStunden: "); debug(altStunden); debug('\t'); debug("posStunden: "); debug(posStunden); debug('\n');
          altStunden = posStunden;

          StepStunden.write(0);

          schritt = Schritt::STD_ZEIT_FAHRT;
        }
        break;

      case Schritt::STD_ZEIT_FAHRT:

        if ((posStunden) = 0 ) {      // 60 Minuten - 1 Minute = Zeitverschub Schlittenfahrt mit Klangschlag

          StepStunden.write(88000);

        }
        else {
          StepStunden.write(schritteS[posStunden]);        //  Stundenschlitten fährt an die Zeitposition
          debug("Stunden: "); debugln (posStunden);

        }

        schritt = Schritt::STD_ZEIT_FAHRT;
      }


  }
  if ( schritt == Schritt::WARTEN_STD ) return altStunden;
  else return -1;

}

Nach einer kleinen Pause bin ich nun wieder zurück :wink: Was meint ihr zu meinem Sketch oben? Sollte das so gehen? Oder muss ich da noch was ändern oder anpassen?

Welchen Sketch? - Du hast irgendwelche Einzelteile ab #338, in #341 sogar noch verändert, vorgestellt.
Was ist Dein Sketch?

Der Sketch besteht aus #340, #341 und #342.
Verstehe nicht genau was du meinst my_xy_projekt

Das sind Einzelteile.
Das ist nicht einmal ansatzweise ein Sketch.
Warum machst Du das nicht a) in einem Post und b) nicht mit sowas wie void setup() und void loop()....
in einem Gesamtdingens.

Der Sketch ist auf 3 Tabs verteilt. Im Tab (#339) ist der void setup() und void loop() Teil.
Im übrigen reklamiert die Seite hier, wenn ich alles zusammen in ein Post packe, wegen zuvielen Satzzeichen.

Macht er jetzt schon den ganzen Thread so - finde ich auch in Ordnung. Ich finde das besser, als das ganze Sketch-Verzeichnis in ein zip zu packen und hochzuladen.

Hab ich auch irgendwie gesehen, mich aber aufgrund der unterschiedlichen Angaben zu den Teilen aber nicht mehr weiter damit befast.
Danke für die Aufklärung.

Habs mit dem Projekt noch nicht ganz aufgegeben. :thinking:

Freut mich, das zu lesen!

Ich müßte die Bewegungen sehen können, um Dir helfen zu können. Nur theoretisch bekomme ich das leider nicht hin. Bleibt mir also nur, Dir die Daumen zu drücken :slightly_smiling_face:

Danke :slightly_smiling_face:

Das ist doch sehr erfreulich. Dann zeig doch mal den aktuellen Stand.

Das ist der aktuelle Stand der Dinge:

ino

// Debugging
#define DEBUG Serial // Diese Zeile als Kommentar, wenn keine Ausgabe auf dem seriellen Monitor gewünscht ist.
#ifdef DEBUG
#define debug(...) DEBUG.print(__VA_ARGS__)
#define debugln(...) DEBUG.println(__VA_ARGS__)
#define debugbegin(...) DEBUG.begin(__VA_ARGS__)
#define SECPERMIN 4  // Sekunden pro Minute - zur Beschleunignung beim Testen

#else
#define debug(...)
#define debugln(...)
#define debugbegin(...)
#endif

#include "Wire.h"
constexpr int DS3231_I2C_ADDRESS = 0x68; // Die Bibliothek möchte int!
#include <MobaTools.h>
MoToTimer Zeitlesen, schlagTimer;

bool schlagwerkStarten = false;

constexpr uint32_t PAUSE = 1000;
const int HandSensor = A4;



constexpr uint16_t NULLPOSMINUTEN = 200;  // Abstand Referenzpunkt ( LS ) zum Nullpunkt
constexpr uint16_t NULLPOSSTUNDEN = 200;

const int STEPS_REVOLUTION = 200;
MoToStepper StepMinuten(STEPS_REVOLUTION, STEPDIR);
MoToStepper StepStunden(STEPS_REVOLUTION, STEPDIR);


                  // Minute   0      5       10      15       20        25        30        35        40         45       50        55
                  // Index    0      1       2       3        4         5         6         7         8          9        10        11
uint32_t schritteM[] =   {88000, 24000,  48000,  32000,   56000,    24000,    64000,    16000,    72000,    8000,    80000,     0};

                 // Stunden   0      5       10      15       20        25        30        35        40         45       50        55
                 // Index     0      1       2       3        4         5         6         7         8          9        10        11
uint32_t schritteS[] =   {88000, 24000,  48000,  32000,   56000,    24000,    64000,    16000,    72000,    8000,    80000,     0};





const byte dirPinMin       = 4;
const byte stepPinMin      = 5;
const byte enaPinMin       = 6;

const byte dirPinStd       = 7;
const byte stepPinStd      = 8;
const byte enaPinStd       = 9;

const byte  MinBeater  = 10;
const byte  StdBeater  = 11;
const byte  GndBeater  = 12;

// Input-Pins ( Lichtschranken und Zeitsetz-Taster ) über MoToButtons verwalten
const byte inPins[] = { 2, 3, A1, A2, A3 };
const byte pinAnzahl = sizeof( inPins );
enum : byte { refMinPin, refStdPin,  stellMin, stellStd, stellMode };
#define MAX8BUTTONS     // optional, spart Speicherplatz ( Standard ist maximal 16 Taster )
MoToButtons Taster ( inPins, pinAnzahl, 20, 2000 );  // Einrichten der Tasterverwaltung

//Variable für das Uhr stellen
boolean stellenAktiv;
const byte stellenLED = A0;

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
  return ( (val / 16 * 10) + (val % 16) );
}

//Convertiert Dezimalzeichen in BCD Zeichen.
byte decToBcd(byte val) {
  return ( (val / 10 * 16) + (val % 10) );
}

// Zeit von DS3231 holen
void readDS3231time( byte &minute, byte &hour)
{ // Die DS3231 wird nur jede 500ms abgefragt, sonst werden die
  // gespeicherten Zeiten zurückgegeben
  static byte DShour, DSmin, DSsec;
  if (!Zeitlesen.running()) {
    Zeitlesen.setTime( PAUSE );
    Wire.beginTransmission(DS3231_I2C_ADDRESS);
    Wire.write(0); // set DS3231 register pointer to 00h
    Wire.endTransmission();
    Wire.requestFrom(DS3231_I2C_ADDRESS, 3);
    // request three bytes of data from DS3231 starting from register 00h
    DSsec = bcdToDec(Wire.read() & 0x7f);
    DSmin = bcdToDec(Wire.read());
    DShour = bcdToDec(Wire.read() & 0x3f);

  }


  hour = DShour;
  minute = DSmin;
}
// Anzeige im seriellen Monitor
void displayTime(byte second, byte minute, byte hour)
{
  char buf [10];
  snprintf ( buf, 10, "%02u:%02u:%02u", hour, minute, second );
  debugln(buf);  // send it to the serial monitor
}

void setup() {
  Wire.begin();
  debugbegin(115200);
  debugln("\nStart");
  // pinMode für die Tater/LS-Eingänge wird in MoToButtons gemacht

  pinMode(stellenLED, OUTPUT);
  pinMode(HandSensor, INPUT);

  StepMinuten.attach( stepPinMin, dirPinMin );
  //StepMinuten.attachEnable( enaPinMin, 7, LOW );        // Enable Pin aktivieren ( LOW=aktiv )
  StepMinuten.setSpeed( 5000 );
  StepMinuten.setRampLen( 250 );
  StepMinuten.setZero(0);


  StepStunden.attach( stepPinStd, dirPinStd );
  StepStunden.attachEnable( enaPinStd, 8, LOW );        // Enable Pin aktivieren ( LOW=aktiv )
  StepStunden.setSpeed( 5000 );
  StepStunden.setRampLen( 250 );
  StepStunden.setZero(0);

  delay(50);
}

void loop () {
  Taster.processButtons();
  int minutenPosition = minutenSchlitten();
  int stundenPosition = stundenSchlitten();
  int Klang();

  // Verwaltung Einstellmode
  if (! stellenAktiv ) {
    // Wenn Taster lange gedrückt, in Stellmode schalten
    if ( Taster.longPress(stellMode) ) {
      stellenAktiv = true;
      debugln("Stellmode aktiv");
      digitalWrite( stellenLED, HIGH );
    }
  } else {
    // Das Beenden des Stellmode ist nur im Stillstand der Ringe möglich
    if ( Taster.shortPress(stellMode) ) {
      debug (F("minutenPosition=")); debugln(minutenPosition);
      debug(F("stundenPosition=")); debugln(stundenPosition);
      if ( minutenPosition >= 0 && stundenPosition >= 0 ) {
        debugln(F("Stellmode beenden"));
        debug("Std: "); debug(stundenPosition); debug(" - Min: "); debugln(minutenPosition * 5);

        // aktuelle Stunden und Minuten an RTC übertragen
        Wire.beginTransmission(DS3231_I2C_ADDRESS);
        Wire.write(0);              // Start ab Register 0 (Sekunden )
        Wire.write(decToBcd(0));    // Sekunden
        Wire.write(decToBcd(minutenPosition * 5)); // Minuten
        Wire.write(decToBcd(stundenPosition));    // Stunde
        Wire.endTransmission();
        digitalWrite( stellenLED, LOW );
        stellenAktiv = false;
      }
    }

  }
}

Klangfunktion:

int Klang() {

      enum class SchlagWerk : byte {WAIT, GRUND_SCHLAG_MIN, WAIT_MIN, STD_SCHLAG };
      static SchlagWerk schlagWerkZustand = SchlagWerk::WAIT;


  
      switch ( schlagWerkZustand ) {
        case SchlagWerk::WAIT:
          // Ruhezustand, warten bis Flag gesetzt
          if ( schlagwerkStarten ) {
            digitalWrite( GndBeater, HIGH );         // Grundschlag-Minuten Anfang
            digitalWrite( MinBeater, HIGH );         // Minutenschlag Anfang
            schlagTimer.setTime( 500 );

            schlagWerkZustand = SchlagWerk::GRUND_SCHLAG_MIN;
          }
          break;
        case SchlagWerk::GRUND_SCHLAG_MIN:
          if (schlagTimer.expired() ) {
            digitalWrite( GndBeater, LOW );                // Grundschlag-Minuten Ende
            digitalWrite( MinBeater, LOW );                // Minutenschlag Ende
            schlagTimer.setTime( 2000 );                   // 2 Sekunden Pause
            schlagWerkZustand = SchlagWerk::WAIT_MIN;
          }
          break;
        case SchlagWerk::WAIT_MIN:
            if (schlagTimer.expired() ) {
            digitalWrite( GndBeater, HIGH );               // Grundschlag-Stunden Anfang
              digitalWrite( StdBeater, HIGH );             // Stundenschlag Anfang
              schlagTimer.setTime( 500 );
              schlagWerkZustand = SchlagWerk::STD_SCHLAG;
            }
          break;
        case SchlagWerk::STD_SCHLAG:
            if (schlagTimer.expired() ) {
            digitalWrite( GndBeater, LOW );                  // Grundschlag-Stunden Ende
              digitalWrite( StdBeater, LOW );                // Minutenschlag Ende
            }
              schlagWerkZustand = SchlagWerk::WAIT;
           
          break;

    
      }
}

Minuten:

void printMinSchritt( byte schritt ) {
  static const char *schrittTexte[] = {"REF_CHK_M_SCHLITTEN", "REF_FAHRT_M", "REF_FREI_M", "MIN_GEFUNDEN", "MIN_REFERENZ", "WARTEN_MIN", "M_ZEIT_FFAHRT", "MIN_KLANG" };
  debug("Min: "); debugln( schrittTexte[schritt] );
}

// Rückgabe wert ist die aktuelle Position ( wenn im Zustand WARTEN )
// oder -1 wenn in Bewegung
int minutenSchlitten() {
  byte minute, hour;
  static byte altMinuten = 12, posMinuten = 0;


  enum class Schritt : byte {REF_CHK_M_SCHLITTEN, REF_FAHRT_M, REF_FREI_M, MIN_GEFUNDEN, MIN_REFERENZ, WARTEN_MIN, M_ZEIT_FAHRT, MIN_KLANG};
  static Schritt schritt = Schritt::REF_CHK_M_SCHLITTEN, altSchritt = Schritt::MIN_REFERENZ;
#ifdef DEBUG
  if ( schritt != altSchritt ) {
    // Debugging; Ausgabe wenn Statuswechsel
    printMinSchritt((byte) schritt);
    altSchritt = schritt;
  }
#endif

  // REFERENZIERUNG DES MINUTENSCHLITTENS

  // Referenzierung der Minuten unabhängig von der FSM

  if (Taster.pressed(refMinPin)) {                  // Wenn Referenzpunkt erreicht, Nullpunkt setzen.
    StepMinuten.setZero(NULLPOSMINUTEN);          // Nullpunkt etwas hinter den referenzpunkt setzen, um ihn auch bei Schrittverlusten sicher zu erreichen
    StepMinuten.writeSteps(-1300);
    debugln("Referenz Minuten gefunden");

  }
  switch (schritt) {

    case Schritt:: REF_CHK_M_SCHLITTEN:

      if (Taster.state(refMinPin)) {         // Prüfen ob Schlitten in der Lichtschranke steht
        debugln(F("Min LS freifahren"));
        StepMinuten.writeSteps(-5000 );      //aus der LS fahren

        schritt = Schritt::REF_FREI_M;

      } else {

        schritt = Schritt::REF_FAHRT_M;      // Referenzfahrt M-Schlitten
      }
      break;


    case Schritt::REF_FREI_M:

      if (!Taster.released(refMinPin)) {
        delay(500);
        StepMinuten.writeSteps(-3000 );              // etwas über LS Grenze hinausfahren
        debugln(F("Minuten über LS hinausfahren"));
      }
      if (!StepMinuten.moving()) {
        debugln(F("Std frei gefahren"));
        schritt = Schritt::REF_FAHRT_M;
      }
      break;


    case Schritt::REF_FAHRT_M:

      StepMinuten.writeSteps(90000);         // Referenz-Fahrt des M-Schlitten starten.


      schritt = Schritt::MIN_GEFUNDEN;

      break;

    case Schritt::MIN_GEFUNDEN:

      if (Taster.state(refMinPin)) {               // Schlitten hat Referenzposition gefunden

        debugln(F("Min Referenzpunkt  gefunden"));

        schritt = Schritt::MIN_REFERENZ;

        break;

      case    Schritt::MIN_REFERENZ:

        if (Taster.pressed(refMinPin)) {
          StepMinuten.setZero(NULLPOSMINUTEN);
          StepMinuten.writeSteps(-1300);         //  Schlitten Fährt zur Grundposition
          debugln(F("Minuten Referenzierung"));

        }

        schritt = Schritt::WARTEN_MIN;;
      }
      break;


    // Auf UhrZeit warten:

    // SCHLITTENFAHRT FÜR UHR-ZEIT MINUTEN

    case Schritt::WARTEN_MIN:



      if ( stellenAktiv ) {
        // im Einstellmodus wird das vorrücken über den Stelltaster ausgelöst
        posMinuten = altMinuten + Taster.clicked(stellMin); // Bei einfach Klick wird eins, bei Doppelklick 2 addiert
        if ( posMinuten > 11 ) posMinuten = 0;
      } else {
        // im Normalbetrieb die Uhr abfragen
        readDS3231time(minute, hour);
        posMinuten = (minute * -1) / 5;

      }

      if (altMinuten != posMinuten) {
        // Ereignis: Zeitpunkt für den Bewegungsablauf ist gekommen

        debug( "Min: "); displayTime(0, minute, hour);

        debug(F("altMinuten: ")); debug(altMinuten); debug('\t'); debug("posMinuten: "); debug(posMinuten); debug('\n');
        altMinuten = posMinuten;


        schritt = Schritt::M_ZEIT_FAHRT;
      }
      break;


    case Schritt::M_ZEIT_FAHRT:

      if ((posMinuten * 5 ) - 1 == -1) {      // 5 Minuten - 1 Minute = Zeitverschub Schlittenfahrt mit Klangschlag

        StepMinuten.write(88000);

      }
      else {
        StepMinuten.write(schritteM[posMinuten]);        //  Minutenschlitten fährt an die Zeitposition
        debug("Minuten: "); debugln (posMinuten);

      }
      schritt = Schritt::MIN_KLANG;

      break;

    case Schritt::MIN_KLANG:

      if (!StepMinuten.moving() )
      {

        schlagwerkStarten = true;           // flag setzen

      }
  
      
     // KLANG ÜBER DEN HANDSENSOR AUSLÖSEN
     
      if (HandSensor, HIGH)
      {
        ( schlagwerkStarten );  // flag setztn
      }
  }
  if ( schritt == Schritt::WARTEN_MIN ) return altMinuten;
  else return -1;
}

Stunden:

void printStdSchritt( byte schritt ) {
  static const char *schrittTexte[] = {"REF_CHK_STD_SCHLITTEN", "REF_FAHRT_STD", "REF_FREI_STD", "STD_GEFUNDEN", "STD_REFERENZ", "WARTEN_STD",  "S_ZEIT", "STD_KLANG" };
  debug( "Std: "); debugln( schrittTexte[schritt] );
}

// Rückgabe wert ist die aktuelle Position ( wenn im Zustand WARTEN )
// oder -1 wenn in Bewegung
int stundenSchlitten() {
  byte minute, hour;
  static byte altStunden = 12, posStunden = 0;
  enum class Schritt : byte {REF_CHK_STD_SCHLITTEN, REF_FAHRT_STD,  REF_FREI_STD, STD_GEFUNDEN, STD_REFERENZ, WARTEN_STD, STD_ZEIT_FAHRT};
  static Schritt schritt = Schritt::REF_CHK_STD_SCHLITTEN, altSchritt = Schritt::STD_REFERENZ;
#ifdef DEBUG
  if ( schritt != altSchritt ) {
    // Debugging: Ausgabe wenn Statuswechsel
    printStdSchritt((byte)schritt);
    altSchritt = schritt;
  }
#endif

  // REFERENZIERUNG DES STUNDENSCHLITTENS

  // Erkennen der Referenzpunkte ( unabhängig von der FSM )

  if (Taster.pressed(refStdPin)) {                   // Wenn Referenzpunkt erreicht, Nullpunkt setzen.
    StepStunden.setZero(NULLPOSSTUNDEN);          // Nullpunkt etwas hinter den referenzpunkt setzen, um ihn auch bei Schrittverlusten sicher zu erreichen
    StepStunden.writeSteps(-1500);
    debugln("Referenz Stunden gefunden");
  }

  switch (schritt) {

    case Schritt::REF_CHK_STD_SCHLITTEN:


      if ( Taster.state(refStdPin ) ) {             // Prüfen ob Schlitten in der Lichtschranke steht
        debugln(F("Std LS freifahren"));
        StepStunden.writeSteps(-5000);              //  aus LS ausfahren


        schritt = Schritt::REF_FREI_STD;
      }
      else {

        schritt = Schritt::REF_FAHRT_STD;
      }
      break;

    case Schritt::REF_FREI_STD:

      if ( Taster.released(refStdPin) )  {
        StepStunden.writeSteps(-3000 );            // etwas über LS Grenze hinausfahren
        debugln(F("Stunde über LS hinausfahren"));
      }
      if (!StepStunden.moving()) {
        debugln(F("Std frei gefahren"));
        schritt = Schritt::REF_FAHRT_STD;

      }
      break;

    case Schritt::REF_FAHRT_STD:

      StepStunden.writeSteps(80000);      // Referenzfahrt des STD-Schlitten starten

      schritt = Schritt::STD_GEFUNDEN;

      break;

    case   Schritt::STD_GEFUNDEN:

      if (Taster.state(refStdPin)) {       // Schlitten hat Referenzposition gefunden
        debugln(F("Std Referenzpunkt gefunden"));
        {
          schritt = Schritt::STD_REFERENZ;

          break;

        case    Schritt::STD_REFERENZ:

          if (Taster.pressed(refStdPin)) {
            StepStunden.setZero(NULLPOSSTUNDEN);
            StepStunden.writeSteps(-1500);         //  Schlitten Fährt zur Grundposition
            debugln(F("Stunden Referenzierung"));

          }

          schritt = Schritt::WARTEN_STD;;
        }
        break;

      //  SCHLITTENFAHRT FÜR UHR-ZEIT STUNDEN


      case Schritt::WARTEN_STD:

        //debugln(F("warten Stunden"));

        if ( stellenAktiv ) {
          // im Einstellmodus wird das vorrücken über den Stelltaster ausgelöst
          posStunden = altStunden + Taster.clicked(stellStd); // Bei einfach Klick wird eins, bei Doppelklick 2 addiert
          if ( posStunden > 11 ) posStunden = 0;
        } else {

          // im Normalbetrieb die Uhr abfragen
          readDS3231time(minute, hour);
          posStunden = hour > 11 ? hour - 12 : hour;     //posStunden = minute > 11 ? minute - 12 : minute; // nur zum Testen
        }
        if (altStunden != posStunden) {
          debug( "Std: "); displayTime(0, minute, hour);
          debug("altStunden: "); debug(altStunden); debug('\t'); debug("posStunden: "); debug(posStunden); debug('\n');
          altStunden = posStunden;

          StepStunden.write(0);

          schritt = Schritt::STD_ZEIT_FAHRT;
        }
        break;

      case Schritt::STD_ZEIT_FAHRT:

        if ((posStunden) = 0 ) {      // 60 Minuten - 1 Minute = Zeitverschub Schlittenfahrt mit Klangschlag

          StepStunden.write(88000);

        }
        else {
          StepStunden.write(schritteS[posStunden]);        //  Stundenschlitten fährt an die Zeitposition
          debug("Stunden: "); debugln (posStunden);

        }

        schritt = Schritt::STD_ZEIT_FAHRT;
      }


  }
  if ( schritt == Schritt::WARTEN_STD ) return altStunden;
  else return -1;

}

Ich finde es schade, das Du keine saubere Codestruktur hast.
Es ist nur abgeschrieben / zusammenkopiert.
Ein Beispiel:

constexpr uint32_t PAUSE = 1000;
const int HandSensor = A4;

Und wozu brauchst Du das?

const byte pinAnzahl = sizeof( inPins );

Und hier habe ich jetzt aufgehört.

void displayTime(byte second, byte minute, byte hour)
{
  char buf [10];
  snprintf ( buf, 10, "%02u:%02u:%02u", hour, minute, second );
  debugln(buf);  // send it to the serial monitor
}

Dann mal die Warnungen, die mir ausgegeben werden:

85:30: warning: variable 'DSsec' set but not used [-Wunused-but-set-variable]

46:1: warning: no return statement in function returning non-void [-Wreturn-type]

40:14: warning: left operand of comma operator has no effect [-Wunused-value]

158:23: note: in expansion of macro 'HIGH'
// codezeile:
if (HandSensor, HIGH)


160:30: warning: statement has no effect [-Wunused-value]
// codezeile
( schlagwerkStarten );  // flag setztn

122:26: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
// codezeile
if ((posStunden) = 0 ) {      // 60 Minuten - 1 Minute = Zeitverschub Schlittenfahrt mit Klangschlag

Dein Problem ist auch das mischen von Zuweisung und Vergleich.

Überarbeite Deinen Code, das er ohne Warnungen kompiliert.
Sonst macht das keinen Sinn.