// spezielle debug-Tools dein Code steht ab ca Zeile 45
// MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START *
// a detailed explanation how these macros work is given in this tutorial
// https://forum.arduino.cc/t/comfortable-serial-debug-output-short-to-write-fixed-text-name-and-content-of-any-variable-code-example/888298
// # define A0 14
#define dbg(myFixedText, variableName) \
Serial.print( F(#myFixedText " " #variableName"=") ); \
Serial.println(variableName);
#define dbgi(myFixedText, variableName,timeInterval) \
{ \
static unsigned long intervalStartTime; \
if ( millis() - intervalStartTime >= timeInterval ){ \
intervalStartTime = millis(); \
Serial.print( F(#myFixedText " " #variableName"=") ); \
Serial.println(variableName); \
} \
}
#define dbgc(myFixedText, variableName) \
{ \
static long lastState; \
if ( lastState != variableName ){ \
Serial.print( F(#myFixedText " " #variableName" changed from ") ); \
Serial.print(lastState); \
Serial.print( F(" to ") ); \
Serial.println(variableName); \
lastState = variableName; \
} \
}
#define dbgcf(myFixedText, variableName) \
{ \
static float lastState; \
if ( lastState != variableName ){ \
Serial.print( F(#myFixedText " " #variableName" changed from ") ); \
Serial.print(lastState); \
Serial.print( F(" to ") ); \
Serial.println(variableName); \
lastState = variableName; \
} \
}
// MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END *
#include <MobaTools.h>
// int schritte_def = 200; //wieviele schritte pro umdrehung 1,8° pro Schritt
// Stepper motor(schritte_def, pinDir_A, pinDir_B); //brauche ich diese ZEile?
const int STEPS_UMDREHUNG = 200;
MoToStepper myStepper( STEPS_UMDREHUNG, STEPDIR );
//Taster
const int duenn = 8;
const int endschalter = 9;
const int dick = 10;
const int start = 11;
const int mittel = 12;
const int zwick = 13;
//Motor TB6600
const byte dirPin = 5;
const byte stepPin = 4;
const byte enaPin = 6;
//variable für Taster damit man weiß dass es normalerweise low ist
int switchStateStart = 1;
int switchStateZwick = 1;
int switchStateStopp = 1;
int switchStateDuenn = 1;
int switchStateMittel = 1;
int switchStateDick = 1;
int switchStateEndschalter = 1; //der ENdschalter ist in echt ein öffner weil er defekt ist und ich noch einen neuen bestellen muss
int modusduenn = 1;
int modusmittel = 1;
int modusdick = 1;
int SchrittAnzahl = 1;
int i = 0; // damit ich den Taster zählen kann
int t = 0;
byte SchrittNr;
bool referenzErreicht = false;
// 1234567890123456789
const byte Moduswahl = 0;
const byte Startanfahren = 1;
const byte warte_start_zwicke = 2;
const byte Fingererkennen = 3;
const byte Fingererneut = 4;
// const byte Stopp = 5;
const byte Referenzfahrt = 6;
const byte losgelassen = HIGH;
const byte gedrueckt = LOW;
// array mit den Namen der cases gleiche Reihenfolge
// => die Indexnummer des Arrays entspricht der SchrittNr
// => kompakter Code zum Ausgeben der case-namen
const char stateName[][24] = {
"Moduswahl", // array-element 0
"Startanfahren", // array-element 1
"warte_start_zwicke", // array-element 2
"Fingererkennen", // array-element 3
"Fingererneut", // array-element 4
"Stopp", // array-element 5
"Referenzfahrt" // array-element 6
};
void setup() {
Serial.begin(115200);
Serial.print("Setup-Start");
PrintFileNameDateTime();
// motor.setSpeed(50);
// digitalWrite(pinPWM_A, HIGH); //warum muss A und B high sein?
// digitalWrite(pinPWM_B, HIGH);
pinMode(zwick, INPUT_PULLUP);
pinMode(start, INPUT_PULLUP);
// pinMode(stopp, INPUT_PULLUP);
pinMode(duenn, INPUT_PULLUP);
pinMode(mittel, INPUT_PULLUP);
pinMode(dick, INPUT_PULLUP);
pinMode(endschalter, INPUT_PULLUP);
//Motor pins
pinMode(enaPin, OUTPUT);
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
digitalWrite(enaPin, HIGH);
//Treiberaktivieren -> LOW aktiviert ihn
digitalWrite(enaPin, LOW);
SchrittNr = Moduswahl;
Serial.println("Warte auf Moduswahl");
}
void TasterEinlesen() {
// dbgc: NUR wenn sich der Wert der Variablen GEÄNDERT hat
// dann EINMAL ausgeben (aber NICHT dauernd)
switchStateDuenn = digitalRead(duenn);
dbgc("01", switchStateDuenn);
switchStateMittel = digitalRead(mittel);
dbgc("02", switchStateMittel);
switchStateDick = digitalRead(dick);
dbgc("03", switchStateDick);
switchStateStart = digitalRead(start);
dbgc("04", switchStateStart);
switchStateZwick = digitalRead(zwick);
dbgc("05", switchStateZwick);
switchStateEndschalter = digitalRead(endschalter);
dbgc("06", switchStateEndschalter);
// switchStateStopp = digitalRead(stopp);
// dbgc("07", switchStateStopp);
}
void myStateMachine() {
printIfStateChanged(SchrittNr); // wenn sich die SchrittNr geändert hat dann einmal ausgeben
switch (SchrittNr) {
case Moduswahl:
// einmal alle auf losgelassen setzen
modusduenn = losgelassen;
modusmittel = losgelassen;
modusdick = losgelassen;
if (switchStateDuenn == gedrueckt) { //um die Tasten zu merken und den Modus gewählt zu halten
modusduenn = gedrueckt;
SchrittAnzahl = 600;
Serial.println("Modus dünn");
modusmittel = losgelassen;
modusdick = losgelassen;
SchrittNr = Startanfahren;
}
if (switchStateMittel == gedrueckt) {
modusmittel = gedrueckt;
SchrittAnzahl = 500;
Serial.println("Modus mittel");
modusduenn = losgelassen;
modusdick = losgelassen;
SchrittNr = Startanfahren;
}
if (switchStateDick == gedrueckt) {
modusdick = gedrueckt;
SchrittAnzahl = 400;
Serial.println("Modus dick");
modusduenn = losgelassen;
modusmittel = losgelassen;
SchrittNr = Startanfahren;
}
// am Ende einmal SchrittNr setzen
break;
case Startanfahren:
if (switchStateEndschalter == losgelassen) {
SchrittNr = Referenzfahrt;
}
if (switchStateStart == gedrueckt && switchStateEndschalter == gedrueckt) {
delay(250);
digitalWrite(dirPin, HIGH); //Richtung festlegen-> HIGH vorwärts
for (int d=0; d<SchrittAnzahl; d++){ //so sollte sich der Motor um die Schrittzahl drehen
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000); //das regelt die Geschwindigkeit
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
// motor.step(SchrittAnzahl);
Serial.println("Motordreht runter");
SchrittNr = warte_start_zwicke;
}
break;
case warte_start_zwicke:
if (switchStateStart == gedrueckt && switchStateZwick == gedrueckt) {
digitalWrite(dirPin, HIGH);
for (int d=0; d<1000-SchrittAnzahl; d++){ //so sollte sich der Motor um die Schrittzahl drehen
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
// motor.step(1000 - SchrittAnzahl);
Serial.println("Motordreht runter");
delay(50);
digitalWrite(dirPin, LOW);
for (int d=0; d<1000+SchrittAnzahl; d++){ //so sollte sich der Motor um die Schrittzahl drehen
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
// motor.step(-1000 + SchrittAnzahl);
Serial.println("Motordreht rauf");
delay(250);// kann ich so mein problem von unten beheben??
SchrittNr = Fingererkennen;
}
// if (switchStateStart==losgelassen){ //ich hätte gerne dass wenn der Finger vom Sensor genommen wird, der Motor wieder neu anfahren muss. muss ich zu "startanfahren" oder muss ich zu " referenzfahrt"
// SchrittNr = Fingererkennen;
// } das Funktioniert leider nicht so wie ich es geplant hatte
break;
case Fingererkennen:
if (switchStateStart == losgelassen) {
SchrittNr = Referenzfahrt;
}
if (switchStateStart == gedrueckt) {
SchrittNr = warte_start_zwicke;
}
break;
// case Stopp: //das Funktioniert leider auch nicht weil er so wie ich vermute noch in einem Schritt festhängt?
// if (switchStateStopp == gedrueckt) {
// motor.step(0);
// Serial.println("Motorstopp");
// SchrittNr = Referenzfahrt; // hier wäre es interessant dass man einen neuen Modus wählen kann. Daumennagel sind meist dicker als kleine Finger nägel.
// }
// break;
case Referenzfahrt:
if (switchStateEndschalter == losgelassen) {
// nur einen Schritt bei hundert Schritten rammelt der Schrittmotor gegen den mechanischen Anschlag
// macht einem Schrittmotor nix aber ist unschön
digitalWrite(dirPin, LOW);
for (int d=0; d<1; d++){ //so sollte sich der Motor um die Schrittzahl drehen
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
// motor.step(-1);
Serial.println("Motordreht 1schrittrauf");
switchStateEndschalter = digitalRead(endschalter);
if (switchStateEndschalter == gedrueckt) {
// motor.step (0); null Schritte ausgeben = nix ausgeben es sei denn du willst vom Schalter herunter fahren
// das er nicht mehr geschaltet ist
SchrittNr = Startanfahren;
}
}
break;
}
}
void printIfStateChanged(byte actualState) {
static byte lastState;
if (lastState != actualState) { // wenn sich die SchrittNr geändert hat dann einmal ausgeben
Serial.print("state changed from ");
Serial.print(stateName[lastState]);
Serial.print(" to ");
Serial.print(stateName[actualState]);
Serial.println();
// update lastState => wird erst dann wieder ausgegeben wenn sich die
// SchrittNr wieder geändert hat
lastState = actualState;
}
}
void loop() { //schreib ich hier statt loop stateMachine? das habe ich im Internet gefunden?
TasterEinlesen();
myStateMachine();
}
// helper-functions
void PrintFileNameDateTime() {
Serial.println( F("Code running comes from file ") );
Serial.println( F(__FILE__) );
Serial.print( F(" compiled ") );
Serial.print( F(__DATE__) );
Serial.print( F(" ") );
Serial.println( F(__TIME__) );
}