Persönlich kann nicht mehr helfen, in der Stelle ab 1603 ist ja die Motorsteuerung drin, warum die bei dem Menüpunkt nicht tut verstehe auch nicht.
Schade fony Du warst meine Hoffnung 
Bin noch Anfänger 
Ich bin blutiger Anfänger ...
Ich hab jetzt mal ein paar Funktionen wie die Servos aus dem Scetch gelöscht, jetzt kann ich ihn flashen und sehe auch was im Seriellen Monitor.
Bei der Funktion manuelles Anfahren, zeigt er immer nur "Motor Stop" aber nichts mit vor oder rückwärts ...
Startpos gef.
SmallRot:0
Motor StopEndpos gef.265
1neuePosRot:1
1neuePosRot:2
Motor StopMotor StopMotor StopMotor Stop
Bei dem Motor vorwärts bzw. Motor rückwärts waren die #endif / #if falsch gesetzt.
//------------------------------------------
// Motor vorwärts
//------------------------------------------
void MotorVor(int Speed)
{
#if myDRIVE
int SpeedOutput;
SpeedOutput = 75 + Speed * 20; //erst ab ca 100 dreht der 12V Gleichstrommmotor
analogWrite(MotorEnable_PIN, SpeedOutput);
digitalWrite(Motorsteuerung_PIN1, HIGH); //Motor läuft vorwärts
digitalWrite(Motorsteuerung_PIN2, LOW);
#endif
#if myDEBUG
Serial.print(F("Motor vorwärts- mit "));
// Serial.print(SpeedOutput / 255 * 100);
// Serial.println(F("%"));
#endif
}
Ich hab das jetzt geändert und sehe im Seriellen Monitor Motor vorwärts bzw. rückwärts.
2.6
Motor vorwärts- mit Motor StopMotorRückw.Motor StopMotor vorwärts- mit Motor Stop1neuePosRot:0
1neuePosRot:1
1neuePosRot:2
Motor vorwärts- mit Motor vorwärts- mit Motor vorwärts- mit Motor vorwärts- mit Motor vorwärts- mit Motor StopMotorRückw.MotorRückw.MotorRückw.Motor Stop
angesteuert wird der Motor aber nicht.
Stimmt. Deswegen habe ich jetzt alle F-macros herausgenommen.
Das liegt aber daran dass du den Compiler-Schalter für ESP32 nicht gesetzt hast.
Der Programmierer hat doch ganz viele
#ifdef
für genau diese Umschaltung zwischen Nano und ESp32 in den Code eingebaut
ACHTUNG !
Im Original-Code sind noch zwei analogWrite() die der ESP32 nicht mag.
Habe ich erst mal auskommentiert.
Wenn der Compiler-Schalter auf ESP32 steht
und die beiden analogWrite() auskommentiert sind = werden NICHT mitcompiliert = sind deaktiviert
#define mySYSTEM 0 //< 0= ESP32 // 1= Arduino Every / 0 = ESP32
dann compiliert es auch.
Das anzupassen ist jetzt vergleichsweise einfach
// Version compiler-Schalter eingestellt für ESP32
/* Universalcode für den Ettimandl (ESP32) und den EtVonSchleck (Arduino Nano)
Copyright (C) 2021 Jeremias Bruker
2021-01-03 Jeremias Bruker| Den Code kann jeder frei verwenden, ändern und hochladen wo er will,
solange er nicht seinen eigenen Namen drüber setzt, oder diesen kommerziell verwertet, beispielsweise
indem Etikettiermaschinen mit diesem Code versehen und verkauft werden.
2021-01-03 Jeremias Bruker | initial version,
2021-01-09 Martin Zahn | Unterstützung ESP32+Schrittmotor hinzugefügt
2021-01-16 Jeremias Bruker | Wahl zwischen Schrittmotor und Gleichstrommotor per myDRIVE
2021-01-21 Johannes Kuder | Ultraschallsensor anstatt Näherungssensor per mySensor
2021-01-28 Jeremias Bruker | Etikettenlänge kann während des Labelvorgangs mit dem SmallRotary geändert werden - wird mit E+ oder E- angezeigt
| Stepperlaufrichtung kann per define angepasst werden
2021-01-29 Johannes Kuder | OTA-Funktionalität für ESP32
2021-01-29 Jeremias Bruker | Grafik auf U8g2 umgestellt
2021-02-03 Jeremias Bruker | Fußschalter implementiert
2021-02-20 Jeremias Bruker | Große Werte können im Menü parallel mit Small und BigRotary verändert werden werden
2021-02-23 Jeremias Bruker | Die Spannung bzw. Drehzahl des Lüfters kann nun per Software eingestellt werden
2021-02-25 Jeremias Bruker | Gemeinsame EncoderLib (für Every und ESP32) & Abbruch über Rotary-Button während der Trockenzeit*/
//----------------------------------------------------------------
// Allgemeine Konfiguration DEBUG/GRAFIK/System Information
//----------------------------------------------------------------
#define mySYSTEM 0 //< 0= ESP32 // 1= Arduino Every / 0 = ESP32
#define myDEBUG 1 // 0 = Debug via Serial Monitor
#define myDRIVE 0 // 1 = Gleichstrommotor mit H-Brücke 0 = Schrittmotor
#define mySENSOR 0 // 1 = Ultraschallsensor 0 = kap. Näherungssensor
//---------------------------
#define useOTA 0 // 1 = OTA Funktionalität nutzen
#if useOTA
const char* ssid = "";
const char* password = "";
#endif
//---------------------------
#define StepperLaufrichtung 0 // 0 für senkrechten Aufbau 1 für waagerechten Aufbau
//----------------------------------------------------------------
const char Version[] = "2.6"; //02.03.2021
#if mySYSTEM
//----------------------------------------------------------------
// Pinbelegung Arduino Nano
//----------------------------------------------------------------
// Rotary Encoder klein für Menü-Steuerung
#define SmallRotary_PIN_SW A0
#define TRIG_PIN A1 // falls Ultraschallsensor im Einsatz
#define Buzzer_PIN A2
// I2C-Display A4 // SDA
// I2C-Display A5 // SCL
#define FussSchalter A6
#define NaeherungsSensor_PIN A7 // Ausgang Näherungsschalter oder Ausgang Ultraschallsensor
// Serial 0
// Serial 1
#define RotaryBig_PIN_A 2
#define RotaryBig_PIN_B 3
#define SmallRotary_PIN_A 4
#define SmallRotary_PIN_B 5
#define MiniLuefterEnable_PIN 6 //Speed PWM für Lüfter am Gleichstrommotorausgang B
#define MiniLuefter_PIN1 7 //PinA Motorsteuerung für Lüfter
#define Motorsteuerung_PIN1 8 // Schrittmotor--> Motorsteuerung_PIN1 = Step oder Gleichstrommotor--> Pin A
#define Motorsteuerung_PIN2 9 // Schrittmotor--> Motorsteuerung_PIN2 = Dir oder Gleichstrommotor--> Pin B
#define MotorEnable_PIN 10 // Schrittmotor--> Enable-Pin oder Gleichstrommotor--> Speed PWM MotorA
#define SERVO1_PIN 12 //Stempel-Servo
#define SERVO2_PIN 13 //Stempel-Position
//----------------------------------------------------------------
#else
//----------------------------------------------------------------
// Pinbelegung ESP32
//----------------------------------------------------------------
#define MotorEnable_PIN 14 // Schrittmotor--> Enable-Pin oder Gleichstrommotor--> Speed PWM
#define Motorsteuerung_PIN1 33 // Schrittmotor--> Step oder Gleichstrommotor--> Pin A
#define Motorsteuerung_PIN2 32 // Schrittmotor--> Dir oder Gleichstrommotor--> Pin B
// Rotary Encoder (Inkrementaler Drehgeber für Etikettenposition)
// Grün = A-Phase, Weiß = B-Phase, Rot = Vcc-Leistung +, Schwarz = V0
#define RotaryBig_PIN_A 16 // A-Phase
#define RotaryBig_PIN_B 17 // B-Phase
// Rotary Encoder klein für Menü-Steuerung
#define SmallRotary_PIN_SW 13
#define SmallRotary_PIN_A 35 // DT
#define SmallRotary_PIN_B 34 // CLK
// Servo
#define SERVO1_PIN 19 // Servo für Stempel
#define SERVO2_PIN 26 // Stempelposition
// I2C-Display 21: SDA
// I2C-Display 22: SCL
// SPI-Display 18: CLK
// SPI-Display 19: MISO
// SPI-Display 23: MOSI
// SPI-Display 5: CS
#define Buzzer_PIN 25
#define MiniLuefter_PIN1 2
#define MiniLuefterEnable_PIN 18 //Speed PWM für Lüfter am Gleichstrommotorausgang B
// Start-Sensor
#define NaeherungsSensor_PIN 23 // Im Fall Ultraschallsensor: ECHO Pin
#define TRIG_PIN 4 // falls Ultraschallsensor im Einsatz
#define FussSchalter 5
// OTA
#if useOTA
#include <WiFi.h>
#endif
#if useOTA
#include <ESPmDNS.h>
#endif
#if useOTA
#include <WiFiUdp.h>
#endif
#if useOTA
#include <ArduinoOTA.h>
#endif
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
// gemeinsame Libs (Nano und ESP)
//----------------------------------------------------------------
#include <Arduino.h>
#include <Encoder.h> // https://github.com/PaulStoffregen/Encoder
#if !myDRIVE
#include <AccelStepper.h> // für Schrittmotor. https://www.airspayce.com/mikem/arduino/AccelStepper/classAccelStepper.html
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
// diverse ARduino Libs
//----------------------------------------------------------------
#if mySYSTEM
#include <EEPROM.h> // aus dem Bibliotheksverwalter
#endif
#if mySYSTEM
#include <Servo.h> // aus dem Bibliotheksverwalter
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
// diverse ESP32 Libs
//----------------------------------------------------------------
#if !mySYSTEM
#include <Preferences.h> // für EEPROM
#endif
#if !mySYSTEM
#include <ESP32Servo.h>
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
// DISPLAY
//----------------------------------------------------------------
#include <Wire.h> // aus dem Bibliotheksverwalter
#include <U8g2lib.h> // aus dem Arduino-Bibliotheksverwalter
#if mySYSTEM
//OLED 1.3 128*64 Breite Version -------------------------------------------------------------------
U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); //128*64 BreiteVersion
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
#else
//2.42 Oled 128*64 Große Version -------------------------------------------------------------------
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
#endif
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration SmallRotary
//----------------------------------------------------------------
Encoder SmallRotary(SmallRotary_PIN_A, SmallRotary_PIN_B);
int LeseSmallRotaryWert()
{
int Wert;
Wert = SmallRotary.read() / 4;
return Wert;
}
void SetzeSmallRotaryWert(int Wert)
{
SmallRotary.write(Wert * 4);
}
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Bigrotary
//----------------------------------------------------------------
Encoder BigRotary(RotaryBig_PIN_A, RotaryBig_PIN_B);
int LeseBigRotaryWert()
{
int Wert;
Wert = BigRotary.read();
return Wert;
}
void SetzeBigRotaryWert(int Wert)
{
BigRotary.write(Wert);
}
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Schrittmotor
//----------------------------------------------------------------
#if !myDRIVE
AccelStepper stepper(1, Motorsteuerung_PIN1, Motorsteuerung_PIN2); // Motortyp, Motorsteuerung_PIN1, Motorsteuerung_PIN2
#endif
//----------------------------------------------------------------
// Konfiguration EEPROM ESP32
//----------------------------------------------------------------
#if !mySYSTEM
Preferences preferences;
#endif
//----------------------------------------------------------------
// Konfiguration Servo
//----------------------------------------------------------------
Servo Servo1;
Servo Servo2;
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Datentransfer via Serial / FTDI / USB
//----------------------------------------------------------------
#define Serial_Baudrate 115200
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Buzzer
//----------------------------------------------------------------
#define BUZZER_SHORT 1
#define BUZZER_LONG 2
#define BUZZER_SUCCESS 3
#define BUZZER_ERROR 4
//----------------------------------------------------------------
//----------------------------------------------------------------
// Variablen
//----------------------------------------------------------------
int hand_steps = 400; // variable Schrittweite, original 40
unsigned int n_pings = 10; // Anzahl Einzelmessungen Ultraschallsensor zur Mittelwertbildung
float Schwelle = 2; // Grenzabstand in cm an dem Glas erkannt wird
volatile int PositionBigRotary;
int altePositionBigRotary = 0; // Def der "alten" RotaryPosition
volatile int PositionSmallRotary;
int altePositionSmallRotary = 0; // Def der "alten" RotaryPosition
int neuePositionSmallRotary = 0; // Def der "alten" RotaryPosition
bool altePositionNaeherung = HIGH;//kein Glas aufgelegt
long Fortschritt;
long AlterFortschritt = 0;
bool EinWertNeu = LOW; //Anzeiger, ob EEPROM beschrieben werden soll
bool HandModus = LOW;
char Ausgabe[30];
//Menüwerte
unsigned int AktuellesEtikett = 0;
unsigned int Etikettenlaenge[] = {500 , 1000 , 2000 };
unsigned int ZeitBisDatumDruck[] = {250 , 500 , 1000 };
unsigned int Counter[] = {0 , 0 , 0}; // Anzahl der
bool MitBuzzer[] = {LOW, LOW, LOW}; //Soll der Buzzer aktiv sein
bool MitFuss[] = {LOW, LOW, LOW}; //Soll der Fußschalter aktiv sein
bool MitDruck[] = {LOW, LOW, LOW}; //Soll überhaupt auf das Etikett gedruckt werden?
unsigned int Servo1PositionOben[] = {90, 90, 90};
unsigned int Servo1PositionUnten[] = {90, 90, 90};
unsigned int Servo2Position[] = {90, 90, 90};
unsigned int DruckTrockenZeit[] = {1, 1, 1}; //Sekunden nach dem Druck warten, damit die Tinte trocknen kann
unsigned int MitLuft[] = {0, 0, 0}; // Spannung des Lüfters in %(Versorgungsspannung Motor) 0 = inaktiv 10 = 100 %
// Schrittmotoreinstellungen
unsigned int MaxSpeed[] = {10, 10, 10}; // Schrittmotor Maximalgeschwindigkeit, wird im Code mit 100 multipliziert
unsigned int Acceleration[] = {5, 5, 5}; // Schrittmotor Beschleunigung (höher = schneller) wird im Code mit 100 multipliziert
//int Speed = 1000; // Schrittmotor Geschwindigkeit für Handbetrieb
int LastSteps = 20000; // Gefahrene Schritte des Schrittmotors beim letzten Etikettiervorgang
int LastStepsPrint = 18000; // Gefahrene Schritte des Schrittmotors beim letzten Etikettiervorgang
#if myDRIVE
int DriveJump = 2; //Menüpunkte vom Schrittmotor ausblenden
#else
int DriveJump = 0;
#endif
//################################################# SETUP #############################################
void setup()
{
#if myDEBUG
Serial.begin(Serial_Baudrate);
Serial.print(F("Starte Setup -"));
Serial.println(Version);
#endif
delay(100);
ReadMem(); //Werte aus EE_Prom einlesen
Wire.begin();
//Wire.setClock(400000L);
u8g2.begin();
u8g2.enableUTF8Print();
print_logo();
#if !mySYSTEM
// OTA -------------------------------------------------
#if useOTA
#if myDEBUG
Serial.println(F("Starte OTA") );
#endif
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println( F("Connection Failed! Rebooting...") );
delay(5000);
ESP.restart();
}
WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE, INADDR_NONE); // required to set hostname properly
#if mySYSTEM
WiFi.setHostname("EtVomSchleck");
#else
WiFi.setHostname("EttiMandl");
#endif
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";
#if myDEBUG
Serial.println( F("Start updating " + type) );
#endif
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB12_tf);
u8g2.setCursor(1, 15);
u8g2.print("Receiving");
u8g2.setCursor(1, 35);
u8g2.print("OTA Update");
u8g2.sendBuffer();
})
.onEnd([]() {
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB12_tf);
u8g2.setCursor(1, 15);
u8g2.print("Receiving");
u8g2.setCursor(1, 35);
u8g2.print("OTA Update");
u8g2.setCursor(1, 55);
u8g2.print("Done !");
u8g2.sendBuffer();
})
.onProgress([](unsigned int progress, unsigned int total) {
#if myDEBUG
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
#endif
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB12_tf);
u8g2.setCursor(1, 15);
u8g2.print("Receiving");
u8g2.setCursor(1, 35);
u8g2.print("OTA Update");
u8g2.setCursor(1, 55);
u8g2.printf("Progress: %u%%\r", (progress / (total / 100)));
u8g2.sendBuffer();
})
.onError([](ota_error_t error) {
#if myDEBUG
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR)
Serial.println( F("Auth Failed") );
else if (error == OTA_BEGIN_ERROR)
Serial.println( F("Begin Failed"));
else if (error == OTA_CONNECT_ERROR)
Serial.println( F("Connect Failed") );
else if (error == OTA_RECEIVE_ERROR)
Serial.println( F("Receive Failed") );
else if (error == OTA_END_ERROR)
Serial.println( F("End Failed") );
#endif
});
ArduinoOTA.begin();
#if myDEBUG
Serial.println( F("Ready") );
Serial.print( F("IP address: ") );
Serial.println(WiFi.localIP());
#endif
#endif
// Ende OTA
#endif
//----------------------------------------------------------------
//Setup Fußschalter
//----------------------------------------------------------------
pinMode(FussSchalter, INPUT_PULLUP);
//----------------------------------------------------------------
#if myDRIVE
//----------------------------------------------------------------
//Setup Motorsteuerung
//----------------------------------------------------------------
digitalWrite(Motorsteuerung_PIN1, LOW);
digitalWrite(Motorsteuerung_PIN2, LOW);
pinMode(Motorsteuerung_PIN1, OUTPUT);
pinMode(Motorsteuerung_PIN2, OUTPUT);
pinMode(MotorEnable_PIN, OUTPUT);
digitalWrite(MotorEnable_PIN, HIGH); // Kann erstmal aktiv sein
//----------------------------------------------------------------
#else
//----------------------------------------------------------------
//Setup Schrittmotorsteuerung
//----------------------------------------------------------------
stepper.setEnablePin(MotorEnable_PIN);
stepper.setPinsInverted(StepperLaufrichtung, false, true); // directioninvert, stepinvert, enableinvert
stepper.setMaxSpeed(MaxSpeed[AktuellesEtikett] * 100); // Maximale Geschwindigkeit
//stepper.setAcceleration(Acceleration[AktuellesEtikett]*100); // Beschleunigung
//stepper.setCurrentPosition(0);
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
// Setup MiniLuefter
//----------------------------------------------------------------
pinMode(MiniLuefter_PIN1, OUTPUT);
pinMode(MiniLuefterEnable_PIN, OUTPUT);
digitalWrite(MiniLuefter_PIN1, LOW);
#if mySYSTEM
analogWrite(MiniLuefterEnable_PIN, MitLuft[AktuellesEtikett] * 25);
#else
ledcSetup(0, 5000, 8);
ledcAttachPin(MiniLuefterEnable_PIN, 0);
ledcWrite(0, 125);
#endif
//----------------------------------------------------------------
//----------------------------------------------------------------
//Setup MiniRotarySwitch
//----------------------------------------------------------------
pinMode(SmallRotary_PIN_SW, INPUT);
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Servo
//----------------------------------------------------------------
Servo1.attach(SERVO1_PIN);
Servo2.attach(SERVO2_PIN);
Servo1.write(Servo1PositionOben[AktuellesEtikett]);
Servo2.write(Servo2Position[AktuellesEtikett]);
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Buzzer
//----------------------------------------------------------------
pinMode(Buzzer_PIN, OUTPUT);
if (MitBuzzer[0] || MitBuzzer[1] || MitBuzzer[2])
{
buzzer(BUZZER_LONG);
}
//----------------------------------------------------------------
//----------------------------------------------------------------
// Konfiguration Ultraschallsensor
//----------------------------------------------------------------
pinMode(TRIG_PIN, OUTPUT);
} //-----------SETUP ENDE----------------------------------------------------------------
void loop()
{
#if !mySYSTEM
#if useOTA
ArduinoOTA.handle();
#endif
#endif
Einstellungsmenue(); //Mit RotarySwitch ins Menü rein
Handsteuerung(); // Mit RotaryDrehen ---> Motor Vor und Motor zurück
//------------------------------------------------------------
// BEREIT-MODUS Abfrage Näherungsschalter und eventuell Etikettieren!
//------------------------------------------------------------
#if mySENSOR // Ultraschallsensor
bool neuePositionNaeherung = !Ultraschallsensor(Schwelle);
#else // Abstandssensor
bool neuePositionNaeherung = digitalRead(NaeherungsSensor_PIN);
#endif
if (MitFuss[AktuellesEtikett])
{
if (!digitalRead(FussSchalter)) // Fußschalter wurde eventuell gedrückt
{
buzzer(BUZZER_LONG);
if (!digitalRead(FussSchalter)) // Fußschalter wurde gedrückt !
{
#if myDEBUG
Serial.println(F("FußSchalter wurde gedrückt"));
#endif
Etikettieren();
for (int i = 0; i <= 3; i++)
{
buzzer(BUZZER_LONG);
delay(200);
}
}
}
}
else if (neuePositionNaeherung != altePositionNaeherung) // Sollte die neue Position ungleich der alten sein...
{
altePositionNaeherung = neuePositionNaeherung;
if (neuePositionNaeherung == LOW)
{
buzzer(BUZZER_LONG);
#if myDEBUG
Serial.println( F("Glas wurde erkannt!") );
#endif
if (neuePositionNaeherung == LOW) Etikettieren(); // Falls Glas immer noch liegt
for (int i = 0; i <= 2; i++)
{
buzzer(BUZZER_SHORT);
delay(200);
}
}
}
}//ENDE LOOP-------------------------------------------------------
//----------------------------------------------------------------
// Etikettiervorgang
//----------------------------------------------------------------
void Etikettieren()
{
SetzeBigRotaryWert(0); //RESET
PositionBigRotary = 0;
bool Gedruckt = LOW;
int LiveLaengenWert = 0;
DisplayEtikettieren(0); //Start mit 0 Prozent
#if !myDRIVE // Für Schrittmotor
stepper.enableOutputs();
stepper.setCurrentPosition(0);
stepper.setAcceleration(Acceleration[AktuellesEtikett] * 100); // ggf brauch man das hier nicht nochmal.
stepper.setMaxSpeed(MaxSpeed[AktuellesEtikett] * 100); // Maximale Geschwindigkeit
stepper.moveTo(LastSteps * 1.02); //
if (MitDruck[AktuellesEtikett]) stepper.moveTo(LastStepsPrint * 1.02);
#if myDEBUG
Serial.println( F("Vorbereitungen") );
Serial.print( F("Acc: ") );
Serial.println(Acceleration[AktuellesEtikett]);
Serial.print( F("Speed: ") );
Serial.println(MaxSpeed[AktuellesEtikett] * 100
);
Serial.print( F("LastStepsPrint: ") );
Serial.println(LastStepsPrint);
Serial.print( F("LastSteps: ") );
Serial.println(LastSteps);
#endif
#endif
bool Notstop = LOW;
MotorVor(11); //Starten
altePositionSmallRotary = 0;
SetzeSmallRotaryWert(0);
bool LiveRotAenderung = false;
bool RotAenderung = false;
while (abs(PositionBigRotary) <= Etikettenlaenge[AktuellesEtikett]) //Etikettierung starten
{
bool FortschrittAenderung = false;
#if !myDRIVE
stepper.run();
if (stepper.speed() <= (MaxSpeed[AktuellesEtikett] * 100) / 4 && stepper.distanceToGo() < 20)
stepper.setSpeed(MaxSpeed[AktuellesEtikett] * 100 / 4);
stepper.runSpeed();
#endif
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != altePositionSmallRotary)
{
Etikettenlaenge[AktuellesEtikett] += neuePositionSmallRotary;
LiveLaengenWert += neuePositionSmallRotary;
SetzeSmallRotaryWert(0);
LiveRotAenderung = true;
RotAenderung = true;
}
Fortschritt = abs((((long)(PositionBigRotary) * 100) / (long)(Etikettenlaenge[AktuellesEtikett])));
#if mySYSTEM
if (Fortschritt != AlterFortschritt || LiveRotAenderung == true) //Zeigt jeden Prozentfortschritt an
#else //Der Schrittmotor wird gestört bei Grafikausgabe
if (abs(Fortschritt - AlterFortschritt) >= 10 || LiveRotAenderung == true) //Zeigt nur jeden zehnten Prozentfortschritt an
#endif
{
u8g2.setDrawColor(0); //Zum Löschen der alten Zeichen
u8g2.drawBox(0, 35, 128, 15); //Zum Löschen der alten Zeichen
u8g2.setDrawColor(1); //Zum Löschen der alten Zeichen
if (RotAenderung)
{
u8g2.setCursor(1, 50);
sprintf(Ausgabe, "E%d", LiveLaengenWert);
u8g2.print(Ausgabe);
}
u8g2.setCursor(43, 50);
sprintf(Ausgabe, "-->%3d\n%%", Fortschritt);
u8g2.print(Ausgabe);
u8g2.sendBuffer();
LiveRotAenderung = false;
AlterFortschritt = Fortschritt;
}
if ((digitalRead(SmallRotary_PIN_SW) == LOW)) //RotarySwitch während Etikettiervorgang als NOTSTOP
{
MotorStop();
#if myDEBUG
Serial.println(F("Notstop gedrückt"));
#endif
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB14_tf);
u8g2.setCursor(10, 20);
u8g2.print(F("ROTA-STOP"));
u8g2.setCursor(0, 50);
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.print(F("Glas entnehmen"));
u8g2.sendBuffer();
Notstop = HIGH;
buzzer(BUZZER_ERROR);
Entprellen();
delay(1000);
break;
} //NOTFALL AUS
// eventuell Datum Drucken?
if (MitDruck[AktuellesEtikett])
{
if (abs(PositionBigRotary) > ZeitBisDatumDruck[AktuellesEtikett] && Gedruckt == LOW)
{
if (MitLuft[AktuellesEtikett] > 0)
{
#if !mySYSTEM
ledcWrite(0, MitLuft[AktuellesEtikett] * 25);
#endif
#if mySYSTEM
analogWrite(MiniLuefterEnable_PIN, MitLuft[AktuellesEtikett] * 25);
#endif
digitalWrite(MiniLuefter_PIN1, HIGH); //Lüfter starten
}
#if myDEBUG
Serial.print(F("Lüfter AN:"));
#endif
#if !myDRIVE
LastStepsPrint = stepper.currentPosition();
#endif
MotorStop(); //warten bis gedruckt
Drucken();
Gedruckt = HIGH;
#if !myDRIVE
stepper.moveTo((LastSteps) * 1.02);
#if myDEBUG
Serial.println( F("Vorbereitungen") );
Serial.print( F("Acc: ") );
Serial.println(Acceleration[AktuellesEtikett]);
Serial.print( F("Speed: ") );
Serial.println(MaxSpeed[AktuellesEtikett] * 100);
Serial.print( F("LastStepsPrint: ") );
Serial.println(LastStepsPrint);
Serial.print( F("LastSteps: ") );
Serial.println(LastSteps);
#endif
#endif
DisplayEtikettieren(Fortschritt);
MotorVor(11);
}
} // mit Druck ende
altePositionBigRotary = PositionBigRotary;
PositionBigRotary = LeseBigRotaryWert();
} // while ende
#if !myDRIVE
LastSteps = stepper.currentPosition();
#if myDEBUG
Serial.print(F("Stepper Anzahl gefahrener Schritte:"));
Serial.println(LastSteps);
#endif
#endif
MotorStop(); //Etikettierung beendet
#if !myDRIVE
stepper.disableOutputs();
#endif
//Falls Lüfter lief ---> abschalten
digitalWrite(MiniLuefter_PIN1, LOW);
#if myDEBUG
Serial.print(F("Lüfter AUS:"));
#endif
if (HandModus == LOW) //Im Handbetrieb diesen Punkt überspringen
{
if (Notstop == LOW) //Der Vorgagng lief sauber durch
{
u8g2.setCursor(43, 50);
sprintf(Ausgabe, "-->%3d\n%%", 100);
u8g2.print(Ausgabe);
u8g2.sendBuffer();
delay (1000);
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB14_tf);
u8g2.setCursor(25, 20);
u8g2.print(F("FERTIG"));
u8g2.setCursor(0, 50);
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.print(F("Glas entnehmen"));
u8g2.sendBuffer();
buzzer(BUZZER_SUCCESS);
Counter[AktuellesEtikett]++;
}
#if mySENSOR // Ultraschallsensor
while (Ultraschallsensor(Schwelle) == HIGH); //GLAS liegt noch drauf
#else
while (digitalRead(NaeherungsSensor_PIN) == LOW) //GLAS liegt noch drauf
#endif
{
delay (100);
}
delay (1000);
if (LiveLaengenWert != 0) WriteMem(); //Etikettenlänge wurde live angepasst
DisplayNeutral();
}
}
//ENDE ETIKETTIERVORGANG------------------------------------------
void DisplayEtikettieren(int Fortschrittswert)
{
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(0, 20);
#if mySYSTEM
u8g2.print(F("EtVomSchleckn"));
#else
u8g2.print(F("EttiMandln"));
#endif
u8g2.setCursor(43, 50);
if (Fortschrittswert > 100) sprintf(Ausgabe, "-->%3d\n%%", "");
else sprintf(Ausgabe, "-->%3d\n%%", Fortschrittswert);
u8g2.print(Ausgabe);
u8g2.sendBuffer();
}
//----------------------------------------------------------------
// DIREKTE MOTORANSTEUERUNG: VORWÄRTS UND RÜCKWÄRTS ZUM JUSTIEREN
//----------------------------------------------------------------
void Handsteuerung()
{
String SpeedAnzeige;
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != altePositionSmallRotary)
{
u8g2.setDrawColor(0);
u8g2.drawBox(0, 37, 128, 16); //löschen der Zeile
u8g2.setDrawColor(1);
u8g2.setCursor(1, 50);
if (neuePositionSmallRotary > 0)
{
if (neuePositionSmallRotary > 8)
{
SetzeSmallRotaryWert(9);
neuePositionSmallRotary = 9;
}
SpeedAnzeige = String(neuePositionSmallRotary) + " ";
MotorVor(neuePositionSmallRotary);
for (int i = 1; i <= neuePositionSmallRotary; i++)
{
SpeedAnzeige = SpeedAnzeige + ">";
}
}
else if (neuePositionSmallRotary < 0)
{
if (neuePositionSmallRotary < -8)
{
SetzeSmallRotaryWert(-9);
neuePositionSmallRotary = -9;
}
SpeedAnzeige = String(-neuePositionSmallRotary) + " ";
MotorRueck(-neuePositionSmallRotary);
for (int i = -1; i >= neuePositionSmallRotary; i--)
{
SpeedAnzeige = SpeedAnzeige + "<";
}
}
else
{
if (MitFuss[AktuellesEtikett]) SpeedAnzeige = "< FussTaster >";
else SpeedAnzeige = "Glas auflegen";
MotorStop();
}
u8g2.print(SpeedAnzeige);
u8g2.sendBuffer();
altePositionSmallRotary = neuePositionSmallRotary;
PositionSmallRotary = neuePositionSmallRotary;
}
#if !myDRIVE
if (PositionSmallRotary != 0)
{
stepper.setEnablePin(MotorEnable_PIN);
int SpeedOutput;
if (PositionSmallRotary > 0) SpeedOutput = MaxSpeed[AktuellesEtikett] * 100 * PositionSmallRotary / 9;
else SpeedOutput = -(MaxSpeed[AktuellesEtikett] * 100 * abs(PositionSmallRotary) / 9);
stepper.setSpeed(SpeedOutput);
stepper.runSpeed();
}
else stepper.disableOutputs();
#endif
}
//------------------------------------------
// Haltbarkeitsdatum Drucken
//------------------------------------------
void Drucken()
{
#if myDEBUG
Serial.println(F("Stempeln"));
#endif
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB12_tf);
u8g2.setCursor(20, 20);
u8g2.print("Stempeln");
u8g2.setCursor(0, 50);
u8g2.print("Warte...");
u8g2.sendBuffer();
Servo1.write(Servo1PositionUnten[AktuellesEtikett]);
delay(500);
Servo1.write(Servo1PositionOben[AktuellesEtikett]);
// Warten zum Trocknen
if (DruckTrockenZeit > 0)
{
unsigned long AktuelleZeit = millis();
unsigned int LetzteAnzeige;
while (millis() - AktuelleZeit < (DruckTrockenZeit[AktuellesEtikett] * 1000))
{
unsigned int LaufZeit = DruckTrockenZeit[AktuellesEtikett] - int((millis() - AktuelleZeit) / 1000);
if (LaufZeit != LetzteAnzeige)
{
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB12_tf);
u8g2.setCursor(20, 20);
u8g2.print("Stempeln");
u8g2.setCursor(0, 50);
u8g2.print("Warte...");
u8g2.print(LaufZeit);
u8g2.print("sec");
u8g2.sendBuffer();
LetzteAnzeige = LaufZeit;
}
if ((digitalRead(SmallRotary_PIN_SW) == LOW)) break; //Mit Rotary-Knopfdruck raus aus der Wartezeit
}
Entprellen();
}
}
//----------------------------------------------------------------
//------------------------------------------
// Motor Stop
//------------------------------------------
void MotorStop()
{
#if myDRIVE
digitalWrite(Motorsteuerung_PIN1, LOW);
digitalWrite(Motorsteuerung_PIN2, LOW);
#endif
#if myDEBUG
Serial.print(F("Motor Stop"));
#endif
}
//------------------------------------------
// Motor vorwärts
//------------------------------------------
void MotorVor(int Speed)
{
#if myDRIVE
int SpeedOutput;
SpeedOutput = 75 + Speed * 20; //erst ab ca 100 dreht der 12V Gleichstrommmotor
analogWrite(MotorEnable_PIN, SpeedOutput);
digitalWrite(Motorsteuerung_PIN1, HIGH); //Motor läuft vorwärts
digitalWrite(Motorsteuerung_PIN2, LOW);
#if myDEBUG
Serial.print(F("Motor vorwärts- mit "));
Serial.print(SpeedOutput / 255 * 100);
Serial.println(F("%"));
#endif
#endif
}
//------------------------------------------
// Motor rückwärts
//------------------------------------------
void MotorRueck(int Speed)
{
#if myDRIVE
int SpeedOutput;
SpeedOutput = 75 + Speed * 20; //erst ab ca. 100 dreht der 12V Gleichstrommmotor
analogWrite(MotorEnable_PIN, SpeedOutput);
digitalWrite(Motorsteuerung_PIN1, LOW);
digitalWrite(Motorsteuerung_PIN2, HIGH);
#if myDEBUG
Serial.print(F("Motor rückwärts: "));
Serial.println(SpeedOutput);
#endif
#endif
}
void DisplayNeutral()
{
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB14_tf);
u8g2.setCursor(0, 20);
u8g2.print(F("Etiketten"));
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.print(" (");
u8g2.print(AktuellesEtikett + 1);
u8g2.print(")");
u8g2.setCursor(0, 50);
u8g2.setFont(u8g2_font_courB12_tf);
if (MitFuss[AktuellesEtikett]) u8g2.print(F("<FussTaster>"));
else u8g2.print(F("Glas auflegen"));
u8g2.sendBuffer();
}
//-----------------------------------------------------------------------------------------
// // Menü Einstellungen
//-----------------------------------------------------------------------------------------
void Einstellungsmenue()
{
if (digitalRead(SmallRotary_PIN_SW) == LOW) //Rein ins Menü durch Tastendruck
{
//Hauptmenü
int SpeicherAktuellesEtikett = AktuellesEtikett;
Entprellen();
altePositionSmallRotary = 99;
SetzeSmallRotaryWert(AktuellesEtikett); //RESET
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != altePositionSmallRotary)
{
if (neuePositionSmallRotary > 2)
{
neuePositionSmallRotary = 2;
SetzeSmallRotaryWert(2);
}
if (neuePositionSmallRotary < 0)
{
neuePositionSmallRotary = 0;
SetzeSmallRotaryWert(0);
}
altePositionSmallRotary = neuePositionSmallRotary;
AktuellesEtikett = neuePositionSmallRotary;
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.setCursor(0, 10);
u8g2.print(F("Einstellungen für"));
u8g2.drawLine(0, 16, 128, 16); //horiz. Linie
u8g2.setFontMode(0);
for (int d = 1; d < 4; d++)
{
u8g2.setFont(u8g2_font_courB08_tf);
sprintf(Ausgabe, "%d)", d);
u8g2.setCursor(0, d * 15 + 15);
if (d == AktuellesEtikett + 1)
{
u8g2.drawBox(0, d * 15 + 6, 10, 11);
u8g2.setDrawColor(0);
}
u8g2.print(Ausgabe);
u8g2.setDrawColor(1);
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(12, d * 15 + 15);
u8g2.print(F("Etiketten"));
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.setCursor(98, d * 15 + 15);
sprintf(Ausgabe, "c:%d", Counter[d - 1]);
u8g2.print(Ausgabe);
}
u8g2.sendBuffer();
SetzeSmallRotaryWert(AktuellesEtikett); //RESET
}
} //while Taster nicht gedrückt
//AktuellesEtikett = altePositionSmallRotary;
// Ende Hauptmenü
buzzer(BUZZER_SHORT);
if (MitDruck[AktuellesEtikett]) //Servos einstellen für ausgewähltes Etikett
{
Servo1.write(Servo1PositionOben[AktuellesEtikett]);
Servo2.write(Servo2Position[AktuellesEtikett]);
}
Entprellen();
// Untermenü
char* MenuePunkte[17] = { "Menü verlassen", // 0
"Etikettenlänge", // 1 + Wert
"Etikettenlänge", // 2 Untermenü
" Handbetrieb", // 3 HANDMODUS falls der Näherungssensor nicht funktioniert
" Buzzer", // 4 Sound aktiv oder inaktiv
" Counterwert", // 5
" Schrittmotor", // 6 Speed
" Schrittmotor", // 7 Acceleration
" Fußschalter", //8 Aktiv Inaktiv
" Drucken", // 9 + Aktiv oder Inaktiv
"Druck-Position", // 10 +Wert
"Druck-Position",// 11 Untermenü
" Servo1 Oben", // 12 +Wert
" Servo1 Unten", // 13 +Wert
"Servo2Position", // 14 +Wert
" Lüfter", // 15 Inaktiv oder Spannung
" Trockenzeit" // 16 WarteZeit nach Druck in Zehntelsekunden
};
byte AktuellerMenuePunkt = 99;
altePositionSmallRotary = 99;
SetzeSmallRotaryWert(0); //RESET
while (altePositionSmallRotary != 0) //bis Menü verlassen wird
{
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary < 0)
{
neuePositionSmallRotary = 0;
SetzeSmallRotaryWert(neuePositionSmallRotary);
}
if (neuePositionSmallRotary > 16)
{
neuePositionSmallRotary = 16;
SetzeSmallRotaryWert(neuePositionSmallRotary);
}
if (MitDruck[AktuellesEtikett] == LOW) neuePositionSmallRotary = neuePositionSmallRotary % 10; //Drucken nicht aktiviert
else neuePositionSmallRotary = neuePositionSmallRotary % 17;
if (neuePositionSmallRotary == 6 && altePositionSmallRotary == 5) neuePositionSmallRotary += DriveJump;
if (neuePositionSmallRotary == 7) neuePositionSmallRotary -= DriveJump;
if (neuePositionSmallRotary != altePositionSmallRotary)
{
#if myDEBUG
Serial.print(F("1.UM_neuePositionSmallRotary:"));
Serial.println(neuePositionSmallRotary);
#endif
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(5, 15);
sprintf(Ausgabe, "Datensatz (%d)", (AktuellesEtikett + 1));
u8g2.print(Ausgabe);
u8g2.drawLine(0, 20, 164, 20); //horiz. Linie
u8g2.setCursor(1, 40);
u8g2.print(MenuePunkte[neuePositionSmallRotary]);
u8g2.setCursor(52, 60);
if (neuePositionSmallRotary == 1) //Etikettenlänge
{
u8g2.print(Etikettenlaenge[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 2 || neuePositionSmallRotary == 11) //M)Etikettenlänge
{
u8g2.setCursor(1, 60);
u8g2.print(F(" man. anfahren"));
}
if (neuePositionSmallRotary == 3) //Handbetrieb
{
u8g2.setCursor(30, 60);
u8g2.print(F("Inaktiv"));
}
if (neuePositionSmallRotary == 4) //Buzzer
{
u8g2.setCursor(12, 60);
if (MitBuzzer[AktuellesEtikett] == LOW) u8g2.print(F("Deaktiviert"));
else u8g2.print(F(" Aktiviert"));
}
if (neuePositionSmallRotary == 5) //Counter
{
u8g2.print(Counter[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 6) //SchrittMotor Speed
{
u8g2.setCursor(10, 60);
u8g2.print(F("Speed:"));
u8g2.setCursor(90, 60);
u8g2.print(MaxSpeed[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 7) //SchrittMotor Acceleration
{
u8g2.setCursor(10, 60);
u8g2.print(F("Accel.:"));
u8g2.setCursor(90, 60);
u8g2.print(Acceleration[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 8) //Fußschalter
{
u8g2.setCursor(12, 60);
if (MitFuss[AktuellesEtikett] == LOW) u8g2.print(F("Deaktiviert"));
else u8g2.print(F(" Aktiviert"));
}
if (neuePositionSmallRotary == 9) //Drucken
{
u8g2.setCursor(12, 60);
if (MitDruck[AktuellesEtikett] == LOW) u8g2.print(F("Deaktiviert"));
else u8g2.print(F(" Aktiviert"));
}
if (neuePositionSmallRotary == 10) //Druckposition
{
u8g2.print(ZeitBisDatumDruck[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 12) //Servo1Oben
{
u8g2.print(Servo1PositionOben[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 13) //Servo1Unten
{
u8g2.print(Servo1PositionUnten[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 14) ////Servo2Pos
{
u8g2.print(Servo2Position[AktuellesEtikett]);
}
if (neuePositionSmallRotary == 15) //Lüfter
{
u8g2.setCursor(12, 60);
if (MitLuft[AktuellesEtikett] == 0) u8g2.print(F("Deaktiviert"));
else
{
u8g2.setCursor(48, 60);
u8g2.print(MitLuft[AktuellesEtikett] * 10);
u8g2.print(F("%"));
}
}
if (neuePositionSmallRotary == 16)
{
u8g2.print(DruckTrockenZeit[AktuellesEtikett]);
u8g2.print(F(" sec"));
}
u8g2.sendBuffer();
altePositionSmallRotary = neuePositionSmallRotary;
SetzeSmallRotaryWert(neuePositionSmallRotary);
}
} //while Taster nicht gedrückt
buzzer(BUZZER_SHORT);
Entprellen();
// Ende Untermenü
// Position 1 Etikettenlänge per Wert einstellen
if (altePositionSmallRotary == 1) WertAendern(Etikettenlaenge, MenuePunkte[neuePositionSmallRotary]);
// Position 2 Etikettenlänge (durch Wert Position anfahren) einstellen
if (altePositionSmallRotary == 2) PositionAnfahren();
// Position 3 Handbetrieb
if (altePositionSmallRotary == 3) Handbetrieb();
// Position 4 Buzzer generell de-/aktivieren
if (altePositionSmallRotary == 4) WertInAktivAendern(MitBuzzer, MenuePunkte[neuePositionSmallRotary]);
// Position 5 Counter Reset
if (altePositionSmallRotary == 5)
{
int oldPositionSmallRotary = 99;
bool ResetCounter = HIGH;
SetzeSmallRotaryWert(0); //RESET
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != oldPositionSmallRotary)
{
u8g2.drawBox(15, 48, 103, 14);
u8g2.setDrawColor(0);
if (!ResetCounter)
{
u8g2.setCursor(42, 60);
u8g2.setDrawColor(0);
u8g2.print(F("Reset"));
ResetCounter = HIGH;
}
else
{
u8g2.setCursor(52, 60);
u8g2.print(Counter[AktuellesEtikett]);
ResetCounter = LOW;
}
u8g2.setDrawColor(1);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
}
} //while Taster nicht gedrückt
if (ResetCounter)
{
Counter[AktuellesEtikett] = 0;
EinWertNeu = HIGH; //EEPROM-Write aktiviert - ein Wert geändert
}
SetzeSmallRotaryWert(altePositionSmallRotary); // zurück an die richtige Stelle
altePositionSmallRotary = 99;
buzzer(BUZZER_LONG);
Entprellen();
}
// Position 6 MaxSpeed
if (altePositionSmallRotary == 6) WertAendern(MaxSpeed, MenuePunkte[neuePositionSmallRotary]);
// Position 7 Acceleration
if (altePositionSmallRotary == 7) WertAendern(Acceleration, MenuePunkte[neuePositionSmallRotary]);
// Position 8 Fußschalter generell de-/aktivieren
if (altePositionSmallRotary == 8) WertInAktivAendern(MitFuss, MenuePunkte[neuePositionSmallRotary]);
// Position 9 Druck de-/aktivieren
if (altePositionSmallRotary == 9) WertInAktivAendern(MitDruck, MenuePunkte[neuePositionSmallRotary]);
// Position 10 ZeitBisDruck per Wert einstellen
if (altePositionSmallRotary == 10) WertAendern(ZeitBisDatumDruck, MenuePunkte[neuePositionSmallRotary]);
// Position 11 ZeitBisDruck per Anfahren einstellen
if (altePositionSmallRotary == 11) PositionAnfahren();
// Position 12 Servo1Oben per Wert einstellen
if (altePositionSmallRotary == 12) WertServoAendern(Servo1PositionOben, MenuePunkte[neuePositionSmallRotary]);
// Position 13 Servo1Oben per Wert einstellen
if (altePositionSmallRotary == 13) WertServoAendern(Servo1PositionUnten, MenuePunkte[neuePositionSmallRotary]);
// Position 14 Servo1Oben per Wert einstellen
if (altePositionSmallRotary == 14) WertServoAendern(Servo2Position, MenuePunkte[neuePositionSmallRotary]);
// Position 15 Lüfter de-/aktivieren bzw Spannung einstellen
if (altePositionSmallRotary == 15) WertAendern(MitLuft, MenuePunkte[neuePositionSmallRotary]);
// Position 16 Druckwartezeit einstellen
if (altePositionSmallRotary == 16) WertServoAendern(DruckTrockenZeit, MenuePunkte[neuePositionSmallRotary]);
}
//Menü verlassen
if (SpeicherAktuellesEtikett != AktuellesEtikett) EinWertNeu = HIGH; //Falls nur Etikett geändert auch abspeichern
if (EinWertNeu)
{
WriteMem(); //Daten nur sichern, falls es eine Änderung gab
//MenueHeader();
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(0, 60);
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.print(F("Daten abspeichern..."));
u8g2.sendBuffer();
for (int p = 0; p < 3; p++)
{
buzzer(BUZZER_SHORT);
}
EinWertNeu = LOW; //Reset
}
Entprellen();
DisplayNeutral();
//Es geht in den BEREITmodus zurück
altePositionSmallRotary = 0; //RESET
SetzeSmallRotaryWert(0); //RESET
}
}
void Entprellen()
{
while (digitalRead(SmallRotary_PIN_SW) == LOW) //ENTPRELLEN
{
delay (100);
}
}
void Handbetrieb()
{
int oldPositionSmallRotary = 0;
SetzeSmallRotaryWert(100); //RESET
Entprellen();
HandModus = HIGH;
while (digitalRead(SmallRotary_PIN_SW) && HandModus) //Warte bis RotarySwitch gedrückt und Modus inaktiv
{
while (digitalRead(SmallRotary_PIN_SW)) //Warte bis RotarySwitch gedrückt und Modus aktiv
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != oldPositionSmallRotary)
{
u8g2.drawBox(1, 48, 128, 14);
u8g2.setDrawColor(0);
if (HandModus)
{
HandModus = LOW;
u8g2.setCursor(30, 60);
u8g2.print("Inaktiv");
}
else
{
HandModus = HIGH;
u8g2.setCursor(1, 60);
u8g2.print("Press to Start");
}
u8g2.setDrawColor(1);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
}
} //while Taster nicht gedrückt - innere While-Schleife
//Tastendruck Auswerten
Entprellen();
if (HandModus)
{
Etikettieren(); //Vorgang von Hand gestartet
Entprellen(); // falls Abbruch im Etikettiervorgang
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(5, 15);
sprintf(Ausgabe, "Datensatz (%d)", (AktuellesEtikett + 1));
u8g2.print(Ausgabe);
u8g2.drawLine(0, 20, 164, 20); //horiz. Linie
u8g2.setCursor(1, 40);
u8g2.print(F(" Handbetrieb"));
u8g2.setCursor(1, 60);
u8g2.drawBox(1, 48, 128, 14);
u8g2.setDrawColor(0);
u8g2.print("Press to Start");
u8g2.setDrawColor(1);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
}
} //äussere Whileschleife
SetzeSmallRotaryWert(altePositionSmallRotary); // zurück an die richtige Stelle
altePositionSmallRotary = 99;
buzzer(BUZZER_LONG);
}
void WertAendern(unsigned int *Was, char * MenuePunkt)
{
int AlterWasWert = Was[AktuellesEtikett];
int oldPositionSmallRotary = 0;
int oldPositionBigRotary = 0;
SetzeSmallRotaryWert(Was[AktuellesEtikett]); //RESET
SetzeBigRotaryWert(0);
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
PositionBigRotary = LeseBigRotaryWert();
if ((neuePositionSmallRotary >= 0) && (neuePositionSmallRotary <= 10000))
{
if (neuePositionSmallRotary != oldPositionSmallRotary || PositionBigRotary != oldPositionBigRotary)
{
Was[AktuellesEtikett] = neuePositionSmallRotary + PositionBigRotary;
#if myDEBUG
Serial.print(F(" neu:"));
Serial.println(Was[AktuellesEtikett]);
#endif
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(1, 40);
u8g2.print(MenuePunkt);
if (altePositionSmallRotary == 6 || altePositionSmallRotary == 7) u8g2.drawBox(80, 48, 108, 14);
else u8g2.drawBox(10, 48, 108, 14);
if (altePositionSmallRotary == 6)
{
u8g2.setCursor(10, 60);
u8g2.print(F("Speed:"));
u8g2.setCursor(90, 60);
}
else if (altePositionSmallRotary == 7)
{
u8g2.setCursor(10, 60);
u8g2.print(F("Accel.:"));
u8g2.setCursor(90, 60);
}
else u8g2.setCursor(50, 60);
u8g2.setDrawColor(0);
if (altePositionSmallRotary == 15)
{
#if !mySYSTEM
ledcWrite(0, MitLuft[AktuellesEtikett] * 25);
#endif
#if mySYSTEM
analogWrite(MiniLuefterEnable_PIN, MitLuft[AktuellesEtikett] * 25);
#endif
digitalWrite(MiniLuefter_PIN1, HIGH); //Lüfter starten
if (Was[AktuellesEtikett] < 1)
{
u8g2.setCursor(12, 60);
u8g2.print(F("Deaktiviert"));
SetzeSmallRotaryWert(0);
SetzeBigRotaryWert(0);
Was[AktuellesEtikett] = 0;
}
else
{
if (Was[AktuellesEtikett] > 9)
{
SetzeSmallRotaryWert(10);
SetzeBigRotaryWert(0);
Was[AktuellesEtikett] = 10;
}
u8g2.setCursor(48, 60);
u8g2.print(Was[AktuellesEtikett] * 10);
u8g2.print("%");
}
}
else u8g2.print(Was[AktuellesEtikett]);
u8g2.setDrawColor(1);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
oldPositionBigRotary = PositionBigRotary;
SetzeSmallRotaryWert(neuePositionSmallRotary);
}
}
EinWertNeu = HIGH; //EEPROM-Write aktiviert - ein Wert geändert
} //while Taster nicht gedrückt
digitalWrite(MiniLuefter_PIN1, LOW); //Lüfter stoppen, falls lief
SetzeSmallRotaryWert(altePositionSmallRotary); // zurück an die richtige Stelle
altePositionSmallRotary = 99;
buzzer(BUZZER_LONG);
Entprellen();
}
void WertServoAendern(unsigned int *Was, char * MenuePunkt) //Für Servowerte und Drucktrockenzeit
{
int oldPositionSmallRotary = 0;
SetzeSmallRotaryWert(Was[AktuellesEtikett]); //RESET
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if ((neuePositionSmallRotary >= 0) && (neuePositionSmallRotary <= 180))
{
if (neuePositionSmallRotary != oldPositionSmallRotary)
{
Was[AktuellesEtikett] = neuePositionSmallRotary;
#if myDEBUG
Serial.print(F("SmRot:"));
Serial.println(Was[AktuellesEtikett]);
#endif
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(1, 40);
u8g2.print(MenuePunkt);
u8g2.drawBox(15, 48, 103, 14);
u8g2.setCursor(52, 60);
u8g2.setDrawColor(0);
u8g2.print(Was[AktuellesEtikett]);
if (altePositionSmallRotary == 16) u8g2.print(F(" sec")); //WarteZeit nach Druck
u8g2.setDrawColor(1);
u8g2.sendBuffer();
if (altePositionSmallRotary == 12 || altePositionSmallRotary == 13) Servo1.write(Was[AktuellesEtikett]);
if (altePositionSmallRotary == 14) Servo2.write(Was[AktuellesEtikett]);
oldPositionSmallRotary = neuePositionSmallRotary;
SetzeSmallRotaryWert(Was[AktuellesEtikett]);
}
}
EinWertNeu = HIGH; //EEPROM-Write aktiviert - ein Wert geändert
} //while Taster nicht gedrückt
//Falls unterer Servo1Wert eingestellt wurde - Servo automatisch wieder hochfahren
if (altePositionSmallRotary == 13) Servo1.write(Servo1PositionOben[AktuellesEtikett]);
SetzeSmallRotaryWert(altePositionSmallRotary); // zurück an die richtige Stelle
altePositionSmallRotary = 99;
buzzer(BUZZER_LONG);
Entprellen();
}
void WertInAktivAendern(bool *Was, char * MenuePunkt) //Für An/Aus-Werte
{
int oldPositionSmallRotary = 99;
SetzeSmallRotaryWert(0); //RESET
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != oldPositionSmallRotary)
{
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(1, 40);
u8g2.print(MenuePunkt);
u8g2.setCursor(15, 60);
u8g2.drawBox(10, 48, 108, 14);
u8g2.setDrawColor(0);
if (Was[AktuellesEtikett] == LOW)
{
u8g2.print(F("Deaktiviert"));
Was[AktuellesEtikett] = HIGH;
}
else
{
u8g2.print(F(" Aktiviert"));
Was[AktuellesEtikett] = LOW;
}
u8g2.setDrawColor(1);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
SetzeSmallRotaryWert(neuePositionSmallRotary);
EinWertNeu = HIGH; //EEPROM-Write aktiviert - ein Wert geändert
}
} //while Taster nicht gedrückt
if (Was[AktuellesEtikett] == LOW) Was[AktuellesEtikett] = HIGH;
else Was[AktuellesEtikett] = LOW;
SetzeSmallRotaryWert(altePositionSmallRotary); // zurück an die richtige Stelle
altePositionSmallRotary = 99;
buzzer(BUZZER_LONG);
Entprellen();
}
void PositionAnfahren()
{
int oldPositionSmallRotary = 0;
Entprellen();
PositionBigRotary = abs(LeseBigRotaryWert());
SetzeSmallRotaryWert(0);
SetzeBigRotaryWert(0);
int OldBig = 99;
String SpeedAnzeige = "<<Drehregler>>";
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != oldPositionSmallRotary)
{
u8g2.setDrawColor(0);
u8g2.drawBox(0, 49, 128, 14); //löschen der Zeile
u8g2.setDrawColor(1);
u8g2.setCursor(1, 60);
if (neuePositionSmallRotary > 0)
{
if (neuePositionSmallRotary > 8)
{
SetzeSmallRotaryWert(9);
neuePositionSmallRotary = 9;
}
SpeedAnzeige = String(neuePositionSmallRotary) + " ";
MotorVor(neuePositionSmallRotary);
for (int i = 1; i <= neuePositionSmallRotary; i++)
{
SpeedAnzeige = SpeedAnzeige + ">";
}
}
else if (neuePositionSmallRotary < 0)
{
if (neuePositionSmallRotary < -8)
{
SetzeSmallRotaryWert(-9);
neuePositionSmallRotary = -9;
}
SpeedAnzeige = String(-neuePositionSmallRotary) + " ";
MotorRueck(-neuePositionSmallRotary);
for (int i = -1; i >= neuePositionSmallRotary; i--)
{
SpeedAnzeige = SpeedAnzeige + "<";
}
}
else
{
SpeedAnzeige = "<<Drehregler>>";
MotorStop();
}
u8g2.print(SpeedAnzeige);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
SetzeSmallRotaryWert(neuePositionSmallRotary);
}
PositionBigRotary = abs(LeseBigRotaryWert());
if (PositionBigRotary != OldBig)
{
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(1, 15);
u8g2.print(F("STARTPOSITION:"));
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.setCursor(1, 30);
u8g2.print(F("Etikett bis ans Glas"));
u8g2.setCursor(1, 45);
u8g2.print(F("ranfahren -->"));
u8g2.setCursor(93, 45);
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.print(PositionBigRotary);
u8g2.setCursor(1, 60);
u8g2.print(SpeedAnzeige);
u8g2.sendBuffer();
OldBig = PositionBigRotary;
}
} //while Taster nicht gedrückt
#if myDEBUG
Serial.println(F("Startposition gefunden"));
#endif
Entprellen();
SetzeSmallRotaryWert(0);
SetzeBigRotaryWert(0);
OldBig = 99;
SpeedAnzeige = "<<Drehregler>>";
while (digitalRead(SmallRotary_PIN_SW))
{
neuePositionSmallRotary = LeseSmallRotaryWert();
if (neuePositionSmallRotary != oldPositionSmallRotary)
{
#if myDEBUG
Serial.print(F("SmallRotarywert:"));
Serial.println(neuePositionSmallRotary); // ...soll die aktuelle Position im seriellen Monitor ausgegeben werden.
#endif
u8g2.setDrawColor(0);
u8g2.drawBox(0, 49, 128, 14); //löschen der Zeile
u8g2.setDrawColor(1);
u8g2.setCursor(1, 60);
if (neuePositionSmallRotary > 0)
{
if (neuePositionSmallRotary > 8)
{
SetzeSmallRotaryWert(9);
neuePositionSmallRotary = 9;
}
SpeedAnzeige = String(neuePositionSmallRotary) + " ";
MotorVor(neuePositionSmallRotary);
for (int i = 1; i <= neuePositionSmallRotary; i++)
{
SpeedAnzeige = SpeedAnzeige + ">";
}
}
else if (neuePositionSmallRotary < 0)
{
if (neuePositionSmallRotary < -8)
{
SetzeSmallRotaryWert(-9);
neuePositionSmallRotary = -9;
}
SpeedAnzeige = String(-neuePositionSmallRotary) + " ";
MotorRueck(-neuePositionSmallRotary);
for (int i = -1; i >= neuePositionSmallRotary; i--)
{
SpeedAnzeige = SpeedAnzeige + "<";
}
}
else
{
SpeedAnzeige = "<<Drehregler>>";
MotorStop();
}
u8g2.print(SpeedAnzeige);
u8g2.sendBuffer();
oldPositionSmallRotary = neuePositionSmallRotary;
SetzeSmallRotaryWert(neuePositionSmallRotary);
}
PositionBigRotary = abs(LeseBigRotaryWert());
if (PositionBigRotary != OldBig)
{
u8g2.clearBuffer();
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(1, 15);
if (altePositionSmallRotary == 2)
{
u8g2.print(F("END-POSITION:"));
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.setCursor(1, 30);
u8g2.print(F("Etikett ans nächste"));
u8g2.setCursor(1, 45);
u8g2.print(F("Glas fahren ->"));
}
else
{
u8g2.print(F("DRUCK-POSITION:"));
u8g2.setFont(u8g2_font_courB08_tf);
u8g2.setCursor(1, 30);
u8g2.print(F("Etikett an die Druck-"));
u8g2.setCursor(1, 45);
u8g2.print(F("Position fahren"));
}
u8g2.setCursor(93, 45);
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.print(PositionBigRotary);
u8g2.setCursor(1, 60);
u8g2.print(SpeedAnzeige);
u8g2.sendBuffer();
OldBig = PositionBigRotary;
}
} //while Taster nicht gedrückt
if (altePositionSmallRotary == 2)
{
Etikettenlaenge[AktuellesEtikett] = abs(LeseBigRotaryWert());
#if myDEBUG
Serial.print(F("Endposition gefunden:"));
Serial.println(Etikettenlaenge[AktuellesEtikett]);
#endif
}
else
{
ZeitBisDatumDruck[AktuellesEtikett] = abs(LeseBigRotaryWert());
#if myDEBUG
Serial.print(F("Druckposition gefunden:"));
Serial.println(ZeitBisDatumDruck[AktuellesEtikett]);
Serial.print(F("alte rotPOs:"));
Serial.println(altePositionSmallRotary);
#endif
}
SetzeSmallRotaryWert(altePositionSmallRotary - 1); // zurück an die richtige Stelle
altePositionSmallRotary = 99;
buzzer(BUZZER_LONG);
EinWertNeu = HIGH; //EEPROM-Write aktiviert - ein Wert geändert
Entprellen();
}
void buzzer(byte type)
{
pinMode(Buzzer_PIN, OUTPUT);
delay(100);
switch (type)
{
case BUZZER_SHORT: //short
if (MitBuzzer[AktuellesEtikett])
{
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);
}
else
{
delay(100);
}
break;
case BUZZER_LONG: //long
if (MitBuzzer[AktuellesEtikett])
{
digitalWrite(Buzzer_PIN, HIGH);
delay(500);
digitalWrite(Buzzer_PIN, LOW);
}
else delay(500);
break;
case BUZZER_SUCCESS: //success
if (MitBuzzer[AktuellesEtikett])
{
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);
delay(100);
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);
delay(100);
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);
}
else delay(500);
break;
case BUZZER_ERROR: //error
if (MitBuzzer[AktuellesEtikett])
{
digitalWrite(Buzzer_PIN, HIGH);
delay(1500);
digitalWrite(Buzzer_PIN, LOW);
}
else delay(1500);
break;
}
}
bool Ultraschallsensor(float Schwelle) {
bool glasda = LOW;
float Abstand = 0; //KUD Abstand initialisieren
for (int i = 1; i <= n_pings; i++) {
Abstand = Abstand + get_distance(); //KUD Ultraschallsensor auslesen
}
Abstand = Abstand / n_pings; //KUD Mittelwertbildung
if (Abstand <= Schwelle) {
glasda = HIGH;
}
return (glasda);
}
float get_distance() { //KUD Abstand Glas von Ultraschallsensor
float duration = 0;
float distance = 0;
digitalWrite(TRIG_PIN, LOW);
delayMicroseconds(2);
noInterrupts();
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);
duration = pulseIn(NaeherungsSensor_PIN, HIGH); // Erfassung - Dauer in Mikrosekunden
interrupts();
distance = (duration / 2) / 29.1; // Distanz in CM
return (distance);
}
//------------------------------------------
// StartLOGO
//------------------------------------------
void print_logo()
{
#if !myDEBUG
const unsigned char logo_biene1[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0,
0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x60, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC1, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x3F,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x70, 0x00, 0xF0, 0xFF, 0x01,
0x00, 0x00, 0x00, 0x00, 0x03, 0xE0, 0x80, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF, 0x80, 0xF1, 0x47, 0xF0, 0x07, 0x00, 0x3E, 0xE0, 0xFF, 0xFF, 0x07,
0xF9, 0x07, 0x7E, 0x00, 0x00, 0x78, 0xF0, 0x03, 0xE0, 0x1F, 0xF8, 0x07, 0x1F, 0x00, 0x00, 0x70, 0x3C, 0x00, 0x00, 0xFE, 0x38, 0xC0, 0x03, 0x00,
0x00, 0xF0, 0x0E, 0x00, 0x00, 0xF8, 0x03, 0xF8, 0x00, 0x00, 0x00, 0xE0, 0x06, 0x00, 0x00, 0xC0, 0x0F, 0x7C, 0x00, 0x00, 0x00, 0xE0, 0x06, 0x00,
0x00, 0x00, 0x1F, 0x1F, 0x00, 0x00, 0x00, 0x70, 0x03, 0x00, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x70, 0x03, 0x00, 0x00, 0x00, 0xF0, 0x03,
0x00, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x07, 0x00, 0x00, 0x0F,
0x0F, 0x00, 0x00, 0x78, 0x78, 0xE0, 0x3F, 0x00, 0xC0, 0x07, 0x3E, 0x00, 0x80, 0xFF, 0x3C, 0xC0, 0x7F, 0x00, 0xF0, 0x01, 0xFC, 0x00, 0xE0, 0xFF,
0x1C, 0x80, 0xFF, 0x01, 0x7E, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x0E, 0x00, 0xFE, 0xFF, 0x0F, 0x00, 0xC0, 0xFF, 0xFF, 0x07, 0x0F, 0x00, 0xC0, 0x1F,
0x00, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x07, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x80, 0x03, 0x80, 0x03, 0xE0, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0,
0x01, 0xC0, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0xE0, 0x81, 0xC3, 0x01, 0xC0, 0x01, 0x00, 0x00, 0x70, 0x00, 0xE0, 0xF1, 0x8F,
0x03, 0x80, 0x03, 0x00, 0x00, 0x38, 0x00, 0xF0, 0xFC, 0x9F, 0x07, 0x00, 0x07, 0x00, 0x00, 0x1C, 0x00, 0xF8, 0x1C, 0x1C, 0x0F, 0x00, 0x06, 0x00,
0x00, 0x1C, 0x00, 0xFE, 0x00, 0x00, 0x1F, 0x00, 0x0C, 0x00, 0x00, 0x0E, 0x00, 0xF7, 0x00, 0x00, 0x7F, 0x00, 0x0C, 0x00, 0x00, 0x06, 0x80, 0x73,
0x00, 0x00, 0xE6, 0x00, 0x0C, 0x00, 0x00, 0x07, 0xE0, 0x71, 0x00, 0x00, 0xC6, 0x03, 0x0C, 0x00, 0x00, 0x07, 0x70, 0x70, 0xF0, 0x0F, 0x86, 0x07,
0x0C, 0x00, 0x00, 0x03, 0x3C, 0x70, 0xFC, 0x3F, 0x06, 0x1F, 0x0E, 0x00, 0x00, 0x03, 0x1E, 0x70, 0xFE, 0x3F, 0x06, 0xFC, 0x07, 0x00, 0x00, 0x87,
0x0F, 0x70, 0x1E, 0x38, 0x06, 0xF0, 0x03, 0x00, 0x00, 0xFE, 0x03, 0xF0, 0x00, 0x00, 0x06, 0xC0, 0x00, 0x00, 0x00, 0xFC, 0x00, 0xF0, 0x00, 0x00,
0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x80, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xE0, 0x0F, 0x07, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xE0, 0xF1, 0x9F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x3B, 0x9C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0,
0x07, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xE0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x7C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0D,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
u8g2.clearBuffer(); // clear the internal memory
u8g2.drawXBM(0, 0, 80, 64, logo_biene1);
#else
u8g2.clearBuffer(); // clear the internal memory
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(1, 10); u8g2.print(F("Achtung:"));
u8g2.setCursor(1, 25); u8g2.print(F("Debug"));
u8g2.setCursor(1, 40); u8g2.print(F("an!!!"));
#endif
u8g2.setFont(u8g2_font_courB14_tf);
#if mySYSTEM
u8g2.setCursor(85, 20); u8g2.print(F("Et"));
u8g2.setCursor(80, 40); u8g2.print(F("Vom"));
u8g2.setCursor(52, 60); u8g2.print(F("Schleck"));
#else
u8g2.setCursor(85, 27); u8g2.print("Etti");
u8g2.setCursor(73, 43); u8g2.print("MANDL");
u8g2.setCursor(85, 54);
#endif
u8g2.setFont(u8g2_font_courB10_tf);
u8g2.setCursor(0, 62); u8g2.print(Version);
u8g2.sendBuffer();
delay(2000);
DisplayNeutral();
}
//----------------------------------------------------------------
// Schreibe in Memory
//----------------------------------------------------------------
void WriteMem() {
#if mySYSTEM
byte low, high, set;
byte AnzahlWerte = 23;
set = 99;
EEPROM.write(0, set); // Zeichen, dass bereits aktiv beschrieben wurde
for (int w = 0; w < 3; w++) //Position 1-69
{
low = Etikettenlaenge[w] & 0xFF;
high = (Etikettenlaenge[w] >> 8) & 0xFF;
EEPROM.write(1 + (w * AnzahlWerte), low);
EEPROM.write(2 + (w * AnzahlWerte), high);
EEPROM.write(3 + (w * AnzahlWerte), MitBuzzer[w]);
low = Counter[w] & 0xFF;
high = (Counter[w] >> 8) & 0xFF;
EEPROM.write(4 + (w * AnzahlWerte), low);
EEPROM.write(5 + (w * AnzahlWerte), high);
low = MaxSpeed[w] & 0xFF;
high = (MaxSpeed[w] >> 8) & 0xFF;
EEPROM.write(6 + (w * AnzahlWerte), low);
EEPROM.write(7 + (w * AnzahlWerte), high);
low = Acceleration[w] & 0xFF;
high = (Acceleration[w] >> 8) & 0xFF;
EEPROM.write(8 + (w * AnzahlWerte), low);
EEPROM.write(9 + (w * AnzahlWerte), high);
EEPROM.write(10 + (w * AnzahlWerte), MitFuss[w]);
EEPROM.write(11 + (w * AnzahlWerte), MitDruck[w]);
low = ZeitBisDatumDruck[w] & 0xFF;
high = (ZeitBisDatumDruck[w] >> 8) & 0xFF;
EEPROM.write(12 + (w * AnzahlWerte), low);
EEPROM.write(13 + (w * AnzahlWerte), high);
low = Servo1PositionOben[w] & 0xFF;
high = (Servo1PositionOben[w] >> 8) & 0xFF;
EEPROM.write(14 + (w * AnzahlWerte), low);
EEPROM.write(15 + (w * AnzahlWerte), high);
low = Servo1PositionUnten[w] & 0xFF;
high = (Servo1PositionUnten[w] >> 8) & 0xFF;
EEPROM.write(16 + (w * AnzahlWerte), low);
EEPROM.write(17 + (w * AnzahlWerte), high);
low = Servo2Position[w] & 0xFF;
high = (Servo2Position[w] >> 8) & 0xFF;
EEPROM.write(18 + (w * AnzahlWerte), low);
EEPROM.write(19 + (w * AnzahlWerte), high);
low = MitLuft[w] & 0xFF;
high = (MitLuft[w] >> 8) & 0xFF;
EEPROM.write(20 + (w * AnzahlWerte), low);
EEPROM.write(21 + (w * AnzahlWerte), high);
low = DruckTrockenZeit[w] & 0xFF;
high = (DruckTrockenZeit[w] >> 8) & 0xFF;
EEPROM.write(22 + (w * AnzahlWerte), low);
EEPROM.write(23 + (w * AnzahlWerte), high);
}
EEPROM.write(70, AktuellesEtikett);
#else
preferences.begin("EEPROM", false);
preferences.putUInt("AktEtikett", AktuellesEtikett);
preferences.putUInt("EtiLaenge0", Etikettenlaenge[0]);
preferences.putUInt("EtiLaenge1", Etikettenlaenge[1]);
preferences.putUInt("EtiLaenge2", Etikettenlaenge[2]);
preferences.putBool("MitBuzzer0", MitBuzzer[0]);
preferences.putBool("MitBuzzer1", MitBuzzer[1]);
preferences.putBool("MitBuzzer2", MitBuzzer[2]);
preferences.putUInt("Counter0", Counter[0]);
preferences.putUInt("Counter1", Counter[1]);
preferences.putUInt("Counter2", Counter[2]);
preferences.putUInt("MaxSpeed0", MaxSpeed[0]);
preferences.putUInt("MaxSpeed1", MaxSpeed[1]);
preferences.putUInt("MaxSpeed2", MaxSpeed[2]);
preferences.putUInt("Acceleration0", Acceleration[0]);
preferences.putUInt("Acceleration1", Acceleration[1]);
preferences.putUInt("Acceleration2", Acceleration[2]);
preferences.putBool("MitFuss0", MitFuss[0]);
preferences.putBool("MitFuss1", MitFuss[1]);
preferences.putBool("MitFuss2", MitFuss[2]);
preferences.putBool("MitDruck0", MitDruck[0]);
preferences.putBool("MitDruck1", MitDruck[1]);
preferences.putBool("MitDruck2", MitDruck[2]);
preferences.putUInt("ZeitBisDruck0", ZeitBisDatumDruck[0]);
preferences.putUInt("ZeitBisDruck1", ZeitBisDatumDruck[1]);
preferences.putUInt("ZeitBisDruck2", ZeitBisDatumDruck[2]);
preferences.putUInt("Servo1PosOben0", Servo1PositionOben[0]);
preferences.putUInt("Servo1PosOben1", Servo1PositionOben[1]);
preferences.putUInt("Servo1PosOben2", Servo1PositionOben[2]);
preferences.putUInt("Servo1PosUnten0", Servo1PositionUnten[0]);
preferences.putUInt("Servo1PosUnten1", Servo1PositionUnten[1]);
preferences.putUInt("Servo1PosUnten2", Servo1PositionUnten[2]);
preferences.putUInt("Servo2Pos0", Servo2Position[0]);
preferences.putUInt("Servo2Pos1", Servo2Position[1]);
preferences.putUInt("Servo2Pos2", Servo2Position[2]);
preferences.putUInt("MitLuft0", MitLuft[0]);
preferences.putUInt("MitLuft1", MitLuft[1]);
preferences.putUInt("MitLuft2", MitLuft[2]);
preferences.putUInt("TrockenZeit0", DruckTrockenZeit[0]);
preferences.putUInt("TrockenZeit1", DruckTrockenZeit[1]);
preferences.putUInt("TrockenZeit2", DruckTrockenZeit[2]);
preferences.end();
#endif
#if myDEBUG
Serial.println(F("EE_Writing"));
Serial.print( F("Aktuelles Etikett: ") );
Serial.println(AktuellesEtikett + 1);
for (int d = 0; d < 3; d++)
{
Serial.print( F("Etikettenlaenge") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Etikettenlaenge[d]);
Serial.print( F("ZeitBisDatumDruck") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(ZeitBisDatumDruck[d]);
Serial.print( F("Buzzer") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(MitBuzzer[d]);
Serial.print( F("Counter") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Counter[d]);
Serial.print( F("DruckOption") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(MitDruck[d]);
Serial.print( F("Servo1PositionOben") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Servo1PositionOben[d]);
Serial.print( F("Servo1PositionUnten") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Servo1PositionUnten[d]);
Serial.print( F("Servo2Position") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Servo2Position[d]);
Serial.print( F("DruckTrockenZeit") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(DruckTrockenZeit[d]);
Serial.print( F("Lüfter") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(MitLuft[d]);
Serial.println();
}
#endif
}
//----------------------------------------------------------------
//----------------------------------------------------------------
// Lese aus Memory
//----------------------------------------------------------------
void ReadMem() {
#if mySYSTEM //Arduino NANO
byte low, high, set;
byte AnzahlWerte = 23;
set = EEPROM.read(0);
if (set == 99) //Gibt es bereits Daten im EEPROM?
{
for (int r = 0; r < 3; r++) //Position 1-69
{
low = EEPROM.read(1 + (r * AnzahlWerte));
high = EEPROM.read(2 + (r * AnzahlWerte));
Etikettenlaenge[r] = low + ((high << 8) & 0xFF00);
MitBuzzer[r] = EEPROM.read(3 + (r * AnzahlWerte));
low = EEPROM.read(4 + (r * AnzahlWerte));
high = EEPROM.read(5 + (r * AnzahlWerte));
Counter[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(6 + (r * AnzahlWerte));
high = EEPROM.read(7 + (r * AnzahlWerte));
MaxSpeed[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(8 + (r * AnzahlWerte));
high = EEPROM.read(9 + (r * AnzahlWerte));
Acceleration[r] = low + ((high << 8) & 0xFF00);
MitFuss[r] = EEPROM.read(10 + (r * AnzahlWerte));
MitDruck[r] = EEPROM.read(11 + (r * AnzahlWerte));
low = EEPROM.read(12 + (r * AnzahlWerte));
high = EEPROM.read(13 + (r * AnzahlWerte));
ZeitBisDatumDruck[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(14 + (r * AnzahlWerte));
high = EEPROM.read(15 + (r * AnzahlWerte));
Servo1PositionOben[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(16 + (r * AnzahlWerte));
high = EEPROM.read(17 + (r * AnzahlWerte));
Servo1PositionUnten[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(18 + (r * AnzahlWerte));
high = EEPROM.read(19 + (r * AnzahlWerte));
Servo2Position[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(20 + (r * AnzahlWerte));
high = EEPROM.read(21 + (r * AnzahlWerte));
MitLuft[r] = low + ((high << 8) & 0xFF00);
low = EEPROM.read(22 + (r * AnzahlWerte));
high = EEPROM.read(23 + (r * AnzahlWerte));
DruckTrockenZeit[r] = low + ((high << 8) & 0xFF00);
}
AktuellesEtikett = EEPROM.read(70);
}
#else //ESP32
preferences.begin("EEPROM", false);
AktuellesEtikett = preferences.getUInt("AktEtikett", 0);
Etikettenlaenge[0] = preferences.getUInt("EtiLaenge0", 500);
Etikettenlaenge[1] = preferences.getUInt("EtiLaenge1", 1000);
Etikettenlaenge[2] = preferences.getUInt("EtiLaenge2", 2000);
ZeitBisDatumDruck[0] = preferences.getUInt("ZeitBisDruck0", 250);
ZeitBisDatumDruck[1] = preferences.getUInt("ZeitBisDruck1", 500);
ZeitBisDatumDruck[2] = preferences.getUInt("ZeitBisDruck2", 1000);
MitBuzzer[0] = preferences.getBool("MitBuzzer0", 1);
MitBuzzer[1] = preferences.getBool("MitBuzzer1", 0);
MitBuzzer[2] = preferences.getBool("MitBuzzer2", 0);
Counter[0] = preferences.getUInt("Counter0", 0);
Counter[1] = preferences.getUInt("Counter1", 0);
Counter[2] = preferences.getUInt("Counter2", 0);
MaxSpeed[0] = preferences.getUInt("MaxSpeed0", 1000);
MaxSpeed[1] = preferences.getUInt("MaxSpeed1", 1000);
MaxSpeed[2] = preferences.getUInt("MaxSpeed", 1000);
Acceleration[0] = preferences.getUInt("Acceleration0", 0);
Acceleration[1] = preferences.getUInt("Acceleration1", 0);
Acceleration[2] = preferences.getUInt("Acceleration2", 0);
MitFuss[0] = preferences.getBool("MitFuss0", 0);
MitFuss[1] = preferences.getBool("MitFuss1", 0);
MitFuss[2] = preferences.getBool("MitFuss2", 0);
MitDruck[0] = preferences.getBool("MitDruck0", 0);
MitDruck[1] = preferences.getBool("MitDruck1", 0);
MitDruck[2] = preferences.getBool("MitDruck2", 0);
Servo1PositionOben[0] = preferences.getUInt("Servo1PosOben0", 125);
Servo1PositionOben[1] = preferences.getUInt("Servo1PosOben1", 125);
Servo1PositionOben[2] = preferences.getUInt("Servo1PosOben2", 125);
Servo1PositionUnten[0] = preferences.getUInt("Servo1PosUnten0", 125);
Servo1PositionUnten[1] = preferences.getUInt("Servo1PosUnten1", 125);
Servo1PositionUnten[2] = preferences.getUInt("Servo1PosUnten2", 125);
Servo2Position[0] = preferences.getUInt("Servo2Pos0", 125);
Servo2Position[1] = preferences.getUInt("Servo2Po1", 125);
Servo2Position[2] = preferences.getUInt("Servo2Pos2", 125);
MitLuft[0] = preferences.getUInt("MitLuft0", 0);
MitLuft[1] = preferences.getUInt("MitLuft1", 0);
MitLuft[2] = preferences.getUInt("MitLuft2", 0);
DruckTrockenZeit[0] = preferences.getUInt("TrockenZeit0", 0);
DruckTrockenZeit[1] = preferences.getUInt("TrockenZeit1", 0);
DruckTrockenZeit[2] = preferences.getUInt("TrockenZeit2", 0);
// preferences.clear(); Falls mal mal das EE-Prom leeren will
preferences.end();
#endif
#if myDEBUG
Serial.println(F("EE_Reading"));
Serial.print( F("Aktuelles Etikett: ") );
Serial.println(AktuellesEtikett + 1);
for (int d = 0; d < 3; d++)
{
Serial.print( F("Etikettenlaenge") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Etikettenlaenge[d]);
Serial.print( F("ZeitBisDatumDruck") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(ZeitBisDatumDruck[d]);
Serial.print( F("Servo1PositionOben") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(Servo1PositionOben[d]);
if (Servo1PositionOben[d] > 180) Servo1PositionOben[d] = 180;
Serial.print( F("Servo1PositionUnten") );
Serial.print(d + 1);
Serial.print( F(": ") );
if (Servo1PositionUnten[d] > 180) Servo1PositionUnten[d] = 180;
Serial.println(Servo1PositionUnten[d]);
Serial.print( F("Servo2Position") );
Serial.print(d + 1);
Serial.print( F(": ") );
if (Servo2Position[d] > 180) Servo2Position[d] = 180;
Serial.println(Servo2Position[d]);
Serial.print( F("MitDruck") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(MitDruck[d]);
Serial.print( F("MitLuft") );
Serial.print(d + 1);
Serial.print( F(": ") );
if (MitLuft[d] > 10) MitLuft[d] = 10;
Serial.println(MitLuft[d]);
Serial.print( F("DruckTrockenZeit") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.print(DruckTrockenZeit[d]);
Serial.print( F(" / ") );
if (DruckTrockenZeit[d] > 60) DruckTrockenZeit[d] = 60;
Serial.println(DruckTrockenZeit[d]);
Serial.print( F("Buzzer") );
Serial.print(d + 1);
Serial.print( F(": ") );
Serial.println(MitBuzzer[d]);
Serial.println();
}
#endif
}Auf dem ESP32 ist im Speicher noch jede Menge Platz
Sketch uses 335997 bytes (25%) of program storage space. Maximum is 1310720 bytes.
Global variables use 24364 bytes (7%) of dynamic memory, leaving 303316 bytes for local variables. Maximum is 327680 bytes.
Sorry wenn ich mich jetzt doof anstelle.
Mit Deinem Skript erhalte ich mein Kompilieren Fehlermeldungen.
cc1plus.exe: some warnings being treated as errors
Bibliothek Encoder in Version 1.4.4 im Ordner: C:\Users\Michael\OneDrive\Dokumente\Arduino\libraries\Encoder wird verwendet
Bibliothek AccelStepper in Version 1.64 im Ordner: C:\Users\Michael\OneDrive\Dokumente\Arduino\libraries\AccelStepper wird verwendet
Bibliothek Preferences in Version 2.0.0 im Ordner: C:\Users\Michael\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.9\libraries\Preferences wird verwendet
Bibliothek ESP32Servo in Version 3.0.5 im Ordner: C:\Users\Michael\OneDrive\Dokumente\Arduino\libraries\ESP32Servo wird verwendet
Bibliothek Wire in Version 2.0.0 im Ordner: C:\Users\Michael\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.9\libraries\Wire wird verwendet
Bibliothek U8g2_Arduino-master in Version 2.35.30 im Ordner: C:\Users\Michael\OneDrive\Dokumente\Arduino\libraries\U8g2_Arduino-master wird verwendet
Bibliothek SPI in Version 2.0.0 im Ordner: C:\Users\Michael\AppData\Local\Arduino15\packages\esp32\hardware\esp32\2.0.9\libraries\SPI wird verwendet
exit status 1
format '%d' expects argument of type 'int', but argument 3 has type 'long int' [-Werror=format=]
Oder muss ich noch was machen, hab Deinen Satz "Das anzupassen ist jetzt vergleichsweise einfach" nicht richtig verstanden. 
Welche sind das? Im Original -Code sind noch zwei analogWrite() die der ESP32 nicht mag.
Habe ich erst mal auskommentiert.
Hab in Deinem Code keine auskommentierte gesehen.
Es heißt nicht "Skript" sondern Quellcode (oder wenn es schwer zu lesen ist "Quälkot")
cc1plus.exe: some warnings being treated as errors
ich meine mich dunkel zu erinnern, dass die ESP32-core-Programmierer da in irgendwelchen Einstellungsdateien die bei bestimmten Warnungen die Warnung zu einem Compiler-Abbruch-Fehler machen.
Das habe ich vor langer Zeit mal abgestellt.
Auskommentierung habe ich rausgenommen und stattdessen
#if !mySYSTEM
ledcWrite(0, MitLuft[AktuellesEtikett] * 25);
#endif
#if mySYSTEM
analogWrite(MiniLuefterEnable_PIN, MitLuft[AktuellesEtikett] * 25);
#endif
rein genommen.
ledcWrite()
ist eine ESP32-core 2.0.17 function.
Heißt im ESP32-core 3.X anders
Ich benutze nach wie vor Arduino-IDE Version 1.8.19 und ESP32-core 2.0.17
Die Arduino-IDE 2.X hat mir zu viele Würstchen, Pfeifchen und Fähnchen die ich alle nicht brauche.
Das schlimmste an IDE 2.X ist der serielle Monitor.
Da bekommt das Wort seriell eine ganz neue Bedeutung.
Man muss hunderte mal "seriell" Code laufen lassen um jedes mal ein paar wenige Zeilen Serial.print-Ausgabe aus dem Ausgabefenster zu kopieren.
Bei IDE 1.8.19 kann man tausende Zeilen auf einmal kopieren.
@combie hatte da eine bessere Variante vorgeschlagen, um dieses Verhalten in einer platform.local.txt für ESP32 wieder auszuschalten.
Gruß Tommy
So ich bin ja lernfähig und habe den Quellcode in der Arduino-ID Version 1.8.19 und in der IDE 2.3.3 hochgeladen, jeweils mit der ESP32-core 2.0.17
Bei der IDE Version 2.3.3 bekomme ich folgende Fehlermeldung im Seriellen Monitor
ELF file SHA256: 78949404fac1a507
E (228) esp_core_dump_flash: Core dump flash config is corrupted! CRC=0x7bd5c66f instead of 0x0
Rebooting...
ets Jul 29 2019 12:21:46
rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:1344
load:0x40078000,len:13964
load:0x40080400,len:3600
entry 0x400805f0
E (145) gpio: esp_ipc_call_blocking failed (0x103)
E (146) gpio: gpio_install_isr_service(450): GPIO isr service already installed
Guru Meditation Error: Core 0 panic'ed (LoadProhibited). Exception was unhandled.
Core 0 register dump:
PC : 0x400fb39b PS : 0x00060733 A0 : 0x800d98d3 A1 : 0x3ffe3b10
A2 : 0x00000000 A3 : 0x3ffc2cd0 A4 : 0x3ffc2cd0 A5 : 0x00060723
A6 : 0x00060720 A7 : 0x00000001 A8 : 0x800d9490 A9 : 0x3ffe3ad0
A10 : 0x3ffbdcc0 A11 : 0x00000004 A12 : 0x00000022 A13 : 0x3ffe3b10
A14 : 0x007bdcac A15 : 0x003fffff SAR : 0x0000001e EXCCAUSE: 0x0000001c
EXCVADDR: 0x00000000 LBEG : 0x40086c09 LEND : 0x40086c19 LCOUNT : 0xfffffff7
Backtrace: 0x400fb398:0x3ffe3b10 0x400d98d0:0x3ffe3b30 0x400d7264:0x3ffe3b60 0x400d72e1:0x3ffe3b90 0x400d1ee9:0x3ffe3bb0 0x400d2021:0x3ffe3bd0 0x400d498a:0x3ffe3bf0 0x400e31d7:0x3ffe3c20 0x40083271:0x3ffe3c50 0x40079316:0x3ffe3c90 |<-CORRUPTED
Im Arduino 1.8.19 erhalte ich diese Meldung im Seriellen Monitor
21:23:06.932 -> ELF file SHA256: e59538d6ed9caae0
21:23:06.932 ->
21:23:06.932 -> E (228) esp_core_dump_flash: Core dump flash config is corrupted! CRC=0x7bd5c66f instead of 0x0
21:23:06.932 -> Rebooting...
21:23:06.932 -> ets Jul 29 2019 12:21:46
21:23:06.932 ->
21:23:06.932 -> rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
21:23:06.932 -> configsip: 0, SPIWP:0xee
21:23:06.978 -> clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
21:23:06.978 -> mode:DIO, clock div:1
21:23:06.978 -> load:0x3fff0030,len:1344
21:23:06.978 -> load:0x40078000,len:13964
21:23:06.978 -> load:0x40080400,len:3600
21:23:06.978 -> entry 0x400805f0
21:23:07.116 -> E (145) gpio: esp_ipc_call_blocking failed (0x103)
21:23:07.116 -> E (146) gpio: gpio_install_isr_service(450): GPIO isr service already installed
21:23:07.116 -> Guru Meditation Error: Core 0 panic'ed (LoadProhibited). Exception was unhandled.
21:23:07.116 ->
21:23:07.116 -> Core 0 register dump:
21:23:07.116 -> PC : 0x400fb39b PS : 0x00060733 A0 : 0x800d98d3 A1 : 0x3ffe3b10
21:23:07.116 -> A2 : 0x00000000 A3 : 0x3ffc2cd0 A4 : 0x3ffc2cd0 A5 : 0x00060723
21:23:07.116 -> A6 : 0x00060720 A7 : 0x00000001 A8 : 0x800d9490 A9 : 0x3ffe3ad0
21:23:07.116 -> A10 : 0x3ffbdcc0 A11 : 0x00000004 A12 : 0x00000022 A13 : 0x3ffe3b10
21:23:07.163 -> A14 : 0x007bdcac A15 : 0x003fffff SAR : 0x0000001e EXCCAUSE: 0x0000001c
21:23:07.163 -> EXCVADDR: 0x00000000 LBEG : 0x40086c09 LEND : 0x40086c19 LCOUNT : 0xfffffff7
21:23:07.163 ->
21:23:07.163 ->
21:23:07.163 -> Backtrace: 0x400fb398:0x3ffe3b10 0x400d98d0:0x3ffe3b30 0x400d6890:0x3ffe3b60 0x400d690d:0x3ffe3b90 0x400d1ee9:0x3ffe3bb0 0x400d2021:0x3ffe3bd0 0x400d498a:0x3ffe3bf0 0x400e31d7:0x3ffe3c20 0x40083271:0x3ffe3c50 0x40079316:0x3ffe3c90 |<-CORRUPTED
Die Fehlermeldungen sind identisch
ich hab mit der IDE 1.8.19 und der ESP32-core 3.0.5
den Quellcode hochgeladen bekommen, nachdem ich folgende Zeilen auskommentiert habe
//#if mySYSTEM
// analogWrite(MiniLuefterEnable_PIN, MitLuft[AktuellesEtikett] * 25);
//#else
// ledcSetup(0, 5000, 8);
// ledcAttachPin(MiniLuefterEnable_PIN, 0);
// ledcWrite(0, 125);
//#endif
und
// Warten zum Trocknen
// if (DruckTrockenZeit > 0)
Im Seriellen Monitor erhalte ich jetzt
rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:4832
load:0x40078000,len:16460
load:0x40080400,len:4
load:0x40080404,len:3504
entry 0x400805cc
E (155) gpio: esp_ipc_call_blocking failed (0x103)
E (155) gpio: esp_ipc_call_blocking failed (0x103)
⸮f (157) gpio: esp_ipc_call_blocking failed (0x103)
E (157) gpioStarte Setup -2.6
EE_Reading
Aktuelles Etikett: 1
Etikettenlaenge1: 500
ZeitBisDatumDruck1: 250
Servo1PositionOben1: 125
Servo1PositionUnten1: 125
Servo2Position1: 125
MitDruck1: 0
MitLuft1: 0
DruckTrockenZeit1: 0 / 0
Buzzer1: 1
Ein Schritt weiter ....
Guten Morgen
schaumall auf das Datum
2021-02-25 Jeremia
im 2021 gab es noch nicht Core 2.0.17. habe auf 2.0.1 runter gesetzt und schaue kein Reboot mehr
Und wen man alle Lib auf Stand 2021 bringt vor allem die Kritischen was arbeiten mit IRQ, Interrupt = Encoder, Stepper dann sollte das 1 A funktionieren.
Am Every musst Programmspeicher sparen.
- Kürze die Ausgabetexte insbesondere auf der Seriellen die du eh nur fürs Debuggen verwendest
- Passe den Beep Code an, mach da eine For Schleife statt den duplizierten Code-Zeilen:
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);
delay(100);
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);
delay(100);
digitalWrite(Buzzer_PIN, HIGH);
delay(100);
digitalWrite(Buzzer_PIN, LOW);- ich vermute du könntest weiteren Code sparen, wenn du die EEPROM schreiberei auf eine Struktur umbaust, dann müssten viele Zeilen wegfallen
- es gibt einige Stellen im code da sollten von einzelnen if auf switch case umgebaut werden
if (neuePositionSmallRotary == 1)oderif (altePositionSmallRotary == 1)als Beispiel - ein großer Umbau wäre das Menüsystem für das Display. Das scheint mir jedesmal komplett neu aufgebaut zu werden, das kann man sicherlich mehr generalisieren und somit Programmzeilen sparen.
Was keinen Programmspeicher spart, aber RAM, wäre die Verwendung des F-Makros auch für die Texte am Display.
Mit der IDE 1.8.19 und der ESP32-core 2.0.2 habe ich den Quellcoder hochladen können. Mein Annäherungssensor funktioniert dafür leider nicht. Die LED das ein Objekt am Sensor anliegt leuchtet die ganze Zeit
Das eigentliche Problem, das ich auch mit dem Arduino Nano hatte ist das selber. Wenn der ESP32 gestartet ist und er sich bei "Glas Auflegen" befindet, kann ich den Rotary drehen und der Stepper bewegt sich Vor und zurück. Bei einem unter Menü wo ich ihn den Rotary drehe, läuft der Motor nicht ....
Habt Ihr schon Erfahrungen mit ChatGPT, Gemini oder CoPilot beim Fehler finden im Arduino Quellcode gemacht?
Ich sitz schon den ganzen Tag am Quellcode und blick einfach nicht durch wo das Problem ist.
keine direkten Erfahrungen aber chatGPT wird hier gar nicht gerne gesehen.
chatGPT macht Wahrscheinlichkeitsrechnung. Wenn es keinen 100%-Treffer findet dann macht es eben mit 99% weiter. Aber das geht beim Programmieren nicht. Wenn die library nun mal nicht 100%tig passt dann passt es nicht.
chatGPT mal mit Fehlersuche zu beauftragen wäre aber schon interessant ob es das gebacken bekommt.
Das ist eine Beschreibung was du beobachten kannst.
Was jetzt noch dazu kommen muss ist
immer den aktuellen und kompletten Sketch posten
jede Menge serial.prints zum debuggen.
Im ESP32 haste ja genug Speicherplatz damit das geht.
Mach im Quellcode kenntlich welches Untermenü das ist.
Nur wenn man deinen kompletten aktuellen Sketch lesen kann, kann man das analysieren
Das hat bisher nach den Erfahrungen hier im Forum nicht mal bei den "Codes" von ChatGPT selbst funktioniert, wie soll das dann erst bei fremden Sketchen sein?
Der Mensch vor der Kiste kann wohl nicht die richtigen Fragen an die KI stellen.
Gruß Tommy
Ich bin ja auch sehr skeptisch und trotzdem es gibt ja mittlerweile chatGPT 4.0 und die Aufgabenstellung ist anders
Als chatGPT-prompt könnte das etwa so lauten:
Hier ist ein Code der fast vollständig funktioniert.
Im Untermenü (code-Zeilen-nummern benennen)
funktioniert folgendes nicht "........"
Behalte in den Zeilen (code-zeilen-ZAHLEN von Zeile xxx bis Zeile yyy reinschreiben) den Code genau so wie er ist
ergänze bzw. ändere nur den Code in den Zeilen ((code-zeilen-ZAHLEN reinschreiben) ,
so dass durch Drehen des Encoders auch an den Schrittmotor mit Namen "exakter-Name-des-Schrittmotor-objekts" Schrittimpulse ausgegeben werden.
Das ist schon recht präzise und an Codezeilen-Nummern gibt es rein garnichts zu interpretieren. Die Codezeilen kann man einfach durchzählen.
Ja und da wäre jetzt wirklich interessant ob chatGPT - wie der Name schon sagt -
mit dem Menschen über allgemeine Debug-Strategien chatten will oder ob die KI in der Lage ist den Fehler zu finden und zu korrigieren und eine fehlerfreie Codeversion anzuliefern.
Wenn es nicht mit dem ersten Prompt funktioniert wäre interessant weitere Prompts einzugeben und zu versuchen chatGPT auf die Sprünge zu helfen.