Schrittkette + LCD Display unterbricht abfolge in Schrittkette

bitte stell mal die schnarchlangsamen 9600 auf mind. 115200 um und mach den Test noch mal.
Wie schon Microbahner: wie lange ist die Leitung zwischen Mega und LCD?
Kannst du klare Bilder einstellen wo man die Module und deren Verkabelung erkennt?

Hallo my_xy_projekt,
Hallo MicroBahner,

das auskommentieren der lcd.clear(); Zeile funktioniert leider auch nicht.

Das I2C Kabel ist ein ungeschirmtes CAT5E Netzwerkkabel mit ca 2m Leitungslänge.
Paralell laufen noch die Leitungen zu den Tasten am Bedienpult. Diese haben eine Spannung von 24 V.

Aber findest Du es nicht kommisch, dass es sich immer nur dann aufhängt wenn ich den LCD beim Richtungswechsel neu beschreiben möchte ?

Wenn Ich denn LCD Text des Richtungswechsels deaktiviere und √ľber den gesamten Schleifprozess den LCD Text vom Case:" LCD_faehrt_rechts:" in der Zeile 368 drinnen lasse, funktioniert das LCD und der gesamte Prozess ganz normal. Ich komme auch am Ende des Schleifprozesses wieder in die Weiche zur√ľck wo das LCD Display den Text √§ndert, jenachdem welchen Knopf ich Dr√ľcke.

Das dass ein Abschirmungsproblem ist w√ľrde ich daher eher ausschlie√üen, da der Schleifprozess mit funktioniereden Display nur halt ohne den Text beim Richtungswechsel ansonsten auch nicht funktionieren d√ľrfte, und so ein Schleifprozess dauert ja ca 15 min, da bauen sich sicher mehr Magnetfelder oder andere St√∂rsignale auf als in den 30 Sekunden in denen ich ihn zum probieren f√ľr das Display am laufen habe.
Oder liege ich da am Holzweg mit meiner Vermutung.

hier der aktuelle code:

#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;

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
MoToStepper S5(400, STEPDIR);          // bipolarer Schrittmotor vertikaler Schwenktisch


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 blinken *********

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 aus *********

void setup()
{

  Serial.begin (9600);                      // Start des seriellen Einlesens der Sensoren

  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
  pinMode(Sensor_Drehtisch_unten, INPUT);           //Kapazitiver Näherungsensor vom Drehtisch NMRV040
  pinMode(Sensor_Topfzustellbegrenzer, INPUT);	    // Kapazitiver Näherungsensor 24V Fa. IFM
  pinMode(Opt_Klingensensor, INPUT);                // Reflexionslichttaster 24V Fa. IFM zum Klingendetektieren

  pinMode(DSM_Rechtslauf, OUTPUT);                  // Rechtslauf des Drehstrommotors
  pinMode(DSM_Linkslauf, OUTPUT);                   // Linksslauf des Drehstrommotors

  S1.attach( 8, 9 );                   // STEPpin, DIRpin     =>     Schrittmotor Längschlitten
  S1.setSpeed( 100 );                  // = 80 U/Min (motorspezifisch)
  S1.setRampLen( 0 );                  // Beschleunigung (motorspezifisch)

  S2.attach( 11, 12 );                 // STEPpin, DIRpin     =>     Schrittmotor Schleifhub
  S2.setSpeed( 300 );                  // = 80 U/Min (motorspezifisch)
  S2.setRampLen( 30 );                 // Beschleunigung (motorspezifisch)

  S3.attach( 2, 3 );                   // STEPpin, DIRpin     =>     Schrittmotor Zustellung Schleiftopf
  S3.setSpeed( 2400 );                 // = 80 U/Min (motorspezifisch)
  S3.setRampLen( 30 );                 // Beschleunigung (motorspezifisch)

  S4.attach( 5, 6 );                   // STEPpin, DIRpin     =>     Schrittmotor Drehtisch unten
  S4.setSpeed( 700 );                  // = 80 U/Min (motorspezifisch)
  S4.setRampLen( 10 );                 // Beschleunigung (motorspezifisch)

  S5.attach( 14, 15 );                  // STEPpin, DIRpin     =>    SSchrittmotor vertikaler Schwenktisch
  S5.setSpeed( 800 );                   // = 80 U/Min (motorspezifisch)
  S5.setRampLen( 3 );                   // Beschleunigung (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();
    S3.stop();                            // Stop vom Vertikalschlitten
    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:
      Serial.println(F("A010 Weiche"));
      lcd.setCursor(0, 0);                    // Text in 1-er Reihe
      lcd.print(F("Welche Klinge sollte"));
      lcd.setCursor(0, 1);                    // Text in 2-er Reihe
      lcd.print(F("geschaerft werden   "));
      lcd.setCursor(0, 2);                    // Text in 3-er Reihe
      lcd.print(F("Taste rot  = AEBI   "));
      lcd.setCursor(0, 3);                    // Text in 3-er Reihe
      lcd.print(F("Taste blau = BM     "));

      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 Tasten 1 bis 4 der L√§ngsschlitten (S1) sowie Vertikalschkitten (S3) bewegt 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.setCursor(0, 0);                    // Text in 1-er Reihe
      lcd.print(F("Brielmaier wurde    "));
      lcd.setCursor(0, 1);                    // Text in 2-er Reihe
      lcd.print(F("ausgewaehlt, zum    "));
      lcd.setCursor(0, 2);                    // Text in 3-er Reihe
      lcd.print(F("Bestaettigen        "));
      lcd.setCursor(0, 3);                    // Text in 3-er Reihe
      lcd.print(F("Start Knopf Druecken"));

      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(4500);
        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.setCursor(0, 0);                    // Text in 1-er Reihe
      lcd.print(F("Beginn der          "));
      lcd.setCursor(0, 1);                    // Text in 2-er Reihe
      lcd.print(F("Referenzierung      "));
      lcd.setCursor(0, 2);                    // Text in 3-er Reihe
      lcd.print(F("                    "));
      lcd.setCursor(0, 3);                    // Text in 3-er Reihe
      lcd.print(F("                    "));

      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
      S5.doSteps(700);   // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren
      Z_Start = AUS;
      Zustand = Hauptreferenz_Ende;

      break;

    /***********************************************/
    /*              Hauptreferenz_Ende             */
    /***********************************************/
    //

    case Hauptreferenz_Ende:

      if (!S4.moving() && !S5.moving()) {
        Z_Start = AUS;
        Zustand = beginn_Sensor_fahrt;
      }
      break;

    /***************************************/
    /*        beginn der Ref-fahrt         */
    /***************************************/

    case beginn_Sensor_fahrt:
      S4.rotate(1);
      S5.rotate(-1);
      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 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 = 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
      S5.doSteps(3750);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren

      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 sind gestoppt), 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 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.clear();
      lcd.setCursor(0, 0);                    // Text in 1-er Reihe
      lcd.print(F("Der Schleifvorgang  "));
      lcd.setCursor(0, 1);                    // Text in 2-er Reihe
      lcd.print(F("ist im Laufen       "));
      lcd.setCursor(0, 2);                    // Text in 3-er Reihe
      lcd.print(F("Schleifrichtung     "));
      lcd.setCursor(0, 3);                    // Text in 3-er Reihe
      lcd.print(F("nach 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 ankommt


      if ( Z_Opt_Klingensensor == 1  && Z_Start == EIN && Z_Schleifrichtung == RECHTS)  {
        S1.rotate(-1);
        S3.rotate(0);
        digitalWrite(DSM_Rechtslauf, LOW);    // Drehstrommotor zum Schleifen der Klingen wird im Rechtslauf gestartet
        digitalWrite(DSM_Linkslauf, HIGH);      // der Linkslauf des Drehstrommotor zum Schleifen der Klingen wird deaktiviert
        Zustand = LS_Endschalter_rechts;       // Endschalter rechts vom Längsschlitten wird ereicht nachdem die letzte Klinge im Rechtslauf angefahren wurde => aktiviert die Schleifumkehr
      }
      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)
      {
        digitalWrite(DSM_Rechtslauf, LOW);    // Drehstrommotor zum Schleifen der Klingen wird im Rechtslauf gestartet
        digitalWrite(DSM_Linkslauf, LOW  );      // der Linkslauf des Drehstrommotor zum Schleifen der Klingen wird deaktiviert
        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 20 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 Schwenk und Drehtisch in Position ist (S4 und S5 sind gestoppt), beginnt der Schleifvorgang
        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
        S1.rotate(0);
        S3.rotate(0);
        Schleifverweilzeit.setTime(4500);      // 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
        S1.rotate(0);
        S3.rotate(1);
        Verz_Hubausschaltung.setTime(1500);
        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() ) {
        S2.rotate(0);
      }

      if (taster.state(Endschalter_3_Hubtisch_oben) == HIGH) {
        S1.rotate(0);
        S3.rotate(0);
        Zustand = LS_faehrt_rechts_man;
        //    Zustand = LS_faehrt_rechts;             // Ein neuer Schleifvorgang beginnt indem eine neue Klinge vom Längsschlitten angefahren wird
      }
      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()) {   //wenn der Schwenk und Drehtisch in Position ist (S4 und S5 sind gestoppt), beginnt der Schleifvorgang
        Zustand = LS_faehrt_rechts;
      }
      break;


    case LCD_Schleifumkehr:
      Serial.println(F("D000 Schleifenumkehr"));
   //   lcd.clear();
      Serial.println(F("D001"));
      Zustand = LCD_Schleifumkehr_1;
      Serial.println(F("D002 fertig"));
      break;

    case LCD_Schleifumkehr_1:
      // /*
      Serial.println(F("D010 Schleifenumkehr_1"));
      lcd.setCursor(0, 0);                    // 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);                    // Text in 2-er Reihe
      Serial.println(F("D040"));
      lcd.print(F("fertig geschliffen"));
      Serial.println(F("D050"));
      lcd.setCursor(0, 2);                    // Text in 3-er Reihe
      Serial.println(F("D060"));
      lcd.print(F("Die Schleifrichtung"));
      Serial.println(F("D070"));
      lcd.setCursor(0, 3);                    // Text in 3-er Reihe
      Serial.println(F("D080"));
      lcd.print(F("wird nun umgekehrt "));
      Serial.println(F("D090"));
      //    */
      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) {
        S1.rotate(0);
        S2.rotate(0);
        S3.rotate(0);
        Zustand = Schwenkwechsel_Scleifumkehr_Brielmaier;
      }
      break;


    case Schwenkwechsel_Scleifumkehr_Brielmaier:

      S4.doSteps(-4672);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren
      S5.doSteps(-7500);    // mit do.Steps wird von der aktuellen Position die anzahl der Schritte verfahren



      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 sind gestoppt), beginnt der Schleifvorgang
        digitalWrite(DSM_Rechtslauf, HIGH);     // der Rechtslauf des Drehstrommotor zum Schleifen der Klingen wird deaktiviert
        digitalWrite(DSM_Linkslauf, LOW);     // der Linkslauf des Drehstrommotor zum Schleifen der Klingen wird aktiviert
        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 ankommt
        S1.rotate(1);
        S3.rotate(0);
        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 alles wird ausgeschalten

      if (S1.moving() && taster.state(Endschalter_1_LS_links) == HIGH)
      {
        S1.rotate(0);
        S2.rotate(0);
        S3.rotate(0);
        digitalWrite(DSM_Rechtslauf, LOW);
        digitalWrite(DSM_Linkslauf, LOW);
        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 Schleifvorgang
          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;


    /************************************************************************************/
    /*     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      */
    /***************************************************************/



    case LS_faehrt_links_zur_Klinge:

      S1.doSteps(40);                           // Es werden noch 20 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 Schwenk und Drehtisch in Position ist (S4 und S5 sind gestoppt), beginnt der Schleifvorgang
        Verz_Hubeinschaltung.setTime(1200);
        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 der Schleifzeit abgelaufen ist fährt die Topfsacheibe wieder hoch
        S2.rotate(1);// Der Schleifhub wird eingeschalten
      }

      if ( Z_Kap_Sensor_Topfzustellbegrenzer == 0 ) {         // Kap Sensor zur Deaktivierung der fahrt des Vertikalschlittens nach unten
        S1.rotate(0);
        S3.rotate(0);
        Schleifverweilzeit.setTime(3500);          // aufziehen des timmers f√ľr die Schleifzeit
        Zustand = VS_faehrt_hoch_links;
      }
      break;


    case VS_faehrt_hoch_links:                       // Vertikaler Schlitten fährt runter zur Klinge

      if ( !Schleifverweilzeit.running() ) {         // Wenn der Timer der Schleifzeit abgelaufen ist fährt der Längsschlitten andem der Schleifmotor befestigt ist wieder hoch
        S1.rotate(0);
        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) {
        S1.rotate(0);
        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);
      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;

  }
}

/***********************************************/
/*                 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 manuele_Steuerung()
{

  lcd.setCursor(0, 0);                    // Text in 1-er Reihe
  lcd.print(F("Manueller Betr      "));
  lcd.setCursor(0, 1);                    // Text in 2-er Reihe
  lcd.print(F("zum Beenden gelben  "));
  lcd.setCursor(0, 2);                    // Text in 3-er Reihe
  lcd.print(F("Knopf Druecken      "));
  lcd.setCursor(0, 3);                    // 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

I2C = Inter Intergrated Circuit.

Auf einer PCB. Nicht "2m Luftleitung durch schwer verseuchtes Gebiet".

In deinem speziellen Fall (und nur in deinem) w√ľrde ich f√ľr das "Display" einen separate Controller nehmen und mittels RS485 oder CAN mit dem Mega verbinden. Alles andere ist gewurschtel.

Hallo noiasca,

habe nun die Baud auf 115200 umgetellt nun hängt er genau bei D020 siehe screenshot.

Das I2C Kabel ist ca. 2m lang und ungeschirmt (CAT5E Netzwerkkabel).
Zum OK welcher den Frequenzumrichter ansteuert habe ich ein geschirmtes Kabel eingebaut.

Bilder vom Schaltkasten werde ich gleich machen versuchen, es ist aber sicher nicht möglich nachzuvollziehen welches Kabel z.B zu Welchen OK geht oder ähnliches. Alles ist in einem Blechschaltschrank auf sehr engen Raum verbaut.

ok, jetzt siehst vermutlich wirklich wie weit er gekommen ist, weil die serielle mit der Ausgabe fertig wird.

Ich ordne den Fehler der langen Verkabelung zu.
Dein I2C Bus verstirbt. Komm jetzt nicht auf die Gedanken das mit einem setTimeout zu bekämpfen.

Ich nehme an, wenn du deine Verkabelung änderst (also kein langer i2c bus) - hast du auch kein Problem mehr.

Zu deinem Vorschlag mit einem RS485 oder CAN muss ich mal googlen, ich verstehe derzeit nur Bahnhof.

Eine Frage am Rande:
Wenn Die Datenleitung zu lange ist, dann d√ľrfte doch das LCD in meinem Fall √ľberhaupt nie funktionieren oder ? Aber es funktioniert doch, nur halt bis zum Punkt der Schleifumkehr.
Merkw√ľrdig finde ich als Laie das schon.

Hier ein paar Bilder vom Schaltkasten bzw. der Gesamtsituation, falls diese noch Relevant sind.







es geht darum dass du diese weite mit einem robusten Bus √ľberbr√ľcken kannst.
RS485 und CAN können das schaffen.
Dass es in unseren Bastelstuben bei I2C auch mal √ľber 15cm hinweggeht und irgendwer auch mal 2m unter optimalen Bedingungen geschafft hat, kann nicht hinwegt√§uschen, dass I2C halt f√ľr Verbindungen auf einer Leiterplatte gemacht wurde. 2m Kabel k√∂nnen wie eine Antenne wirken und alles auffangen was so rumschwirrt.
Das "geht - geht nicht - geht" ... ist in so einem Szenario durchaus √ľblich.

oder bus extender zb 2x P82B715 +4 Widerstände

Vor allem lassen die Fotos vermuten, dass es eine elektrisch ziemlich verseuchte Umgebung ist.
Evtl. helfen I2C-Extender oder aktive Terminatoren (wie LTC4311).

Gruß Tommy

Danke f√ľr die R√ľckmeldung bzw deine Hilfe,

muss ich f√ľr RS485 oder CAN viel austauschen, bzw umadaptieren, oder kann ich es mir so vorstellen das halt ein kleines Elektronikbauteil zwischengeschalten wird wo halt die Kabel anzuklemmen sind ?
Ich kann mit diesen 2 Begriffen noch nichts anfangen, ich komme leider nicht aus der Elektronikbranche....

Hier mal ein Datenblatt zum LTC4311
I2C √ľber l√§ngere Distanzen (>15 cm) ist ein Gl√ľcksspiel ohne zus√§tzlichen Aufwand und besonders in Umgebungen mit hohen St√∂rpegeln.

Gruß Tommy

"Einfach" ist das alles nicht.
RS485 ist sehr weit verwandt was du vermutlich als Serielle Schnittstelle kennst.
Aber robuster.
Da gibt es Module die aus dem TTL-Seriell ein RS485 machen.
Du m√ľsstest dann einerseits am Mega den Text statt ans LCD an eine Serielle Schnittstelle schicken (z.B. Serial1) Dann eine 3-Drahtverbindung zum z.B. einem Arduino Nano geben, dann dort das Serielle lesen und ans LCD senden.

Mega -> TTL-RS485 ----> lange leitung ---> RS485-TTL - Nano/Uno -> ganzkurze Leitung ->i2c-Expander->LCD

CAN ist noch mal eine andere Baustelle. Zum Anfangen ist vermutlich RS485 einfacher.

Hallo Tommy,

Danke f√ľr deinen Vorschlag.
Habe ich das richtig verstaden, dass ich den LTC4311 direkt an die SDA bzw. SDL Pins vom Arduino anschliesse und dann das 2m Lange Kabel zum Display anklemme ?

LG
Christian

Uha, dass klingt dann f√ľr mich als Laien doch etwas kompliziert umzusetzen.
Hier wäre sicher am einfachsten mal die Vorschläge von Tommy oder fony mit einem extender zu testen.

Hast Du das mit dem Timeout (was ich ja nicht machen sollte :grimacing:) in etwa so gemeint ???

    case LCD_Schleifumkehr:
      Serial.println(F("D000 Schleifenumkehr"));
      //   lcd.clear();
      Serial.println(F("D001"));
      Zustand = LCD_Schleifumkehr_1;
      Serial.println(F("D002 fertig"));
      Display.setTime(500);
      break;

    case LCD_Schleifumkehr_1:
      // /*
      Serial.println(F("D010 Schleifenumkehr_1"));
      lcd.setCursor(0, 0);                    // 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);                    // Text in 2-er Reihe
      Serial.println(F("D040"));
      lcd.print(F("fertig geschliffen"));
      Serial.println(F("D050"));
      lcd.setCursor(0, 2);                    // Text in 3-er Reihe
      Serial.println(F("D060"));
      lcd.print(F("Die Schleifrichtung"));
      Serial.println(F("D070"));
      lcd.setCursor(0, 3);                    // Text in 3-er Reihe
      Serial.println(F("D080"));
      lcd.print(F("wird nun umgekehrt "));
      Serial.println(F("D090"));

      //    */
      if ( !Display.running() ) {
        Zustand = Schleifumkehr_Brielmaier;
        Serial.println(F("D100 fertig"));
      }
      break;

nein.
Ich meinte den Wire.setWireTimeout()

https://github.com/arduino/Arduino/issues/10803

die nächste Frage ist dann wohl wie man das setzt.
ins setup z.B.:

Wire.setWireTimeout(3000 /* us */, true /* reset_on_timeout */);

genau nachlesen was es macht!(!!!).
Vermutlich verstirbt das Display trotzdem, aber der Sketch friert vermutlich nicht mehr ein.

Na...
Ich nicht.
Das Stichwort ist Magnetfeld.
Wenn Du den Richtungswechsel durchfährst, dann kann da auf dem Bus, mithin den ungeschirmten Drähten, schon einiges passieren.

Was I2C ist, ist ja durch und auch verinnerlicht.

ICH w√ľrde ungeachtet dessen ein geschirmtes Kabel nehmen und das damit einmal versuchen. Auch wenn ich daf√ľr die H√∂lle aufsuchen muss...
Anbindung des Schirm nur auf einer Seite.
Und die Versorgungspannung extra f√ľhren.

Hallo, my_xy_projekt,

ich werde mir noch ein geschirmtes kabel kaufen und nur den SDA und SCL Pin damit anschlie√üen => hoffe dass ich dieses noch irgendwie in mein Kabelf√ľhrungsformrohr unterbringe.....

Zudem habe ich auch gerade einen LTC4311 bestellt welches das Setup ebenfalls verbessern sollte.

Was genau verstehst Du unter "Anbindung des Schirm nur auf einer Seite".
An den Schraubklemmen des Arduino werde ich bis ca. 5mm keine Folie oben lassen können, d.h in diesem Bereich ist das Kabel ungeschirmt.

Frag in irgend ner Computerbude um die Ecke, ob die Dir nicht nen √ľbrig gebliebenen Rest-Meter aus der letzten Installation vermachen.
Im √úbrigen habe ich das auch schon mal mit nem St√ľck geschirmten Telefonkabel gemacht - und ja es ging. Ist aber nicht so geblieben. War nur halt Wochenende :wink:

@christian_auer_11
Das wei√üe Kabel auf dem Foto ist f√ľhrt wahrscheinlich zum Schaltnetzteil?
wen ja macht dir das unheimliche EMV Probleme im Schaltschrank, nim ein runden Ferritkern und wickel das Kabel zweimal um den kern so nah wie möglich am Netzteil

Habe gerade ein geschirmtes cat5e Netzwerkkabel aufgetrieben, werde dort noch 2 Weibchen eines Steckbrettkabel f√ľr die I2C Pins anl√∂ten, dann kann ich das ganze morgen gleich testen.
Bin schon sehr gespannt.....

Aber noch mal kurz zu den Magnetfeldern beim Richtungswechsel.

Während dem das LCD umgeschrieben werden sollte, gibt es ja noch gar keinen Richtungswechsel.

Dieser w√ľrde erst am Ende des neubeschreibens des LCD im case: "
Schleifumkehr_Brielmaier" stattfinden, aber soweit bin ich ja gar nie gekommen.

Hoffe morgen klappt es mit dem geschirmten kabel :thinking: ......