LTC4311 + Display

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.

Ersetze:
(ab Zeile 274)

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

NEU:

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)
{
  Serial.println(F("TIK"));
  S1.rotate(0);
  delay(5000);
  Serial.println(F("TAK"));
  delay(5000);
  Z_Schleifrichtung = LINKS;
  Serial.println(F("TOK"));
  Zustand = LCD_Schleifumkehr;
}

Ersetze:
(ab Zeile 367)

    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;

neu:

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) {
  Serial.println(F("4711"));
  digitalWrite(DSM_Rechtslauf, LOW);     // DSM wird abgeschalten
  digitalWrite(DSM_Linkslauf, LOW  );    // DSM wird abgeschalten
  delay(5000);
  Serial.println(F("0815"));
  Zustand = Schwenkwechsel_Scleifumkehr_Brielmaier;
}
break;

Was passiert?

Was'n los mit Dir?
Den nicht mitbekommen?

EinSchritt vor dem LCD Umschreiben (welches den Arduino einfrieren lässt) wird der Schrittmotor S1 gestoppt. Das Stoppen erfolgt durch einen Endschalter welcher mit 24 V Spannung betrieben wird.

Dann beginnt ein ganzer Schritt nur mit dem Umschreiben des LCD.
Dieser Schritt lässt den Arduino jedoch jedes Mal einfrieren.
Hier passiert aber nichts neues. Während des Umschreibvorganges dreht der Drehstrommotor, welcher schon die ganze Zeit im Betrieb war weiter.

Wenn ich aber nur das Überschreiben des LCD´s auslasse (ist in meinem Sketch auskommentiert), friert der Arduino nicht ein.

Von welcher Irreführung sprechen wir hier bitte ???

Vielen Dank my_xy_projekt :ok_hand::smiley:

Ich werde deine Verbesserungen gleich morgen in den Sketch einfließen lassen und Testen.

LG
Christian

Und dann da weiter machen, wo Du angefangen hast!!!

Das verstehe ich jetzt nicht ganz, meinst Du mit dem LTC4311 weitermachen?

Oder wahrscheinlich eher das auslesen des SerMo.

Siehe #22. Ich bin ja nu nicht erst seit heute an Deinem Schleifteil.

Ah Alles klar, Du meinst im anderen Topic.

Diesen hier habe ich eröffnet, weil ich zu dem LTC 4311 fragen hatte.
Da erschien es mir besser hierfür einen eigenen Topic aufzumachen, da ja im anderen niemand einen Bezug zum LTC 4311 herstellen kann, da da ja eine ganz andere Fragestellung war.

Da der LTC4311 nicht des Rätsels Lösung war schließe ich diesen Topic hier als gelöst ab.

LG
Christian

Du hast also die Lösung gefunden. Das freut mich. Dann darfst Du auch an anderer Stelle gerne selbst weiter machen.
Damit Du Dich selbst beweihräuchern kannst, werde auch ich meine Zeit nicht mehr einsetzen.

Du hast es damit als erster geschafft.

https://forum.arduino.cc/u/hier eigenen Usernamen eintragen/preferences/users
- ignoriert
- hinzufügen.

Die nächsten 4 Wochen. Erstmal.
Na dann.

Das verstehe ich nun wirklich nicht.
Weil ich diesen Topic hier schliesse um im anderen (alten Topic) weiterzumachen (was Du mir #26 angeraten hast) ignorierst Du mich??

Dann überlege doch mal.
Warum hast du deinen vorherigen Thread hier nicht verlinkt. Daran wäre zu erkennen, das du dir die vorhandenen Probleme selbst einschenkst. Wie sollen andere da helfen.

Mit VDE hat der Schaltkasten sicher nichts mehr zu tun.

Auch aus dem Grunde habe ich mich hier abgemeldet.
Nicht das es dann heißt, wir würden dich bei deinen lebensmüden Aktionen noch unterstützen.

Wie kann ich den Schaltschrank dann in Ordnung bringen ??
Bitte einen klaren Hinweis geben was falsch ist !

  • Gehört nur die 230V Klemmleiste raus ?
  • Darf das 24V Netzteil auch nicht drinnen bleiben ?
  • Sollte nur der Arduino umgesiedelt wreden ?

Wenn ich keinen klaren Hinweis bekomme, wie sollte ich dann reagieren.

Also bitte einen klaren Tipp was geändert werden muss damit der Schaltschrank in Ordnung gebracht wird.

Gerne....
Da du sicher kein Elektomeister oder einer mit der entsprechenden Ausbildung bist, darfst du nicht an 230V Systemen arbeiten.

Also lass es von einem Fachmann machen.
Mehr kann und will ich nicht zu dem Thema sagen.