Schrittkette + LCD Display unterbricht abfolge in Schrittkette

ich hab dir ja schon mal geschrieben, du sollst mittels debug Ausgaben verfolgen was dein Programm macht.
So blöd das auch klingt, jede einzelne Zeile und auf der Seriellen Schnittstelle beobachten wo genau der Controller verstirbt:

   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;

Guten Morgen noiasca,

aha, so meintest Du das => Jede Zeile für sich alleine ausgeben.
Ich habe mir nur die cases ausgeben lassen, und da habe ich dann ja auch nicht wirklich mehr Informationen erhalten.

Am Nachmittag / Abend werde ich deinen Vorschlag gleich malt testen

Danke :+1:

LG
Christian

Werden denn die Texte am LCD alle ausgegeben? Da müsste man ja auch schon sehen wie weit er kommt - auch ohne die Serial.print.
Das Schreiben auf das I2C LCD ist rel. langsam. Könnte also auch ein Timing-Problem sein. Obwohl mir da im Moment noch nichts zeitkritisches auffällt.

bitte lass ihn erst mal die Serial prints einbauen, ein lcd.setCursor sieht er ja noch nicht, sondern erst den nächsten Schritt.
und es kann ja auch sein, dass der controller noch weitermacht, nur das LCD weg ist.
Daher finde ich Debug Ausgaben für eine Analyse hilfreich.
Apropos sehen:
Wir sehen ja keine Verkabelung und kein Umfeld.
Wie schauts aus mit Schaltplan und ECHTBILDER?

Ja, kann und soll er ja auch machen. Aber die Frage was auf dem LCD zu sehen ist, hätte er vielleicht auch schon vorher beantworten können.
Und ja, Infos zum tatsächlichen Aufbau wären auch noch wichtig und nützlich.

1 Like

Hallo MicroBahner,
Hallo noiasca,

ich habe nun die Debugfunktion eingebaut, und er blieb beim ersten mal genau bei "D000 Schleifumke" stehen.
Anscheinend schafft es der Arduino nicht einmal mehr "D000 Schleifenumkehr" vollständig auszuschreiben.
Ich habe auch noch einen zweiten Versuch gemacht, da ging der serielle Monitor sogar nur noch bis "D000 Sch"

Alles wird abgewürgt sogar das Display schaltet die Beleuchtung aus.
Der Drehstrommotor wird auch ausgeschaltet.

@MicroBahner :
Text kann ich dann am Display keinen mehr erkennen.

Lasse ich das LCD beschreiben ( case LCD_Schleifumkehr_1:) aber aus kann der Schleifvorgang ganz normal ausgeführt werden (die restlichen LCD-Texte bleiben im Code und funktionieren auch).

Es hängt deffinitiv mit dem Display zusammen, mir kommt fast schon vor als ob ich es nur eine gewisse anzahl oft überschreiben dürfte.

Hier ein Bild der Verkabelung allzu viel zu sehen wird leider nicht sein.
Aber die ganze Verkabelung funktioniert auch, ich habe ja schon mehrere Schleifvorgänge gemacht nur halt ohne den LCD Text im Case "LCD_Schleifumkehr_1:"

Der Arduino Mega steckt in einem Schraubklemmblock welchen ich sehr praktisch finde.

Hier der Link zum Video.

LG
Christian

Kommentier mal das löschen des LCD aus:

// lcd.clear();

Könnte sein, das er sich da verschluckt.
Wenn das geht, ersetz die Zeile duch:

      for (int i = 0; i < 3; i++)
      {
        lcd.setCursor(0, i);                    // Text in 1-er Reihe
        lcd.print(F("                    "));  // Fixtexte mit F-Makro im Flash belassen
      }

Das ist zwar langsamer, aber nen Versuch wert.

Wie lang ist denn deine I2C Verbindung vom Mega zum LCD? Und was sind da noch für Leitungen parallel. Hast Du für die I2C Leitung abgeschirmtes Kabel genommen? Könnte sein, dass sich da der I2C Bus aufhängt.
P.S. Ich habe auch nicht den Eindruck, dass Du Leistungs- und Steuerleitungen ordentlich getrennt hast.

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.