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
