Hallo zusammen,
ich versuche derzeit eine PV-Nachführung zu programmieren, die vorgegebene Gradzahlen mit Hilfe von NEMA17-Motoren und TMC2209-Drivern abfährt.
Das Gute: Mein Programm läuft mit einer "geringen" Anzahl (6 Stk.) von Gradzahlen. Jedoch nicht, wenn ich meine eigentlichen Gradzahlen (32 Stk.) abfahren möchte.
Bitte nicht über die Länge dieses Beitrags wundern, ich erkläre lieber zu viel als zu wenig.
Zunächst einmal der funktionierende Code inkl. Erklärung:
Vor "void setup" binde ich meine Bibliotheken ein, defniere meine Pin-Belegung vom Driver auf dem Arduino und initialisiere globale Variablen, die ich im anschließendem Code benötige.
In "void setup" starte ich meinen seriellen Monitor und deklariere meine zuvor initialisierten Pins als Outputs.
In "void loop" lese ich Buchstaben ein, die meine zuvor deklarierten Variablen mit bestimmten Variablen initialiseren. Hier sind eigentlich nur 'w' und 'W' relevant.
Bei 'w' fahre ich an den Ausgangspunkt, an dem die Nachführung starten soll.
Bei 'W' passiert das Gleiche, nur schreibe ich diesmal nicht einzelne Variablen sondern ein Array voll.
Im Anschluss rufe ich in "void loop" zwei Funktionen auf, die ohne eine Eingabe wie "v", "w" oder "W" nicht tun, da die dort verwendeten Variablen ohne Eingabe den Wert 0 haben.
Zu den Funktionen: Zunächst haben wir die Funktionen VorschrittVPV/RueckschrittVPV. Diese führen entweder einen Schritt im Uhrzeigersinn (UZS) oder gegen den UZS an der vertikalen Achse der PV-Anlage (VPV) durch. Selbes dann nochmal für die horizontale des PV-Moduls (HPV).
Diese werden dann in "AusgangspunktPV" und "SonnenverlaufPV" aufgerufen.
/*************************
Einbinden der Bibliotheken
*************************/
#include <Arduino.h> //Für alle Arduino-sketches erforderlich
#include <TMCStepper.h> //Bibliothek für alle TMC-Stepper (Auch 2209)
/*****************************************
Pin-Belegung für den ersten Stepper-driver
*****************************************/
#define DIR_PIN_VPV A1 // Richtungssignal
#define STEP_PIN_VPV A0 // Schrittsignal
#define EN_PIN_VPV 38 // Aktivierte Motorausgänge (GND = An, VIO = Aus)
/******************************************
Pin-Belegung für den zweiten Stepper-driver
*****************************************/
#define DIR_PIN_HPV A3 // Richtungssignal
#define STEP_PIN_HPV A2 // Schrittsignal
#define EN_PIN_HPV 40 // Aktivierte Motorausgänge (GND = An, VIO = Aus)
/************************
Deklarieren der Variablen
************************/
unsigned long previousMicros = 0;
long zeit = 0;
long eineMin = 60000*1000; //Eine Minute in Mikrosekunden
long dreiMin = eineMin*3; //3 Minuten
long viertelMin = eineMin/4;
float stepVPV = 0;
float stepHPV = 0;
float stepsVPV[6];
float stepsHPV[6];
long taktVPV = 0;
long taktHPV = 0;
long takteVPV[6];
long takteHPV[6];
float gradVPV = 0;
float gradHPV = 0;
float gradeVPV[6];
float gradeHPV[6];
int iterationen = 0;
float uebersetzungVPV = 3.17;
float uebersetzungHPV = 13.83;
void setup() {
/************************
Seriellen Monitor starten
************************/
Serial.begin(115200); //Seriellen Monitor starten
Serial.println("Start....");
/**********************************
Driver-Pins als Outputs deklarieren
**********************************/
pinMode(DIR_PIN_VPV, OUTPUT);
pinMode(STEP_PIN_VPV, OUTPUT);
pinMode(EN_PIN_VPV, OUTPUT);
pinMode(DIR_PIN_HPV, OUTPUT);
pinMode(STEP_PIN_HPV, OUTPUT);
pinMode(EN_PIN_HPV, OUTPUT);
//Enable-Pins auf LOW setzen
digitalWrite(EN_PIN_VPV, LOW);
digitalWrite(EN_PIN_HPV, LOW);
}
void loop() {
char eingabe = Serial.read();
/**********************************
Eingabeparameter zur PV-Ausrichtung
**********************************/
//Ausgangspunkt Winter PV
if(eingabe == 'w')
{
zeit = viertelMin/5;
gradVPV = -30.00;
gradHPV = -60.00; //Eigentlich -52.81
stepVPV = (gradVPV/(2.8125*0.01))*uebersetzungVPV;
stepHPV = (gradHPV/(2.8125*0.01))*uebersetzungHPV;
taktVPV = (zeit/stepVPV)/2;
taktHPV = (zeit/stepHPV)/2;
}
//Von Ausgangsposition zu Ursprung
if(eingabe == 'v')
{
zeit = viertelMin/5;
gradVPV = -30.00*(-1);
gradHPV = -60.00*(-1); //Eigentlich -52.81
stepVPV = (gradVPV/(2.8125*0.01))*uebersetzungVPV;
stepHPV = (gradHPV/(2.8125*0.01))*uebersetzungHPV;
taktVPV = (zeit/stepVPV)/2;
taktHPV = (zeit/stepHPV)/2;
}
//Kleines Array abfahren
if(eingabe == 'W')
{
zeit = viertelMin/5;
float GradeVPV[] = {10.0, 10.0, 10.0, -10.0, -10.0, -10.0};
float GradeHPV[] = {20.0, 20.0, 20.0, 20.0, 20.0, 20.0};
float StepsVPV[] = {(GradeVPV[0]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[1]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[2]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[3]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[4]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[2]/(2.8125*0.01))*uebersetzungVPV,};
float StepsHPV[] = {(GradeHPV[0]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[1]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[2]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[3]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[4]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[5]/(2.8125*0.01))*uebersetzungHPV};
long TakteVPV[] = {(zeit/StepsVPV[0])/2, (zeit/StepsVPV[1])/2, (zeit/StepsVPV[2])/2, (zeit/StepsVPV[3])/2, (zeit/StepsVPV[4])/2, (zeit/StepsVPV[5])/2};
long TakteHPV[] = {(zeit/StepsHPV[0])/2, (zeit/StepsHPV[1])/2, (zeit/StepsHPV[2])/2, (zeit/StepsHPV[3])/2, (zeit/StepsHPV[4])/2, (zeit/StepsHPV[5])/2};
iterationen = (sizeof(GradeVPV)/sizeof(float));
for(int i = 0; i < iterationen; i++)
{
gradeVPV[i] = abs(GradeVPV[i]);
gradeHPV[i] = abs(GradeHPV[i]);
stepsVPV[i] = abs(StepsVPV[i]);
stepsHPV[i] = abs(StepsHPV[i]);
takteVPV[i] = abs(TakteVPV[i]);
takteHPV[i] = abs(TakteHPV[i]);
}
}
/***********************
Auszuführende Funktionen
***********************/
AusgangspunktPV();
SonnenverlaufPV();
}
/*********
Funktionen
*********/
void AusgangspunktPV()
{
unsigned long currentMicros = micros();
if(gradVPV < 0)
{
stepVPV = stepVPV*(-1);
taktVPV = taktVPV*(-1);
if (stepVPV > 0)
{
if(currentMicros - previousMicros >= taktVPV)
{
RueckschrittVPV();
previousMicros = currentMicros;
stepVPV--;
}
}
}
if(gradHPV < 0)
{
stepHPV = stepHPV*(-1);
taktHPV = taktHPV*(-1);
if (stepHPV > 0)
{
if(currentMicros - previousMicros >= taktHPV)
{
RueckschrittHPV();
previousMicros = currentMicros;
stepHPV--;
}
}
}
if(gradVPV > 0)
{
if (stepVPV > 0)
{
if(currentMicros - previousMicros >= taktVPV)
{
VorschrittVPV();
previousMicros = currentMicros;
stepVPV--;
}
}
}
if(gradHPV > 0)
{
if (stepHPV > 0)
{
if(currentMicros - previousMicros >= taktHPV)
{
VorschrittHPV();
previousMicros = currentMicros;
stepHPV--;
}
}
}
}
void VorschrittVPV()
{
digitalWrite(DIR_PIN_VPV, LOW); //Gegen den Uhrzeigersinn (UZS)
digitalWrite(STEP_PIN_VPV, HIGH);
digitalWrite(STEP_PIN_VPV, LOW);
}
void VorschrittHPV()
{
digitalWrite(DIR_PIN_HPV, LOW); //Gegen den Uhrzeigersinn (UZS)
digitalWrite(STEP_PIN_HPV, HIGH);
digitalWrite(STEP_PIN_HPV, LOW);
}
void RueckschrittVPV()
{
digitalWrite(DIR_PIN_VPV, HIGH); //UZS
digitalWrite(STEP_PIN_VPV, HIGH);
digitalWrite(STEP_PIN_VPV, LOW);
}
void RueckschrittHPV()
{
digitalWrite(DIR_PIN_HPV, HIGH); //UZS
digitalWrite(STEP_PIN_HPV, HIGH);
digitalWrite(STEP_PIN_HPV, LOW);
}
void SonnenverlaufPV()
{
unsigned long currentMicros = micros();
for(int i = 0; i < iterationen/2; i++)
{
if (stepsVPV[i] > 0)
{
if(currentMicros - previousMicros >= takteVPV[i])
{
VorschrittVPV();
previousMicros = currentMicros;
stepsVPV[i]--;
}
continue;
}
if (stepsHPV[i] > 0)
{
if(currentMicros - previousMicros >= takteHPV[i])
{
VorschrittHPV();
previousMicros = currentMicros;
stepsHPV[i]--;
}
}
}
for (int i = iterationen/2; i < iterationen; i++)
{
if (stepsVPV[i] > 0)
{
if(currentMicros - previousMicros >= takteVPV[i])
{
RueckschrittVPV();
previousMicros = currentMicros;
stepsVPV[i]--;
}
continue;
}
if (stepsHPV[i] > 0)
{
if(currentMicros - previousMicros >= takteHPV[i])
{
VorschrittHPV();
previousMicros = currentMicros;
stepsHPV[i]--;
}
}
}
}
So weit, so gut. Das Panel dreht wie gewünscht: vor, hoch, vor, hoch, vor, hoch, vor, runter, vor, runter, vor. runter.
Nun zum Problem:
Wenn ich die Werte initialisiere, die ich eigentlich verwenden, funktioniert es nicht mehr. Ich habe es bereits mehrfach neu runtergeschrieben und alles auf Fehler geprüft. Auch habe ich den funktionierenden Code genommen und einfach die Werte geändert:
/*************************
Einbinden der Bibliotheken
*************************/
#include <Arduino.h> //Für alle Arduino-sketches erforderlich
#include <TMCStepper.h> //Bibliothek für alle TMC-Stepper (Auch 2209)
/*****************************************
Pin-Belegung für den ersten Stepper-driver
*****************************************/
#define DIR_PIN_VPV A1 // Richtungssignal
#define STEP_PIN_VPV A0 // Schrittsignal
#define EN_PIN_VPV 38 // Aktivierte Motorausgänge (GND = An, VIO = Aus)
/******************************************
Pin-Belegung für den zweiten Stepper-driver
*****************************************/
#define DIR_PIN_HPV A3 // Richtungssignal
#define STEP_PIN_HPV A2 // Schrittsignal
#define EN_PIN_HPV 40 // Aktivierte Motorausgänge (GND = An, VIO = Aus)
/************************
Deklarieren der Variablen
************************/
unsigned long previousMicros = 0;
long zeit = 0;
long eineMin = 60000*1000; //Eine Minute in Mikrosekunden
long dreiMin = eineMin*3; //3 Minuten
long viertelMin = eineMin/4;
float stepVPV = 0;
float stepHPV = 0;
float stepsVPV[32];
float stepsHPV[32];
long taktVPV = 0;
long taktHPV = 0;
long takteVPV[32];
long takteHPV[32];
float gradVPV = 0;
float gradHPV = 0;
float gradeVPV[32];
float gradeHPV[32];
int iterationen = 0;
float uebersetzungVPV = 3.17;
float uebersetzungHPV = 13.83; //Check, alles richtig
void setup() { //Check, alles richtig
/************************
Seriellen Monitor starten
************************/
Serial.begin(115200); //Seriellen Monitor starten
Serial.println("Start....");
/**********************************
Driver-Pins als Outputs deklarieren
**********************************/
pinMode(DIR_PIN_VPV, OUTPUT);
pinMode(STEP_PIN_VPV, OUTPUT);
pinMode(EN_PIN_VPV, OUTPUT);
pinMode(DIR_PIN_HPV, OUTPUT);
pinMode(STEP_PIN_HPV, OUTPUT);
pinMode(EN_PIN_HPV, OUTPUT);
//Enable-Pins auf LOW setzen
digitalWrite(EN_PIN_VPV, LOW);
digitalWrite(EN_PIN_HPV, LOW);
}
void loop() {
char eingabe = Serial.read();
/**********************************
Eingabeparameter zur PV-Ausrichtung
**********************************/
//Ausgangspunkt Winter PV
if(eingabe == 'w')
{
zeit = viertelMin/5;
gradVPV = 30.00;
gradHPV = 52.81;
stepVPV = (gradVPV/(2.8125*0.01))*uebersetzungVPV;
stepHPV = (gradHPV/(2.8125*0.01))*uebersetzungHPV;
taktVPV = (zeit/stepVPV)/2;
taktHPV = (zeit/stepHPV)/2;
}
//Von Ausgangsposition zu Ursprung
if(eingabe == 'v')
{
zeit = viertelMin/5;
gradVPV = 30.00*(-1);
gradHPV = 60.00*(-1); //Eigentlich -52.81
stepVPV = (gradVPV/(2.8125*0.01))*uebersetzungVPV;
stepHPV = (gradHPV/(2.8125*0.01))*uebersetzungHPV;
taktVPV = (zeit/stepVPV)/2;
taktHPV = (zeit/stepHPV)/2;
}
//Gradzahlen Wintersonnenwende abfahren
if(eingabe == 'W')
{
zeit = viertelMin/5;
float GradeVPV[] = {1.55, 1.59, 1.60, 1.54, 1.46, 1.36, 1.27, 1.15, 1.04, 0.91, 0.78, 0.65, 0.51,
0.37, 0.23, 0.08, -0.06, -0.21, -0.35, -0.49, -0.63, -0.77, -0.90, -1.01, //Bis zum 16ten Wert positiv
-1.14, -1.25, -1.36, -1.44, -1.53, -1.59, -1.60, -1.55};
float GradeHPV[] = {2.91, 2.96, 3.01, 3.06, 3.12, 3.18, 3.23, 3.29, 3.34, 3.39, 3.44, 3.47, 3.52,
3.53, 3.56, 3.56, 3.57, 3.55, 3.54, 3.52, 3.48, 3.44, 3.40, 3.35, 3.29, 3.24,
3.19, 3.12, 3.08, 3.01, 2.97, 2.91};
float StepsVPV[] = {(GradeVPV[0]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[1]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[2]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[3]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[4]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[5]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[6]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[7]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[8]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[9]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[10]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[11]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[12]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[13]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[14]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[15]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[16]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[17]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[18]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[19]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[20]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[21]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[22]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[23]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[24]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[25]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[26]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[27]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[28]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[29]/(2.8125*0.01))*uebersetzungVPV,
(GradeVPV[30]/(2.8125*0.01))*uebersetzungVPV, (GradeVPV[31]/(2.8125*0.01))*uebersetzungVPV};//Check, alles richtig
float StepsHPV[] = {(GradeHPV[0]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[1]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[2]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[3]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[4]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[5]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[6]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[7]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[8]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[9]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[10]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[11]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[12]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[13]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[14]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[15]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[16]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[17]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[18]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[19]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[20]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[21]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[22]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[23]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[24]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[25]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[26]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[27]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[28]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[29]/(2.8125*0.01))*uebersetzungHPV,
(GradeHPV[30]/(2.8125*0.01))*uebersetzungHPV, (GradeHPV[31]/(2.8125*0.01))*uebersetzungHPV};//Check, alles richtig
long TakteVPV[] = {(zeit/StepsVPV[0])/2, (zeit/StepsVPV[1])/2, (zeit/StepsVPV[2])/2, (zeit/StepsVPV[3])/2, (zeit/StepsVPV[4])/2, (zeit/StepsVPV[5])/2,
(zeit/StepsVPV[6])/2, (zeit/StepsVPV[7])/2, (zeit/StepsVPV[8])/2, (zeit/StepsVPV[9])/2, (zeit/StepsVPV[10])/2, (zeit/StepsVPV[11])/2,
(zeit/StepsVPV[12])/2, (zeit/StepsVPV[13])/2, (zeit/StepsVPV[14])/2, (zeit/StepsVPV[15])/2, (zeit/StepsVPV[16])/2, (zeit/StepsVPV[17])/2,
(zeit/StepsVPV[18])/2, (zeit/StepsVPV[19])/2, (zeit/StepsVPV[20])/2, (zeit/StepsVPV[21])/2, (zeit/StepsVPV[22])/2, (zeit/StepsVPV[23])/2,
(zeit/StepsVPV[24])/2, (zeit/StepsVPV[25])/2, (zeit/StepsVPV[26])/2, (zeit/StepsVPV[27])/2, (zeit/StepsVPV[28])/2, (zeit/StepsVPV[29])/2,
(zeit/StepsVPV[30])/2, (zeit/StepsVPV[31])/2}; //Check, alles richtig
long TakteHPV[] = {(zeit/StepsHPV[0])/2, (zeit/StepsHPV[1])/2, (zeit/StepsHPV[2])/2, (zeit/StepsHPV[3])/2, (zeit/StepsHPV[4])/2, (zeit/StepsHPV[5])/2,
(zeit/StepsHPV[6])/2, (zeit/StepsHPV[7])/2, (zeit/StepsHPV[8])/2, (zeit/StepsHPV[9])/2, (zeit/StepsHPV[10])/2, (zeit/StepsHPV[11])/2,
(zeit/StepsHPV[12])/2, (zeit/StepsHPV[13])/2, (zeit/StepsHPV[14])/2, (zeit/StepsHPV[15])/2, (zeit/StepsHPV[16])/2, (zeit/StepsHPV[17])/2,
(zeit/StepsHPV[18])/2, (zeit/StepsHPV[19])/2, (zeit/StepsHPV[20])/2, (zeit/StepsHPV[21])/2, (zeit/StepsHPV[22])/2, (zeit/StepsHPV[23])/2,
(zeit/StepsHPV[24])/2, (zeit/StepsHPV[25])/2, (zeit/StepsHPV[26])/2, (zeit/StepsHPV[27])/2, (zeit/StepsHPV[28])/2, (zeit/StepsHPV[29])/2,
(zeit/StepsHPV[30])/2, (zeit/StepsHPV[31])/2}; //Check, alles richtig
iterationen = (sizeof(GradeVPV)/sizeof(float)); //32
for(int i = 0; i < iterationen; i++) //////////Hier wird alles richtig berechnet
{
gradeVPV[i] = abs(GradeVPV[i]);
gradeHPV[i] = abs(GradeHPV[i]);
stepsVPV[i] = abs(StepsVPV[i]);
stepsHPV[i] = abs(StepsHPV[i]);
takteVPV[i] = abs(TakteVPV[i]);
takteHPV[i] = abs(TakteHPV[i]);
}
}
/***********************
Auszuführende Funktionen
***********************/
ausgangspunktPV();
sonnenverlaufPV();
}
/*********
Funktionen
*********/
void vorschrittVPV()
{
digitalWrite(DIR_PIN_VPV, LOW); //UZS
digitalWrite(STEP_PIN_VPV, HIGH);
digitalWrite(STEP_PIN_VPV, LOW);
}
void vorschrittHPV()
{
digitalWrite(DIR_PIN_HPV, LOW); //UZS
digitalWrite(STEP_PIN_HPV, HIGH);
digitalWrite(STEP_PIN_HPV, LOW);
}
void rueckschrittVPV()
{
digitalWrite(DIR_PIN_VPV, HIGH); //Gegen den Uhrzeigersinn (UZS)
digitalWrite(STEP_PIN_VPV, HIGH);
digitalWrite(STEP_PIN_VPV, LOW);
}
void rueckschrittHPV()
{
digitalWrite(DIR_PIN_HPV, HIGH); //Gegen den Uhrzeigersinn (UZS)
digitalWrite(STEP_PIN_HPV, HIGH);
digitalWrite(STEP_PIN_HPV, LOW);
}
void ausgangspunktPV()
{
unsigned long currentMicros = micros();
if(gradVPV < 0)
{
stepVPV = stepVPV*(-1);
taktVPV = taktVPV*(-1);
if (stepVPV > 0)
{
if(currentMicros - previousMicros >= taktVPV)
{
vorschrittVPV();
previousMicros = currentMicros;
stepVPV--;
}
}
}
if(gradHPV < 0)
{
stepHPV = stepHPV*(-1);
taktHPV = taktHPV*(-1);
if (stepHPV > 0)
{
if(currentMicros - previousMicros >= taktHPV)
{
vorschrittHPV();
previousMicros = currentMicros;
stepHPV--;
}
}
}
if(gradVPV > 0)
{
if (stepVPV > 0)
{
if(currentMicros - previousMicros >= taktVPV)
{
rueckschrittVPV();
previousMicros = currentMicros;
stepVPV--;
}
}
}
if(gradHPV > 0)
{
if (stepHPV > 0)
{
if(currentMicros - previousMicros >= taktHPV)
{
rueckschrittHPV();
previousMicros = currentMicros;
stepHPV--;
}
}
}
}
void sonnenverlaufPV() //check, alles richtig
{
unsigned long currentMicros = micros();
for(int i = 0; i < iterationen/2; i++)
{
if (stepsVPV[i] > 0)
{
if(currentMicros - previousMicros >= takteVPV[i])
{
vorschrittVPV();
previousMicros = currentMicros;
stepsVPV[i]--;
}
continue;
}
if (stepsHPV[i] > 0)
{
if(currentMicros - previousMicros >= takteHPV[i])
{
vorschrittHPV();
previousMicros = currentMicros;
stepsHPV[i]--;
}
}
}
for (int i = iterationen/2; i < iterationen; i++)
{
if (stepsVPV[i] > 0)
{
if(currentMicros - previousMicros >= takteVPV[i])
{
rueckschrittVPV();
previousMicros = currentMicros;
stepsVPV[i]--;
}
continue;
}
if (stepsHPV[i] > 0)
{
if(currentMicros - previousMicros >= takteHPV[i])
{
vorschrittHPV();
previousMicros = currentMicros;
stepsHPV[i]--;
}
}
}
} //Check, alles richtig
Wenn ich diesen Code ausführe, passiert folgendes:
vor, hoch, vor, hoch, vor, runter, vor, hoch, vor, runter, vor, hoch, usw.
Ich habe alles doppelt und dreifach auf richtige Schreibweise überprüft und weiß leider nicht mehr weiter.
Ich hoffe, dass mir jemand von euch weiterhelfen kann.
Beste Grüße