LTC4311 + Display

Hallo,

Ich hätte da mal eine Frage zum LTC4311, vielleich hat hier im Forum schon mal jemand was damit zu tun gehabt.
Ich möchte mit einem LTC4311 ein I2C Display ansteuern, welches über einem 2m langen geschirmten Netzwerkkabel zum Arduino verbunden ist.
Anscheinend ist für den I2C Bus die Länge des Kabels etwas zu groß.

Kann mir vielleicht jemand einen Tip geben wie die Verkabelung hierfür aussehen müsste (aus der Beschreibung des Herstellers werde ich einfach nicht schlau).
Ich habe mal eine Skizze erstellt, bin mir aber nicht sicher ob die Verkabelung so in Ordnung ist.
Vorallem Frage ich mich warum hier 2x Anschlüße für ein STEMMA QT Kabel am LTC4311 vorhanden sind ???

LG
Christian

Du musst den I2C Bus nur einmal drauf schalten.
https://www.google.com/search?q=ltc4311+i2c+extender&client=tablet-android-samsung-rev2&prmd=sivn&source=lnms&tbm=isch&sa=X&ved=2ahUKEwjzjf2vgpLxAhXVO-wKHSTmBasQ_AUoAnoECAIQAg&biw=1334&bih=800#imgrc=vaKioIHQFmmJuM

Hast Du mal einen Link zu dem LTC4311-Modul, nicht zum Schaltkreis.

Gruß Tommy

Hallo Tommy,

hier ist der Link direkt vom Hersteller.

LG
Christian

OK, da steht eigentlich alles drin (unter Learn).
Du kannst die Stemma-QT-Buchsen nutzen, wenn Du die passenden Stecker hast. Du kannst aber auch alles direkt an SDA/SCL klemmen.
Es ist alles ein Bus.

Gruß Tommy

Und du solltest auch alles Lesen, was dir hier geschrieben wird.
Und beachte den Enable .

Hallo Hot Systems,

Das habe ich auf der Adafruit Seite gefunden:

EN - Enable pin, pulled high to VIN. Pull down to ground to disable the terminator.

Habe ich das so richtig verstanden?

Wenn ich den Enable pin nicht anschließe läuft das System (oder muss ich +5V draufgeben, damit der terminator läuft) ?
Wenn ich den enable pin mit gnd vom Arduino verbinden würde wäre er deaktiviert

Enable heißt "aktivieren", also sollte der auf +VCC geschaltet werden.

Danke für die Info!
Dann gebe ich auf den enable Pin auch noch +5V vom Arduino

Ja das ist okay.

Oder verbinde ihn auf dem Modul einfach mit Vin.

Gruß Tommy

Mal eine kurze Erklährung was der LTC4311 macht:
Normalerweise schaltet man 2 pullup Widerstände um die beiden Leitungen des Busses auf HIGH zu bringen. Diese Widerstände laden die beiden Leitungen wieder auf die Versorgungsspannung. Ich sage "laden" weil die Kabel eine Kapazität gegenüber Masse haben bzw die I2C Devicees in der Eingangsschaltung auch etwas Strom brauchen. Dadurch braucht es etwas Zeit damit die Spannung auf Endwert angestiegen ist. Im Oszylosgramm erkennt man eine abgerundete L-H Kante.

Die Ausgänge des LTC4311 werden einfach an SDA bzw SCL angeschlossen.


Auf dem gezeigten Schaltplan ist die Versorgungsspannung 2,5V. Diese kann aber 1,8 V bis 5.5V betragen.

Wenn der Pullupwiderstand nach einem LOW-Signal den Spannungslevel auf der Leitung bis zu einem gewissen Wert geladen hat, tiggert der TLC und schaltet per Transistor die Versorgungsspannung auf die Leitung. Der höhere Strom durch den Transistor beschleunigt das Erreichen des HIGH-Pegels.

Unzweifelhaft begünstigt der TLC4311 die mögliche Länge eines I2C Busses. Ich bin mir aber keineswegs sicher welche die bessere Wahl ist:
Langer Kabel und I2C Accelerator TLC4311 oder langer Kabel und zwei I2C Extender wie zB P82B715

Grüße Uwe

Ich denke, da gibt es kein allgemeines "besser". Das wird in jedem >Fall von den konkreten Gegebenheiten abhängen. Mit dem TLC4311 ist der Aufbau erst mal einfacher. Wenn es funktioniert - ok, sonst muss halt die andere Variante ran.

Gruß Tommy

Und für 2m Kabelweg wird das wohl auch der einfachere Weg sein.
In früheren Versuchen hat bei mir auch 2m ohne zusätzliche Komponenten funktioniert. War wie gesagt nur ein Versuch und keine Endinstallation.
Mit niedriger Taktfrequenz und keinerlei Störungen im Umfeld.

Hallo,

Danke für die vielen Rückmeldungen.

ich habe nun gerade den LTC4311 mittels 2m geschirmten Netzwerkkabel zum Display hin eingebaut, wobei mit LTC4311 beginnt sich nun nun schon der Arduino beim Auswahl im Menü aufzuhängen. Allerdings würde ich vom Gefühl her sagen, dass das Display mit LTC4311 schneller überschrieben wird. Ich kann mich aber auch täuschen.

Ohne den LTC4311 und mit ca. 2,5m langen ungeschirmten Netzwerkkabel war dies nie der Fall, dass sich der Arduino schon im Auswahlmenü aufgehängt hat.
Hier hing er sich immer nur während der vierten Überschreibung des LCD´s im Programm auf.

Merkwürdig finde ich dass 3 LCD Überschreibungen immer gingen nur, die vierte ging nicht mehr

Habt ihr eine Idee was hier mit LTC4311 nun falsch laufen könnte ?

Hier ein Link zum Video
In Sekunde 15 sieht man das aufhängen (gelbe leuchte blinkt nicht mehr, und bei Tastendruck gehen die Schrittmotoren nicht mehr.

Deiner Mitteilung zu Folge sieht es nach einem Problem mit dem I2C Bus aus.

Du solltest es mal ohne den LTC4311 und mit kurzen Kabeln probieren.
Dann den LTC4311 einbauen und testen. Mit kurzen Kabeln.
Dann berichten mit Foto des Aufbaus.
Dann geht es weiter.....
Und poste deinen Sketch hier in Code-Tags.

Hallo HotSystems,

den Code kann ich hier schon einmal posten, und vorab ein Bild vom Schaltschrank.
Eingefroren ist der Arduino immer in der Zeile 353 ( "LCD_Text_Schleifumkehr();" ) beim überschreiben des LCD´s.

Folgende LCD überschreibungen hat der Arduino witzigerweise im Programmablauf immer problemlos geschafft.

  • LCD_Text_Weiche();
  • manuele_Steuerung();
  • LCD_Text_Brielmaier();
  • LCD_Text_Referenzierung();
  • LCD_Text_rechts();

Die Idee mit dem kurzen Kabel zu testen finde ich sehr gut.
Den Umbau hierfür werde ich wohl erst morgen schaffen.....
Ich werde dann jeweils mit nur ein Spreadboard Kabel (ungeschirmt und ca. 20 cm lang) zum Adruino hin anschließen.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
#define MAX32BUTTONS
#include <MobaTools.h>
const int Sensor_vert_Schwenktisch = 45;       // vertikaler Schwenktisch mit NMRV050  =>  geschalten = 0  => ungeschalten = 1
const int Sensor_Drehtisch_unten = 43;         // horizontaler Drehtisch mit NMRV040   =>  geschalten = 0  => ungeschalten = 1
const int Sensor_Topfzustellbegrenzer = 29;    // Kapazitiver Näherungssensor 24V IFM für Abschaltung Topfzustellung S3   =>  geschalten = 0  => ungeschalten = 1
const int Opt_Klingensensor = 17;              // Reflexionslichttaster 24V
const int DSM_Rechtslauf = 18;                 // Anschluß X1 am FU  => Drehstrommotor dreht rechts
const int DSM_Linkslauf = 19;                  // Anschluß X2 am FU  => Drehstrommotor dreht0
MoToTimer   Schleifverweilzeit;
MoToTimer   Start_Leucht_Zeit;
MoToTimer   Verz_Hubeinschaltung;
MoToTimer   Verz_Hubausschaltung;
MoToTimer   Display;
MoToStepper S1(400, STEPDIR);          // bipolarer Schrittmotor Längschlitten
MoToStepper S2(400, STEPDIR);          // bipolarer Schrittmotor Schleifhub
MoToStepper S3(400, STEPDIR);          // bipolarer Schrittmotor Zustellung Schleiftopf
MoToStepper S4(400, STEPDIR);          // bipolarer Schrittmotor Drehtisch unten NMRV040
MoToStepper S5(400, STEPDIR);          // bipolarer Schrittmotor vertikaler Schwenktisch NMRV050
enum {Taster_Start, Taster_Stop, Taster_AEBI, Taster_Brielmaier, Taster_Handbetrieb, Taster_Pfeil_oben, Taster_Pfeil_unten, Taster_Pfeil_links, Taster_Pfeil_rechts, Endschalter_1_LS_links, Endschalter_2_LS_rechts, Endschalter_3_Hubtisch_oben };
const byte tasterPins[] = { 34, 38, 40, 44, 48, 35, 37, 39, 41, 30, 31, 28 };
MoToButtons taster( tasterPins, sizeof(tasterPins), 20, 500 );
enum ZUSTAENDE { Weiche, Manueller_Betrieb, Kontrolle_Pos_Topfscheibe, Kontrolle_Pos_Topfscheibe_Ende, Hauptreferenz, Hauptreferenz_Ende, suche_Ref_Sensor, beginn_Sensor_fahrt, Referenz_AEBI, Referenz_Brielmaier_rechts_Start, Referenz_Brielmaier_rechts_Ende, Bestaetigung_Brielmaier, LCD_faehrt_rechts, LS_faehrt_rechts, LS_faehrt_rechts_zur_Klinge, LS_faehrt_rechts_zur_Klinge_Ende, LS_faehrt_rechts_man, LS_faehrt_rechts_man_Ende, LS_Endschalter_rechts, LS_findet_Klinge_rechts, VS_faehrt_runter, VS_faehrt_hoch, VS_oben_angekommen,
                 LCD_Schleifumkehr, LCD_Schleifumkehr_1, Schleifumkehr_Brielmaier, Schwenkwechsel_Scleifumkehr_Brielmaier, Schwenkwechsel_Scleifumkehr_Brielmaier_Ende, LS_faehrt_links, LS_faehrt_links_zur_Klinge, LS_faehrt_links_man, LS_faehrt_links_man_Ende, LS_faehrt_links_zur_Klinge_Ende, LS_Endschalter_links, LS_findet_Klinge_links, VS_faehrt_runter_links, VS_faehrt_hoch_links, VS_oben_angekommen_links, Schlitten_fahrt_in_Neuralposition, Schlitten_in_Neuralposition_angekommen, Schlitten_man_Nachkorrektur, Schlitten_man_Nachkorrektur_Ende
               };
byte Zustand = Weiche;
enum Maschinenzustand { AUS, EIN, Man_Betrieb };
Maschinenzustand    Z_Start;
enum Richtung_LS { LINKS, RECHTS };      // Fahrrichtung vom Längsschlitten
Richtung_LS   Z_Schleifrichtung;
// ******** LED *********
const int led_Start =  36;
const int led_AEBI =  42;
const int led_Brielmaier =  46;
const int led_Handbetrieb =  50;
bool led_status = LOW;
unsigned long vergangene_Millis = 0;
const long interval = 500;
// ******** LED *********

void setup()
{
  Serial.begin (230400);
  lcd.init();                               // LCD Initialisieren
  lcd.backlight();                          // LCD Hintergrundbeleuchtung aktivieren
  LiquidCrystal_I2C lcd(0x27, 20, 4);       // LC Dsplay deffinieren
  pinMode(led_Start, OUTPUT);
  pinMode(led_AEBI, OUTPUT);
  pinMode(led_Brielmaier, OUTPUT);
  pinMode(led_Handbetrieb, OUTPUT);
  pinMode(Sensor_vert_Schwenktisch, INPUT);         //Kapazitiver Näherungsensor vom Schwenktisch NMRV050 24V Fa. IFM
  pinMode(Sensor_Drehtisch_unten, INPUT);           //Kapazitiver Näherungsensor vom Drehtisch NMRV040 24V Fa. IFM
  pinMode(Sensor_Topfzustellbegrenzer, INPUT);	    // Kapazitiver Näherungsensor bei Topfsacheibe 24V Fa. IFM
  pinMode(Opt_Klingensensor, INPUT);                // Reflexionslichttaster 24V Fa. IFM zum Klingendetektieren
  pinMode(DSM_Rechtslauf, OUTPUT);                  // Rechtslauf des Drehstrommotors  LOW = aus
  pinMode(DSM_Linkslauf, OUTPUT);                   // Linksslauf des Drehstrommotors LOW = aus
  S1.attach( 8, 9 );                   // STEPpin, DIRpin     =>     Schrittmotor Längschlitten
  S1.setSpeed( 100 );                  // Drehzahl / U/min
  S1.setRampLen( 0 );                  // Beschleunigungs / Verzögerungsramperampe (motorspezifisch)
  S2.attach( 11, 12 );                 // STEPpin, DIRpin     =>     Schrittmotor Schleifhub
  S2.setSpeed( 300 );                  // Drehzahl / U/min
  S2.setRampLen( 30 );                 // Beschleunigungs / Verzögerungsramperampe (motorspezifisch)
  S3.attach( 2, 3 );                   // STEPpin, DIRpin     =>     Schrittmotor Zustellung Schleiftopf
  S3.setSpeed( 2400 );                 // Drehzahl / U/min
  S3.setRampLen( 30 );                 // Beschleunigungs / Verzögerungsramperampe (motorspezifisch)
  S4.attach( 5, 6 );                   // STEPpin, DIRpin     =>     Schrittmotor Drehtisch unten
  S4.setSpeed( 700 );                  // Drehzahl / U/min
  S4.setRampLen( 10 );                 // Beschleunigungs / Verzögerungsramperampe (motorspezifisch)
  S5.attach( 14, 15 );                 // STEPpin, DIRpin     =>    SSchrittmotor vertikaler Schwenktisch
  S5.setSpeed( 800 );                  // Drehzahl / U/min
  S5.setRampLen( 3 );                  // Beschleunigungs / Verzögerungsramperampe (motorspezifisch)
  Z_Start = AUS;                       // Zustandsvariable für Start des Schleifvorganges
  Z_Schleifrichtung = RECHTS;          // Zustandsvariable der Schleifrichtung des Längsschlittens
}
void loop()
{
  //   Serial.println(Zustand);
  //   Serial.println(Z_Schleifrichtung);
  //   Serial.println(Z_Start);
  taster.processButtons();                                         // Taster Einlesen und bearbeiten
  int Z_Opt_Klingensensor = digitalRead(Opt_Klingensensor);                              // 24V Optischer IFM-Sensor => geschalten = 0  => ungeschalten = 1
  int Z_Kap_Sensor_vert_Schwenktisch = digitalRead(Sensor_vert_Schwenktisch);            // Zustand Sensor => geschalten = 0  => ungeschalten = 1
  int Z_Kap_Sensor_Drehtisch_unten = digitalRead(Sensor_Drehtisch_unten);                // Zustand Sensor => geschalten = 0  => ungeschalten = 1
  int Z_Kap_Sensor_Topfzustellbegrenzer = digitalRead(Sensor_Topfzustellbegrenzer);      // Zustand Sensor => geschalten = 0  => ungeschalten = 1
  // static byte status = 0;                                          // Schrittkettenstatus

  /***********************************************/
  /*        Weichen-Abfrage vor dem Start        */
  /***********************************************/

  if (taster.pressed(Taster_Stop))             // Stop Funktion
  {
    S1.stop();                            // im Gegensatz zu S1.rotate(0) führt S1.stop(0) zu einem sofortigen anhalten ohne Rampe  => Stop vom Längsschlitten
    S2.stop();                            // Stop vom  Schleifhub
    S3.stop();                            // Stop von Zustellung Schleiftopf
    S4.stop();                            // Stop von horizontaler Drehtisch unten NMRV040
    S5.stop();                            // Stop von vertikaler Schwenktisch NMRV050
    digitalWrite(DSM_Rechtslauf, LOW);    // Stop vom Drehstrommotor im Fall eines Rechtslauf
    digitalWrite(DSM_Linkslauf, LOW);     // Stop vom Drehstrommotor im Fall eines Linkslauf
    Z_Start = AUS;
    Zustand = Weiche;
  }

  switch (Zustand)
  {
    /***********************************************/
    /*        Weichen-Abfrage vor dem Start        */
    /***********************************************/
    case Weiche:
      LCD_Text_Weiche();
      blinken_Messerauswahl();              // wurde als Methode programmiert und befindet sich unter dem loop - Teil

      if (taster.pressed(Taster_Handbetrieb))   //Wenn der Knopf für manuelle Steuerung gedrückt wird sollte mit den 4 Stk Pfeiltasten der Horizontale und vertikale Drehtisch geschwenkt werden
      {
        Z_Start = Man_Betrieb;
        Zustand = Manueller_Betrieb;
      }
      if (taster.pressed(Taster_Brielmaier))   //Beginn der Referenzierung für Brielmaier
      {
        Z_Start = AUS;
        Zustand = Bestaetigung_Brielmaier;
      }
      break;

    /***********************************************/
    /*                 Brielmaier                  */
    /***********************************************/

    case Bestaetigung_Brielmaier:

      LCD_Text_Brielmaier();
      if (taster.pressed(Taster_Start))   // Wenn der Startknopf gedrückt wird, gelangt man zur Referenzierung
      {
        Z_Start = AUS;
        Zustand = Kontrolle_Pos_Topfscheibe;
        //  Start_Leucht_Zeit.setTime(6000);
        digitalWrite(led_Start, LOW);
      }
      if (taster.pressed(Taster_Stop))   // Wenn der Startknopf gedrückt wird, gelangt man zur Referenzierung
      {
        Z_Start = AUS;
        Zustand = Weiche;
      }
      else
      {
        blinken_Bestaetigung();         //Startknopf blinkt bis bestättigt
      }
      break;
    /***********************************************************/
    /*           Kontrolle Position Topfscheibe                */
    /***********************************************************/
    case Kontrolle_Pos_Topfscheibe:
      LCD_Text_Referenzierung();
      if (taster.state(Endschalter_3_Hubtisch_oben) == LOW) {            //wenn Endschalter von Schleiftopf nicht gedrückt ist, dann fährt der Schleiftopf S3 nach oben
        S3.rotate(1);
        Z_Start = AUS;
        Zustand = Kontrolle_Pos_Topfscheibe_Ende;
      } else {
        Z_Start = AUS;
        Zustand = Hauptreferenz;
      }
      break;
    /***********************************************************/
    /*            Kontrolle ob Topfscheibe oben ist            */
    /***********************************************************/

    case Kontrolle_Pos_Topfscheibe_Ende:
      if (taster.state(Endschalter_3_Hubtisch_oben) == HIGH) {     //wenn der Schleiftopf oben angekommen ist, stoppt S3
        S3.stop();
        Z_Start = AUS;
        Zustand = Hauptreferenz;
      }
      break;
    /***********************************************/
    /*                Hauptreferenz                */
    /***********************************************/
    // Referenzierung (Nullung) des Schwenk & Drehtisches
    case Hauptreferenz:
      S4.doSteps(-700);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren => Drehtisch aus dem Sensor bewegen
      S5.doSteps(700);     // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren => Drehtisch aus dem Sensor bewegen
      Z_Start = AUS;
      Zustand = Hauptreferenz_Ende;
      break;
    /***********************************************/
    /*              Hauptreferenz_Ende             */
    /***********************************************/
    case Hauptreferenz_Ende:
      if (!S4.moving() && !S5.moving()) {      // Abwarten bis die Drehtische die 700 Steps gefahren sind
        Z_Start = AUS;
        Zustand = beginn_Sensor_fahrt;
      }
      break;
    /***************************************/
    /*        beginn der Ref-fahrt         */
    /***************************************/
    case beginn_Sensor_fahrt:
      S4.rotate(1);                         // Drehtisch_unten zum Sensor fahren lassen
      S5.rotate(-1);                        // vert_Schwenktisch zum Sensor fahren lassen
      Z_Start = AUS;
      Zustand = suche_Ref_Sensor;
      break;
    /********************************************************/
    /*        suche Referenz mit Kap. Sensor S4 und S5      */
    /********************************************************/
    case suche_Ref_Sensor:
      if ( Z_Kap_Sensor_Drehtisch_unten == 0 ) {           // wenn Drehtisch in 0-Position angekommen ist, stoppt Kap.Sensor S4
        S4.rotate(0);
      }
      if ( Z_Kap_Sensor_vert_Schwenktisch == 0 ) {         // wenn Schwenktisch in 0-Position angekommen ist, stoppt Kap.Sensor S5
        S5.rotate(0);
      }
      if ( Z_Kap_Sensor_Drehtisch_unten == 0 && Z_Kap_Sensor_vert_Schwenktisch == 0)
      {
        Z_Start = AUS;
        Zustand = Referenz_Brielmaier_rechts_Start;
      }
      break;
    /********************************************************/
    /*      Ref. Schwenk und Drehtisch fuer Brielmaier      */
    /********************************************************/
    case Referenz_Brielmaier_rechts_Start:
      S4.doSteps(2333);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren => horizontalen Drehtisch unten NMRV040 in Schleifposition bringen
      S5.doSteps(3857);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren => vertikaler Schwenktisch NMRV050 in Schleifposition bringen
      Z_Start = AUS;
      Zustand = Referenz_Brielmaier_rechts_Ende;
      break;
    /*******************************************************************/
    /*      Einstellen der Schleifwinkel für Schwenk und Drehtisch     */
    /*******************************************************************/
    case Referenz_Brielmaier_rechts_Ende:
      if (!S4.moving() && !S5.moving()) {   //wenn der Schwenk und Drehtisch in Position ist (S4 und S5 haben alle Steps abgefahren), beginnt der Schleifvorgang
        Z_Start = EIN;
        Zustand = LCD_faehrt_rechts;
      }
      break;
    /***********************************************/
    /*                 Handbetrieb                 */
    /***********************************************/
    case Manueller_Betrieb:
      if (taster.pressed(Taster_Handbetrieb))  {  //mit Taster für Handbetrieb gelangt man wieder zurück in die Weiche
        S1.rotate(0);
        S2.rotate(0);
        S3.rotate(0);
        S4.rotate(0);
        S5.rotate(0);
        Z_Start = AUS;
        Zustand = Weiche;
      }
      else
      {
        blinken_manueler_Betr();
        manuele_Steuerung();
      }
      break;

    case LCD_faehrt_rechts:
      LCD_Text_rechts();
      Zustand = LS_faehrt_rechts;       // mit LS fährt rechts beginnt der Schleifumkehrprozess
      break;
    /***********************************************/
    /*          Beginn des Schleifvorganges        */
    /*      Schleifrichtung erfolgt nach Rechts    */
    /***********************************************/
    case LS_faehrt_rechts:                     // Der Längsschlitten angetrieben von S1 faehrt solange nach RECHTS, solange KEIN Sensorsignal vom Opt_Klingensensor ankommt
      if ( Z_Opt_Klingensensor == 1  && Z_Start == EIN && Z_Schleifrichtung == RECHTS)  {
        S1.rotate(-1);
        digitalWrite(DSM_Rechtslauf, LOW);      // DSM wird in Linkslauf gestartet => Linkslauf für Schleifrichtung nach rechts
        digitalWrite(DSM_Linkslauf, HIGH);      // DSM wird in Linkslauf gestartet => Linkslauf für Schleifrichtung nach rechts
        Zustand = LS_Endschalter_rechts;        // Wenn Endschalter rechts vom Längsschlitten ereicht wird, nachdem die letzte Klinge im Rechtslauf angefahren wurde => wird der Schleifumkehrprozess aktiviert
      }
      break;
    case LS_Endschalter_rechts:                // nach der letzten Klinge fährt der Längsschlitten S1 solange nach RECHTS bis er an den Endschalter Taster 2 kommt
      if (S1.moving() && taster.state(Endschalter_2_LS_rechts) == HIGH)
      {
        S1.rotate(0);
        Z_Schleifrichtung = LINKS;
        Zustand = LCD_Schleifumkehr;
      }
      else                                     // Wenn der Längsschlitten angetrieben durch S1 vom Sensor EIN Signal bekommt, stoppt S1 und der Schleifvorgang wird eingeleitet
      {
        if ( Z_Opt_Klingensensor == 0 ) {
          Zustand = LS_findet_Klinge_rechts;
        };
      }
      break;

    case LS_findet_Klinge_rechts:                  // wenn der Klingensensor eine Klinge gefunden hat stoppt der Längsschlitten, und der Schleifvorgang beginnt
      if ( Z_Opt_Klingensensor == 0 ) {            // Klingensensor hat Klinge gefunden
        Zustand = LS_faehrt_rechts_zur_Klinge;
      }
      break;
    /***************************************************/
    /*    Sensor Händisch näher zur klinge Stellen     */
    /***************************************************/
    case LS_faehrt_rechts_zur_Klinge:
      S1.doSteps(-35);                           // Es werden noch 35 Extraschritte hinzugefügt, damit S1 näher zur Klinge fährt
      S3.rotate(-1);                             // Vertikaler Schlitten fährt runter zur Klinge
      S2.rotate(1);                              // Der Schleifhub wird eingeschalten
      Zustand = LS_faehrt_rechts_zur_Klinge_Ende;
      break;

    case LS_faehrt_rechts_zur_Klinge_Ende:
      if (!S1.moving()) {                        // wenn der längsschlitten alle Steps gefahren ist, wird der Vertikalschlitten nach unten gefahren
        Zustand = VS_faehrt_runter;
      }
      break;

    case VS_faehrt_runter:                                      // Vertikaler Schlitten fährt runter zur Klinge
      if ( Z_Kap_Sensor_Topfzustellbegrenzer == 0 ) {           // Endschalter zur Deaktivierung der fahrt des Vertikalschlittens nach unten
        S3.rotate(0);
        Schleifverweilzeit.setTime(6000);                         // aufziehen des timmers für die Schleifzeit
        Zustand = VS_faehrt_hoch;
      }
      break;

    case VS_faehrt_hoch:                       // Vertikaler Schlitten fährt hoch zum Endschalter_3_Hubtisch_oben
      if ( !Schleifverweilzeit.running() ) {   // Wenn der Timer der Schleifzeit abgelaufen ist fährt die Topfsacheibe wieder hoch
        S3.rotate(1);
        Verz_Hubausschaltung.setTime(1000);    // Aufziehen der Zeit in welcher der Schleifhub ausgeschalten wird
        Zustand = VS_oben_angekommen;
      }
      break;

    case VS_oben_angekommen:                    // Wenn der Vertikalschlitten (S3) oben angekommen ist, betätigt dieser den Endschalter Taster 4 und S3 stoppt
      if ( !Verz_Hubausschaltung.running() ) {  // Wenn der Timer abgelaufen ist wird der Schleifhub ausgeschaltet
        S2.rotate(0);
      }
      if (taster.state(Endschalter_3_Hubtisch_oben) == HIGH) {
        S3.rotate(0);
        Zustand = LS_faehrt_rechts_man;
      }
      break;
    /*************************************************************/
    /*       Übersteuerung um aus Sensorsignal zu kommen         */
    /*************************************************************/
    case LS_faehrt_rechts_man:
      S1.doSteps(-100);
      Zustand = LS_faehrt_rechts_man_Ende;
      break;
    /*************************************************************/
    /*        warten bis manuelle fahrt beendet ist              */
    /*************************************************************/
    case LS_faehrt_rechts_man_Ende:
      if (!S1.moving()) {       //nun ist der Klingensensor wieder aus dem Signal und kann die nächste Klinge erfassen
        Zustand = LS_faehrt_rechts;
      }
      break;
      
    case LCD_Schleifumkehr:
      Serial.println(F("D000 Schleifenumkehr"));
      // LCD_Text_Schleifumkehr();
      Serial.println(F("D001"));
      Zustand = LCD_Schleifumkehr_1;
      Serial.println(F("D002 fertig"));
      break;

    case LCD_Schleifumkehr_1:  // Hier ist das große Problem

      Zustand = Schleifumkehr_Brielmaier;
      Serial.println(F("D100 fertig"));
      break;
    /***********************************************/
    /*          Schleifrichtungsumkehr             */
    /***********************************************/
    case Schleifumkehr_Brielmaier:                        // nach der letzten Klinge fährt der Längsschlitten S1 solange nach RECHTS bis er an den rechten Endschalter Taster 2 kommt.
      if (Z_Schleifrichtung == LINKS) {
        digitalWrite(DSM_Rechtslauf, LOW);     // DSM wird abgeschalten
        digitalWrite(DSM_Linkslauf, LOW  );    // DSM wird abgeschalten
        Zustand = Schwenkwechsel_Scleifumkehr_Brielmaier;
      }
      break;

    case Schwenkwechsel_Scleifumkehr_Brielmaier:
      S4.doSteps(-4675);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren  => horizontalen Drehtisch unten NMRV040 in Schleifposition für Schleifvorgang nach links bringen
      S5.doSteps(-7697);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren  => vertikaler Schwenktisch NMRV050 in Schleifposition für Schleifvorgang nach links bringen
      Zustand = Schwenkwechsel_Scleifumkehr_Brielmaier_Ende;
      break;

    case Schwenkwechsel_Scleifumkehr_Brielmaier_Ende:
      if (!S4.moving() && !S5.moving()) {       //wenn der Schwenk und Drehtisch in Position ist (S4 und S5 haben beide angehalten), beginnt der Schleifvorgang
        digitalWrite(DSM_Rechtslauf, HIGH);     // DSM wird in rechtslauf gestartet => rechtslauf für Schleifrichtung nach links
        digitalWrite(DSM_Linkslauf, LOW);       // DSM wird in rechtslauf gestartet => rechtslauf für Schleifrichtung nach links
        Zustand = LS_faehrt_links;
      }
      break;
    /***********************************************/
    /*     Schleifrichtung erfolgt nach Links      */
    /***********************************************/
    case LS_faehrt_links:                        // Nach dem Umschalten der Schleifrichtung werden die Klingen auf der zweiten Seite nach links geschliffen
      if ( Z_Opt_Klingensensor == 1  && Z_Schleifrichtung == LINKS)  {   // Der Längsschlitten angetrieben von S1 faehrt solange nach Links, solange KEIN Sensorsignal vom Opt_Klingensensor ankommt
        S1.rotate(1);
        Zustand = LS_Endschalter_links;
      }
      break;

    case LS_Endschalter_links:                   // nach der letzten Klinge fährt der Längsschlitten S1 solange nach Links bis er an den Endschalter Taster 1 kommt => dadurch wird der Schleifvorgang beendet und , die Drehtische werden in 0-Position geschwenkt
      if (S1.moving() && taster.state(Endschalter_1_LS_links) == HIGH)
      {
        S1.rotate(0);
        digitalWrite(DSM_Rechtslauf, LOW);        // DSM wird abgeschalten
        digitalWrite(DSM_Linkslauf, LOW);         // DSM wird abgeschalten
        Z_Start = AUS;
        Z_Schleifrichtung = RECHTS;
        Zustand = Schlitten_fahrt_in_Neuralposition;
      }
      else
      {
        if ( Z_Opt_Klingensensor == 0 ) {            // sollte der Klingensensor eine Klinge finden beginnt wieder ein Schleifprozess
          Zustand = LS_findet_Klinge_links;
        };
      }
      break;

    case LS_findet_Klinge_links:                     // wenn der Klingensensor eine Klinge gefunden hat stoppt der Längsschlitten, und der Schleifvorgang beginnt
      if ( Z_Opt_Klingensensor == 0 ) {              // Klingensensor hat Klinge gefunden
        Zustand = LS_faehrt_links_zur_Klinge;
      }
      break;

    case LS_faehrt_links_zur_Klinge:
      S1.doSteps(40);                           // Es werden noch 40 Extraschritte hinzugefügt, damit S1 näher zur Klinge fährt
      S3.rotate(-1);                            // Vertikaler Schlitten fährt runter zur Klinge
      Zustand = LS_faehrt_links_zur_Klinge_Ende;
      break;

    case LS_faehrt_links_zur_Klinge_Ende:
      if (!S1.moving()) {                    // wenn der längsschlitten alle Steps gefahren ist, wird der Vertikalschlitten nach unten gefahren
        Verz_Hubeinschaltung.setTime(1200);  // aufziehen des Timers für Schleifhubeinschaltung
        Zustand = VS_faehrt_runter_links;
      }
      break;

    case VS_faehrt_runter_links:                              // Vertikaler Schlitten fährt runter zur Klinge
      if ( !Verz_Hubeinschaltung.running() ) {   // Wenn der Timer abgelaufen ist sollte der Schleifhub einschalten
        S2.rotate(1);                            // Der Schleifhub wird eingeschalten
      }
      if ( Z_Kap_Sensor_Topfzustellbegrenzer == 0 ) {         // Kap Sensor zur Deaktivierung der fahrt des Vertikalschlittens nach unten
        S3.rotate(0);
        Schleifverweilzeit.setTime(6000);          // aufziehen des timmers für die Schleifzeit
        Zustand = VS_faehrt_hoch_links;
      }
      break;

    case VS_faehrt_hoch_links:
      if ( !Schleifverweilzeit.running() ) {         // Wenn der Timer der Schleifzeit abgelaufen ist fährt der Längsschlitten andem der Schleifmotor befestigt ist wieder hoch
        S3.rotate(1);
        Verz_Hubausschaltung.setTime(1000);
        Zustand = VS_oben_angekommen_links;
      }
      break;

    case VS_oben_angekommen_links:                    // Wenn der Vertikalschlitten (S3) oben angekommen ist, betätigt dieser den Endschalter Taster 4 und S3 stoppt
      if ( !Verz_Hubausschaltung.running() ) {
        S2.rotate(0);
      }
      if (taster.state(Endschalter_3_Hubtisch_oben) == HIGH) {
        S3.rotate(0);
        Zustand = LS_faehrt_links_man;             // Ein neuer Schleifvorgang beginnt indem eine neue Klinge vom Längsschlitten angefahren wird
      }
      break;
    /*********************************************************************/
    /*        LS fährt nach dem Sensorsignal der Klinge noch weiter      */
    /*********************************************************************/
    case LS_faehrt_links_man:
      S1.doSteps(100);        // Längsschlitten fährt 100 extraschritte um näher zur klinge zu kommen
      Zustand = LS_faehrt_links_man_Ende;
      break;

    case LS_faehrt_links_man_Ende:
      if (!S1.moving()) {   //wenn der Schwenk und Drehtisch in Position ist (S4 und S5 sind gestoppt), beginnt der Schleifvorgang
        Zustand = LS_faehrt_links;
      }
      break;
    /************************************************************************************/
    /*     Schlittenstellung fährt am Ende des Schleifvorganges in Neutralposition      */
    /************************************************************************************/

    case Schlitten_fahrt_in_Neuralposition:    // am Ende des Schleifvorganges werden beide Schlitten wieder in die 0-Position gestellt.
      S4.rotate(1);
      S5.rotate(1);
      Zustand = Schlitten_in_Neuralposition_angekommen;
      break;

    case Schlitten_in_Neuralposition_angekommen:
      if ( Z_Kap_Sensor_Drehtisch_unten == 0 ) {           // wenn Drehtisch in Position, stoppt Kap.Sensor S4
        S4.rotate(0);
      }
      if ( Z_Kap_Sensor_vert_Schwenktisch == 0 ) {         // wenn Schwenktisch in Position, stoppt Kap.Sensor S5
        S5.rotate(0);
      }
      if ( Z_Kap_Sensor_Drehtisch_unten == 0 && Z_Kap_Sensor_vert_Schwenktisch == 0)
      {
        Z_Start = AUS;
        Zustand = Schlitten_man_Nachkorrektur;
      }
      break;

    case Schlitten_man_Nachkorrektur:
      S1.doSteps(-77);
      S3.doSteps(-770);
      S5.doSteps(350);
      Z_Start = AUS;
      Zustand = Schlitten_man_Nachkorrektur_Ende;
      break;

    case Schlitten_man_Nachkorrektur_Ende:
      if (!S1.moving() && !S3.moving() && !S5.moving()) {
        Z_Start = AUS;
        Z_Schleifrichtung = RECHTS;
        Zustand = Weiche;
      }
      break;
      /***************************************************************/
      /*     Schlittenstellung fährt  in Neutralposition   ENDE      */
      /***************************************************************/
  }
}

/***********************************************/
/*                 Methoden                    */
/***********************************************/

void blinken_Messerauswahl()
{
  unsigned long aktuelle_Millis = millis();
  if (aktuelle_Millis - vergangene_Millis >= interval) {
    vergangene_Millis = aktuelle_Millis;
    if (led_status == LOW) {
      led_status = HIGH;
    } else {
      led_status = LOW;
    }
    digitalWrite(led_Start, HIGH);  // HIGH ist ausgeschaltet
    digitalWrite(led_Handbetrieb, led_status);
    digitalWrite(led_AEBI, led_status);
    digitalWrite(led_Brielmaier, led_status);
  }
}

void blinken_manueler_Betr()
{
  unsigned long aktuelle_Millis = millis();
  if (aktuelle_Millis - vergangene_Millis >= interval) {
    vergangene_Millis = aktuelle_Millis;
    if (led_status == LOW) {
      led_status = HIGH;
    } else {
      led_status = LOW;
    }
    digitalWrite(led_Handbetrieb, led_status);
    digitalWrite(led_Start, HIGH);            // HIGH ist ausgeschaltet
    digitalWrite(led_AEBI, HIGH);             // HIGH ist ausgeschaltet
    digitalWrite(led_Brielmaier, HIGH);       // HIGH ist ausgeschaltet
  }
}

void blinken_Bestaetigung()
{
  unsigned long aktuelle_Millis = millis();
  if (aktuelle_Millis - vergangene_Millis >= interval) {
    vergangene_Millis = aktuelle_Millis;
    if (led_status == LOW) {
      led_status = HIGH;
    } else {
      led_status = LOW;
    }
    digitalWrite(led_Start, led_status);
    digitalWrite(led_Handbetrieb, HIGH);
    digitalWrite(led_AEBI, HIGH);
    digitalWrite(led_Brielmaier, HIGH);
  }
}

/*
  void blinken_off()
  {
  digitalWrite(led_Start, LOW);
  digitalWrite(led_Handbetrieb, LOW);
  digitalWrite(led_AEBI, LOW);
  digitalWrite(led_Brielmaier, LOW);
  }
*/

void LCD_Text_Weiche()
{
  Serial.println(F("A010 Weiche"));
  lcd.setCursor(0, 0);                    // Cursor für Text in 1-er Reihe
  lcd.print(F("Welche Klinge sollte"));
  lcd.setCursor(0, 1);                    // Cursor für Text in 2-er Reihe
  lcd.print(F("geschaerft werden   "));
  lcd.setCursor(0, 2);                    // Cursor für Text in 3-er Reihe
  lcd.print(F("Taste rot  = AEBI   "));
  lcd.setCursor(0, 3);                    // Cursor für Text in 4-er Reihe
  lcd.print(F("Taste blau = BM     "));
}

void LCD_Text_Referenzierung()
{
  lcd.setCursor(0, 0);                    // Cursor für Text in 1-er Reihe
  lcd.print(F("Beginn der          "));
  lcd.setCursor(0, 1);                    // Cursor für Text in 2-er Reihe
  lcd.print(F("Referenzierung      "));
  lcd.setCursor(0, 2);                    // Cursor für Text in 3-er Reihe
  lcd.print(F("                    "));
  lcd.setCursor(0, 3);                    // Cursor für Text in 4-er Reihe
  lcd.print(F("                    "));
}

void LCD_Text_rechts()
{
  lcd.setCursor(0, 0);                    // Cursor für Text in 1-er Reihe
  lcd.print(F("Der Schleifvorgang  "));
  lcd.setCursor(0, 1);                    // Cursor für Text in 2-er Reihe
  lcd.print(F("ist im Laufen       "));
  lcd.setCursor(0, 2);                    // Cursor für Text in 3-er Reihe
  lcd.print(F("Schleifrichtung     "));
  lcd.setCursor(0, 3);                    // Cursor für Text in 4-er Reihe
  lcd.print(F("nach rechts         "));
  Zustand = LS_faehrt_rechts;       // mit LS fährt rechts beginnt der Schleifumkehrprozess
}

void LCD_Text_Brielmaier()
{
  lcd.setCursor(0, 0);                    // Cursor für Text in 1-er Reihe
  lcd.print(F("Brielmaier wurde    "));
  lcd.setCursor(0, 1);                    // Cursor für Text in 2-er Reihe
  lcd.print(F("ausgewaehlt, zum    "));
  lcd.setCursor(0, 2);                    // Cursor für Text in 3-er Reihe
  lcd.print(F("Bestaettigen        "));
  lcd.setCursor(0, 3);                    // Cursor für Text in 4-er Reihe
  lcd.print(F("Start Knopf Druecken"));
}

void LCD_Text_Schleifumkehr()
{
  Serial.println(F("D010 Schleifenumkehr_1"));
  lcd.setCursor(0, 0);                    // Cursor für Text in 1-er Reihe
  Serial.println(F("D020"));
  lcd.print(F("Die rechte Seite ist"));  // Fixtexte mit F-Makro im Flash belassen
  Serial.println(F("D030"));
  lcd.setCursor(0, 1);                    // Cursor für Text in 2-er Reihe
  Serial.println(F("D040"));
  lcd.print(F("fertig geschliffen"));
  Serial.println(F("D050"));
  lcd.setCursor(0, 2);                    // Cursor für Text in 3-er Reihe
  Serial.println(F("D060"));
  lcd.print(F("Die Schleifrichtung"));
  Serial.println(F("D070"));
  lcd.setCursor(0, 3);                    // Cursor für Text in 4-er Reihe
  Serial.println(F("D080"));
  lcd.print(F("wird nun umgekehrt "));
  Serial.println(F("D090"));
}


void manuele_Steuerung()
{
  lcd.setCursor(0, 0);                    // Cursor für Text in 1-er Reihe
  lcd.print(F("Manueller Betr      "));
  lcd.setCursor(0, 1);                    // Cursor für Text in 2-er Reihe
  lcd.print(F("zum Beenden gelben  "));
  lcd.setCursor(0, 2);                    // Cursor für Text in 3-er Reihe
  lcd.print(F("Knopf Druecken      "));
  lcd.setCursor(0, 3);                    // Cursor für Text in 3-er Reihe
  lcd.print(F("                    "));

  if (taster.pressed(Taster_Pfeil_links)) {
    S4.rotate(-1);
  }
  if ( taster.released(Taster_Pfeil_links)) {
    S4.rotate(0);
  }
  if (taster.pressed(Taster_Pfeil_rechts)) {
    S4.rotate(1);
  }
  if ( taster.released(Taster_Pfeil_rechts)) {
    S4.rotate(0);
  }
  if (taster.pressed(Taster_Pfeil_oben)) {
    S5.rotate(1);
  }
  if ( taster.released(Taster_Pfeil_oben)) {
    S5.rotate(0);
  }
  if (taster.pressed(Taster_Pfeil_unten)) {
    S5.rotate(-1);
  }
  if ( taster.released(Taster_Pfeil_unten)) {
    S5.rotate(0);
  }
}

LG
Christian

Wenn das Schreiben von Text auf das Display grundsätzlich funktioniert und erst bei einem bestimmten Text bzw. Position der Absturz erfolgt, dann ist der Grund bzw. Auslöser ein anderer.

Was genau soll denn an der Stelle noch passieren ? Wird da ein Magnet oder Motor gestartet bzw. angehalten. Da vermute ich eher dein Problem.
Das produziert Störungen, die den I2C-Bus zum Absturz bringen können.

Du solltest auch mal eine HeardBeat-Led mit einbauen, an der du genau erkennen kannst, ob der Controller noch rennt.

Edit:
Dein Schaltschrank sieht seht nach Störungen aus.
Nur um da evtl. mal drüber nachzudenken.

Also der TO ist sich sicher das alles iO ist nur der LCD spint
na ja viel Erfolg

Fony, danke dir für die Erleuchtung.

Da soll der TO erst mal seinen Schaltschrank auf einen sauberen Stand bringen.
So wird das nichts. Und danke an den TO für die gelungene Irreführung.

Ich bin hier raus, meine Zeit kann ich besser verbringen.