INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Motorsteuerung
08.02.2021, 17:34 (Dieser Beitrag wurde zuletzt bearbeitet: 08.02.2021 17:35 von MicroBahner.)
Beitrag #9
RE: Motorsteuerung
Wenn Du Code postest, dann setze den bitte in Codetags (das '#' oben rechts im Editor anklicken - Code einfügen - dann '#' nochmal anklicken ). Wenn Du Code aus der IDE einfügst, kannst Du auch direkt mit der rechten Maustaste in das Codefeld klicken, und im Pop-Up Menu 'Für Forum kopieren' auswählen. Dann sind die Codetags schon dabei.

'noInterrupts' in der ISR zu setzen macht keinen Sinn, da sind die Interrupts eh schon gesperrt. Beim atomaren Auslesen geht es darum, wenn Du im normalen Programmablauf auf Variable zugreifst, die in der ISR verändert werden. Dann musst Du vorher noInterrupts() und hinterher interrupts() einfügen.
N.B. Serial.print in einer ISR ist eine sehr schlechte Idee, das kann dir gegebenenfalls deinen ganzen Sketch blockieren.

Wenn die ISR mehrfach auslöst, dann hast Du auch mehrfache Flanken am Eingang. Das kann auch bei einer Lichtschranke passieren, wenn die Lochblende z.B. keine ganz exakten und sauberen Löcher hat. Die ISR ist sehr schnell. Evtl. kannst Du das LS-Signal auch mit einem RC GLied glätten. Aber Du darfst dir natürlich nicht auch die gewollten Flanken rausfiltern Wink .
Oder Du musst es per Software machen: Die Zeit zwischen 2 Interrupts messen, und wenn die zu schnell kommen, dann ignorieren.
Welche Zeiten hast Du den eigentlich zwischen 2 korrekten Flanken bei maximaler Motordrehzahl?

Gruß, Franz-Peter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
08.02.2021, 17:35
Beitrag #10
RE: Motorsteuerung
Ahhh danke,
jetzt verstehe ich was du da bauen willst. :-)

Franz

https://www.youtube.com/watch?v=Fnzn85oWM_Q
Hier was zum Thema Deutsche Politik Angry
Und hier zum Thema richtige Politik Big Grin
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
08.02.2021, 18:41
Beitrag #11
RE: Motorsteuerung
OK. Ich hab einfach nur im Feld "Schnellantwort" geantwortet.
Da gibt es wenig Möglichkeiten.
Der Getriebemotor hat vor der Schnecke ca. 30 U/min. Die Lochscheibe hat 40 Löcher. Also ca. 50 ms. zwischen zwei korrekten Flanken.
Ich versuche das mal per Software raus zu bekommen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.02.2021, 11:39
Beitrag #12
RE: Motorsteuerung
Vielen Dank an alle.
Es funktioniert mit der Softwarelösung. Es reichen wirklich 5 ms um die unerwünschten Flanken raus zu bekommen.
Hätte ich nicht gedacht, dass das Ding so schnell ist.
Ein kleines Problem gibt es noch, mit dem ich aber leben kann. Egal welchen Modus ich im attachInt... verwende, wird immer bei beiden Flanke aus/ein der Interrupt ausgelöst. Aber wie gesagt, kann ich damit leben.
Aber ich glaube, ich werde für diese Funktion einen zusätzlichen Arduino Mini bereitstellen, weil das Zeitverhalten des Mega 2650 jetzt schon grenzwertig ist.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.02.2021, 12:04
Beitrag #13
RE: Motorsteuerung
(09.02.2021 11:39)othello schrieb:  Egal welchen Modus ich im attachInt... verwende, wird immer bei beiden Flanke aus/ein der Interrupt ausgelöst.
Das liegt daran, dass durch das 'Prellen' deiner LS sowohl bein Ein- als auch beim Ausschalten positive und negative Flanken erzeugt werden. Sonst bräuchtest Du ja auch nicht filtern.

(09.02.2021 11:39)othello schrieb:  Aber ich glaube, ich werde für diese Funktion einen zusätzlichen Arduino Mini bereitstellen, weil das Zeitverhalten des Mega 2650 jetzt schon grenzwertig ist.
Woran erkennst Du das? Ich kann mir nicht vorstellen, dass ein Mega damit großartig belastet ist. Zeig mal deinen aktuellen Sketch ( Die Codetags nicht vergessen Wink ).

Gruß, Franz-Peter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.02.2021, 15:36
Beitrag #14
RE: Motorsteuerung
Doch, der Code ist schon sehr umfangreich.
Zeitkritisch ist aber vor allem der IR-Empfänger.
Der bekommt von der Fernbedienung beim drücken einer Taste alle 100 ms mittgeteilt, dass die Taste noch gedrückt ist (PIN 2). Beim loslassen der Taste müssen die Motoren schnellstmöglich stoppen. Das ist dringend Notwendig, zumindest so lange bis die Berührungs- und Abstandssensoren in Betrieb sind.
Ich habe auf dem Board auf der einen Seite sowieso schon einen zusätzlichen Mini Pro, der für das Standby verantwortlich ist. Dies ist notwendig, da der Lift mit Batterien betrieben wird. Dieser kann auf der einen Seite dann auch noch als Schrittzähler benutzt werden. Später wird der eventuell auch noch das autonivilieren übernehmen.
Auf der Gegenseite sind auf dem Board nur die Motortreiber. Da würde ich aber auch noch einen Mini Pro einsetzen. Der kann dann den Schrittzähler und eventuell den zweiten Beschleunigungssensor GY-521 übernehmen.
Ein weiterer Mini Pro wird auf der Plattform für die Sensoren benötigt (erst in Planung).
Alle Boards mit KiCAD erstellt.
Eigentlich wollte ich nach einem Jahr Bauzeit fertig sein. Aber dauert noch.


Code:
// LCD-Anzeige
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x27,20,3); // LCD2002

// Beschleunigungssensor Rahmen
const int xpin = A0; // x-Achse des Beschleunigungsmessers
const int ypin = A1; // y-Achse
const int zpin = A2; // Z-Achse (nur bei 3-Achsen-Modellen)
unsigned long motorenwartezeit = 0;
unsigned long motorenstartzeit = 0;
int xp = 0;
int yp = 0;
int zp = 0;
int p = 0;
int automatik = 0;
long tastentimer;
int x_zero = 345;
int y_zero = 335;
int z_zero = 337;
long ytimer = (millis()/1000);
long xtimer = (millis()/1000);
int x;
int y;
int yi;
int z;
//Ende

// Beschleunigungssensor Plattform
const int Plattform_xpin = A3; // x-Achse des Beschleunigungsmessers
const int Plattform_ypin = A4; // y-Achse
const int Plattform_zpin = A5; // Z-Achse (nur bei 3-Achsen-Modellen)
unsigned long Plattform_motorenwartezeit = 0;
unsigned long Plattform_motorenstartzeit = 0;
//Ende


// Variablen für die auto. Abschaltung
#include <avr/sleep.h>
int lcdaus = 0;
int Standbyein = 10;   //Standby einschalten mit D7
int Standbyaus = 7;    //Standby ausschalten mit D10
int abschalten = 12;      //Steuerung komplett abschalten mit D12
unsigned long aktuellems = 0;
unsigned long neuems = 0;
unsigned long Standbyzeit = 300000;
unsigned long Abschaltzeit = 305000;
int plus5V = 53;

// IR-Fernbedienung
#include "IRLremote.h"
#define pinIR 2
CNec IRLremote;
int Pulse_Width = 0;
int ir_code = 0x00;
char  adrL_code = 0x00;
char  adrH_code = 0x00;
String adresse;
int mini_mega = 13;


// Motorenkontrolle

int Niveaumotor = 0;  //Voreinstellung auf Hubmotoren
int Hubmotor = 1;     //           "             "
int LiftBox = 0;
int motoran = 0;
int einaus = 0;
int SetUp = 0;

int Richtung = 1; //1 = auf, 0 = ab
int RichtungLV = 1; //1 = auf, 0 = ab
int RichtungLH = 1; //1 = auf, 0 = ab
int RichtungRV = 1; //1 = auf, 0 = ab
int RichtungRH = 1; //1 = auf, 0 = ab
int state;
String richt = "aufwaerts";
String Mode = "Hub";
int Modeschalter = 0;
String Nivmotorwahl = "alle";
float Hubspeed = 255;
int TEST = 0;
unsigned long Niveauanzeige = 0;
int motoranlV = 0;
int motoranlH = 0;
int motoranrV = 0;
int motoranrH = 0;
long anzeige = millis();
String LVrichtung;
String LHrichtung;
String RVrichtung;
String RHrichtung;


//Niveau-Motor-Steuerung links Vorne
int MotlVoben        = 29;           // Nivelliermotor links Vorne oberer Anschlag (Vertausch bei
int MotlVunten       = 28;           //                            unterer Anschlag  linksmontage)
int MotspeedlV       = 9;            //                            Geschwindigkeit PWM
int MotsleeplV       = 26;           //                            Strommsparfunktion
int MotdirlV         = 27;           //                            Drehrichtung
int MotlVStrom       = A15;          //                            Strommessung
int MotlVobenstate = 0;
int MotlVuntenstate = 0;
float MotlVStromvalue = 0;

//Niveau-Motor-Steuerung links Hinten
int MotlHoben        = 34;           // Nivelliermotor links Hinten oberer Anschlag  
int MotlHunten       = 33;           //                             unterer Anschlag
int MotspeedlH       = 8;            //                             Geschwindigkeit PWM
int MotsleeplH       = 31;           //                             Strommsparfunktion  
int MotdirlH         = 32;           //                             Drehrichtung  
int MotlHStrom       = A14;          //                             Strommessung  
int MotlHobenstate = 0;
int MotlHuntenstate = 0;
float MotlHStromvalue = 0;

//Niveau-Motor-Steuerung rechts Vorne
int MotrVoben        = 41;           // Nivelliermotor rechts Vorne oberer Anschlag
int MotrVunten       = 42;           //                            unterer Anschlag
int MotspeedrV       = 4;            //                            Geschwindigkeit PWM
int MotsleeprV       = 39;           //                            Strommsparfunktion
int MotdirrV         = 40;           //                            Drehrichtung
int MotrVStrom       = A13;          //                            Strommessung
int MotrVobenstate = 0;
int MotrVuntenstate = 0;
float MotrVStromvalue = 0;

//Niveau-Motor-Steuerung rechts Hinten
int MotrHoben        = 45;           // Nivelliermotor rechts Hinten oberer Anschlag  (Vertauscht bei
int MotrHunten       = 44;           //                             unterer Anschlag   linksmontage)
int MotspeedrH       = 5;            //                             Geschwindigkeit PWM
int MotsleeprH       = 46;           //                             Strommsparfunktion  
int MotdirrH         = 47;           //                             Drehrichtung  
int MotrHStrom       = A12;          //                             Strommessung  
int MotrHobenstate = 0;
int MotrHuntenstate = 0;
float MotrHStromvalue = 0;

//Hub-Motor-Steuerung Links
int HubMotspeedL     = 11;            //                            Geschwindigkeit PWM
int HubMotsleepL     = 24;           //                             Strommsparfunktion  
int HubMotdirL       = 23;           //                             Drehrichtung  
int HubMotLStrom     = A11;          //                             Strommessung  
float HubMotLStromValue = 0;


//Hub-Motor-Steuerung Rechts
int HubMotspeedR     = 6;            //                            Geschwindigkeit PWM
int HubMotsleepR     = 37;           //                             Strommsparfunktion  
int HubMotdirR       = 36;           //                             Drehrichtung  
int HubMotRStrom     = A10;          //                             Strommessung  
float HubMotRStromValue = 0;

//  Wird vom Plattformprozessor übernommen
// Berührungssensor für automatischen Stop oben und unten
int BSlV             = 52;
int BSlVvalue        = 1;
int BSrV             = 51;
int BSrVvalue        = 1;
int BSlH             = 50;
int BSlHvalue        = 1;
int BSrH             = 49;
int BSrHvalue        = 1;


// Batterieladefunktion
int Batrechts_ein    = 49;
int Batrechts_aus    = 50;
int Batlinks_ein     = 51;
int Batlinks_aus     = 52;
int Batterie_R = A8;
int Batterie_L = A9;
float Batspg_R;
float Batspg_L;



// Hubmotorsynchronisation
const byte Schritt_Rechts_Int = 18;
const byte Schritt_Links_Int = 19;
volatile int Schrittanzahl_R = 1;
volatile int Schrittanzahl_L = 1;
int Schrittdiff = 0;
int SpeedR = 0;
int SpeedL = 0;
int sp = 0;
int synchfaktor = 100;  //zwischen 0 und 100% dämpft die Synchronisation
String daempfer = "";
int anzahlR = 0;
int anzahlL = 0;
int zahlR = 0;
int zahlL = 0;
long wartenIntL = millis();
long wartenIntR = millis();

void setup()
{
  Serial.begin(9600);
  Serial.flush();
  pinMode(pinIR, INPUT_PULLUP);
  if (!IRLremote.begin(pinIR))
    Serial.println(F("You did not choose a valid pin."));
  delay(100);

  pinMode(abschalten, OUTPUT);
  digitalWrite(abschalten, LOW);
  pinMode(Standbyein, OUTPUT);
  pinMode(Standbyaus, OUTPUT);
  digitalWrite(Standbyein, LOW);
  digitalWrite(Standbyaus, HIGH);
  delay(100);
  digitalWrite(Standbyaus, LOW);
  pinMode(plus5V, INPUT);
  pinMode(mini_mega, INPUT);


//Niveau-Motor-Steuerung vorne Links
  pinMode(MotdirlV, OUTPUT);
  pinMode(MotspeedlV, OUTPUT);
  pinMode(MotsleeplV, OUTPUT);
  pinMode(MotlVoben, INPUT_PULLUP);
  pinMode(MotlVunten, INPUT_PULLUP);
  if (TEST == 1)
  {
    pinMode(MotlVoben, OUTPUT);
    pinMode(MotlVunten, OUTPUT);
  }

//Niveau-Motor-Steuerung hinten Links
  pinMode(MotdirlH, OUTPUT);
  pinMode(MotspeedlH, OUTPUT);
  pinMode(MotsleeplH, OUTPUT);
  pinMode(MotlHoben, INPUT_PULLUP);
  pinMode(MotlHunten, INPUT_PULLUP);
  if (TEST == 1)
  {
    pinMode(MotlHoben, OUTPUT);
    pinMode(MotlHunten, OUTPUT);
  }

//Niveau-Motor-Steuerung hinten Rechts
  pinMode(MotdirrH, OUTPUT);
  pinMode(MotspeedrH, OUTPUT);
  pinMode(MotsleeprH, OUTPUT);
  pinMode(MotrHoben, INPUT_PULLUP);
  pinMode(MotrHunten, INPUT_PULLUP);
  if (TEST == 1)
  {
    pinMode(MotrHoben, OUTPUT);
    pinMode(MotrHunten, OUTPUT);
  }

  //Niveau-Motor-Steuerung vorne Rechts
  pinMode(MotdirrV, OUTPUT);
  pinMode(MotspeedrV, OUTPUT);
  pinMode(MotsleeprV, OUTPUT);
  pinMode(MotrVoben, INPUT_PULLUP);
  pinMode(MotrVunten, INPUT_PULLUP);
  if (TEST == 1)
  {
    pinMode(MotrVoben, OUTPUT);
    pinMode(MotrVunten, OUTPUT);
  }

  // Hub-Motor-Steuerung
  // Links
  pinMode(HubMotdirL, OUTPUT);
  pinMode(HubMotspeedL, OUTPUT);
  pinMode(HubMotsleepL, OUTPUT);
  // Rechts
  pinMode(HubMotdirR, OUTPUT);
  pinMode(HubMotspeedR, OUTPUT);
  pinMode(HubMotsleepR, OUTPUT);

  //Hubmotorsynch.
  pinMode(Schritt_Rechts_Int, INPUT);
  pinMode(Schritt_Links_Int, INPUT);
  attachInterrupt(digitalPinToInterrupt(Schritt_Rechts_Int), schrittR, RISING);
  attachInterrupt(digitalPinToInterrupt(Schritt_Links_Int), schrittL, RISING);
    

  // Batterieladefunktion
  // Rechts
  pinMode(Batrechts_ein, OUTPUT);
  digitalWrite(Batrechts_ein, LOW);
  pinMode(Batrechts_aus, OUTPUT);
  digitalWrite(Batrechts_aus, HIGH);
  delay(100);
  digitalWrite(Batrechts_aus, LOW);
  // Links
  pinMode(Batlinks_ein, OUTPUT);
  digitalWrite(Batlinks_ein, LOW);
  pinMode(Batlinks_aus, OUTPUT);
  digitalWrite(Batlinks_aus, HIGH);
  delay(100);
  digitalWrite(Batlinks_aus, LOW);
  // Batterieanzeige
  pinMode(Batterie_R, INPUT);
  pinMode(Batterie_L, INPUT);
  


  // LCD-Anzeige
  lcd.init (); // lcd initialisieren
  lcd.backlight();
  //lcd.print ("LCD2002 starten");
  //analogReference (EXTERNAL);
  //delay(1000);
  lcd.clear ();
  lcd.setCursor (0,0);
  lcd.print ("Volki`s Wohni-Lift   ");
  lcd.setCursor (0,1);
  lcd.print (" Hub_Motoren     ");  
  lcd.setCursor (0,2);
  Batspg_L = analogRead(Batterie_L);
  lcd.print ("Bat. L. = " + String(Batspg_L/36.11) + " Volt");  
  lcd.setCursor (0,3);
  Batspg_R = analogRead(Batterie_R);
  lcd.print ("Bat. R. = " + String(Batspg_R/36.11) + " Volt");  


  // Beschleunigungssensor
  pinMode (xpin, INPUT);
  pinMode (ypin, INPUT);
  pinMode (zpin, INPUT);

  // Berührungssensor
  pinMode (BSlV, INPUT_PULLUP);
  pinMode (BSrV, INPUT_PULLUP);
  pinMode (BSlH, INPUT_PULLUP);
  pinMode (BSrH, INPUT_PULLUP);


}  


void loop()
{
Serial.println("läuft");
  while(1)
  {
    
  
    if (!IRLremote.receiving()) {
      
      // Run code that disables interrupts, such as some led strips
    }
    
    if (IRLremote.available())
    {  
      adresse = " ";
      auto data = IRLremote.read();
      if (data.command != 0) adrL_code = data.command;
      if (data.address == 0xFFFF)
      {
        aktuellems = millis();
        neuems = millis();
        auswahl_menue();
      }
      if (lcdaus == 1)
      {
        digitalWrite(Standbyein, HIGH);
        delay(200);
        digitalWrite(Standbyein, LOW);
        schlafmodusaus();  
      }
      Serial.println(data.command, HEX);  
      Serial.println(data.address, HEX);  
      anzeige = millis()+100;           // 0,1 Sekunden bis zum Motoren stoppen
    }


    // Motoren stopen
    if ((motoran == 1) && (anzeige <= millis()) && (automatik == 0))
    {
      motoren_stoppen();
    }

  if ((millis() - neuems >= Standbyzeit) && (millis() - neuems <= (Standbyzeit + 100)))
    {
      Serial.println("Schalte 5V ab");
      delay(1000);
      digitalWrite(Standbyein, HIGH);
      delay(200);
      digitalWrite(Standbyein, LOW);
      lcdaus = 1;
    }

      
    if (TEST == 1)
    {
      if ((millis() - neuems >= 500) && (millis() - neuems <= 550))
      {
        lcd.setCursor (0,0);
        lcd.print ("                    ");
      }
      if ((millis() - neuems >= 1000))
      {
        lcd.setCursor (0,0);
        lcd.print ("!Achtung! Testmodus ");
        neuems = millis();
      }
    }

    if (millis() - aktuellems > Abschaltzeit)
    {
      Serial.println("Schalte mich ab");
      delay(1000);
      digitalWrite(Standbyein, HIGH);
      delay(200);
      digitalWrite(Standbyein, LOW);
      delay(1000);
      digitalWrite(abschalten, HIGH);
      delay(200);
      digitalWrite(abschalten, LOW);
    }

    if ((Niveauanzeige <= millis()) && (Niveaumotor == 1) && (einaus == 0))
    {
      Niveauanzeige = millis()+1000;
      Niveau();
    }
  }  
}



void auswahl_menue()
{
  //Hub-Motor mit Pfeiltaste aufwärts 0x40 / abwärts 0x19 / links kippen 0x07  rechts kippen 0x09
  if (((adrL_code == 0x40 || adrL_code == 0x07 || adrL_code == 0x19 || adrL_code == 0x09)) && (Hubmotor == 1))  
  {
      if (motoran == 0)
      {
        lcd.setCursor (0,2);
        lcd.print ("Strom L.");
        lcd.setCursor (0,3);
        lcd.print ("Strom R.");
      }

    hub_motoren();
  }
  
  // Niveau-Motoren mit Pfeiltasten auf(0x40)/ab(0x19) und kippen links(0x07)/rechts(0x09)
  if (((adrL_code == 0x40) || (adrL_code == 0x19) || (adrL_code == 0x07) || (adrL_code == 0x09)) && (Niveaumotor ==1)&& (einaus == 0))
  {
    motoran = 1;
    Niveau_Motoren();  
    Niveau();
  }   // Ende Niveaumotoren
  else
  {
    einstellungen();
  }
}




void hub_motoren()
{

      // Linker Motor
      if (adrL_code == 0x09 || adrL_code == 0x19)
      {
        digitalWrite(HubMotdirL, HIGH);
       //serial.println("links ab");
      }
      if (adrL_code == 0x07 || adrL_code == 0x40)
      {
      digitalWrite(HubMotdirL, LOW);
     //serial.println("links auf");
      }
      digitalWrite(HubMotsleepL, HIGH);
      HubMotLStromValue = (analogRead(HubMotLStrom)-9)*45;
      HubMotLStromValue = HubMotLStromValue/100;
      
      // Rechter Motor      
      if (adrL_code == 0x07 || adrL_code == 0x19)
      {
        digitalWrite(HubMotdirR, HIGH);
       //serial.println("rechts ab");
      }
      if (adrL_code == 0x09 || adrL_code == 0x40)
      {
        digitalWrite(HubMotdirR, LOW);
       //serial.println("rechts auf");
      }
      digitalWrite(HubMotsleepR, HIGH);
      HubMotRStromValue = (analogRead(HubMotRStrom)-9)*45;
      HubMotRStromValue = HubMotRStromValue/100;

      if (((adrL_code == 0x07) || (adrL_code == 0x09)) && (Hubspeed >= 128)) { Hubspeed = 25;}

      // BSlVvalue = digitalRead(BSlV);  //Nur bis die Sensoren angeschlossen sind
      // BSrVvalue = digitalRead(BSeV);  //Nur bis die Sensoren angeschlossen sind

    
      if ((BSrVvalue == 1) && (BSlVvalue == 1))
      {
        if (motoran == 0)
        {
          for (int sp = 0; sp < Hubspeed; sp=sp+2)
          {
            analogWrite(HubMotspeedR, sp);
            analogWrite(HubMotspeedL, sp);
            SpeedR = sp;
            SpeedL = sp;
            delay(1);
          }
         //serial.println("Motoren starten");
        }
      }
      else
      {
        for (int sp = Hubspeed; sp > 0; sp=sp-2)
        {
          analogWrite(HubMotspeedL, sp);
          analogWrite(HubMotspeedR, sp);
          delay(1);
        }
       //serial.println("Motoren stoppen");
      }  

    if ((zahlR != Schrittanzahl_R) || (zahlL != Schrittanzahl_L))
    {
      if (Schrittanzahl_R != Schrittanzahl_L)
      {
        Schrittdiff = (Schrittanzahl_R - Schrittanzahl_L) * synchfaktor/100;
        if ((Schrittdiff <= (-1*synchfaktor/100)) || (Schrittdiff >= (+1*synchfaktor/100)))
        {
          SpeedR = SpeedR+(Schrittdiff*10*SpeedR/100);
          if (SpeedR >= 256) {SpeedR = 255;}
          SpeedL = SpeedR+(Schrittdiff*10*SpeedR/100);
          if (SpeedL >= 256) {SpeedL = 255;}
          analogWrite(HubMotspeedL, SpeedR);
          analogWrite(HubMotspeedL, SpeedL);
          //Serial.println(SpeedR);
          //Serial.println(SpeedL);
        }
      }
      zahlR = Schrittanzahl_R;
      zahlL = Schrittanzahl_L;
    }

    lcd.setCursor (10,2);
    lcd.print (HubMotLStromValue);
    lcd.setCursor (10,3);
    lcd.print (HubMotRStromValue);
    lcd.setCursor (17,2);
    lcd.print (Schrittanzahl_R);
    lcd.setCursor (17,3);
    lcd.print (Schrittanzahl_L);
    motoran = 1;  
}

void schrittR()
    {
      detachInterrupt(digitalPinToInterrupt(Schritt_Rechts_Int));
      if (wartenIntR <= millis())
      {  
        Schrittanzahl_R = Schrittanzahl_R + 1;
        wartenIntR = millis() + 5;
        anzahlR = Schrittanzahl_R;
      }
      attachInterrupt(digitalPinToInterrupt(Schritt_Rechts_Int), schrittR, RISING);
    }
    
void schrittL()
    {
      detachInterrupt(digitalPinToInterrupt(Schritt_Links_Int));
      if (wartenIntL <= millis())
      {  
        Schrittanzahl_L = Schrittanzahl_L + 1;
        wartenIntL = millis() + 5;
        anzahlL = Schrittanzahl_L;
      }
      attachInterrupt(digitalPinToInterrupt(Schritt_Links_Int), schrittL, RISING);
    }



void Niveau_Motoren()
{
      if (adrL_code == 0x40) //aufwaerts
      {
        Richtung = 1;
        richt = "aufwaerts";
        digitalWrite(MotdirlV, HIGH);    //Richtung auf mit Taste ^
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        RichtungLV = 1;
        digitalWrite(MotdirrV, HIGH);    //Richtung auf mit Taste ^
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        RichtungRV = 1;
        digitalWrite(MotdirlH, HIGH);    //Richtung auf mit Taste ^
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        RichtungLH = 1;
        digitalWrite(MotdirrH, HIGH);    //Richtung auf mit Taste ^
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
        RichtungRH = 1;
      }

      if (adrL_code == 0x19) //abwaerts
      {
        Richtung = 0;
        richt = "abwaerts";
        digitalWrite(MotdirlV, LOW);    //Richtung ab mit Taste v
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        RichtungLV = 0;
        digitalWrite(MotdirrV, LOW);    //Richtung ab mit Taste v
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        RichtungRV = 0;
        digitalWrite(MotdirlH, LOW);    //Richtung ab mit Taste v
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        RichtungLH = 0;
        digitalWrite(MotdirrH, LOW);    //Richtung ab mit Taste v
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
        RichtungRH = 0;
      }
      if (adrL_code == 0x07) //links kippen
      {
        Richtung = 0;
        richt = "links kippen  ";
        digitalWrite(MotdirlV, LOW);    //Richtung links mit Taste <
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        RichtungLV = 0;
        digitalWrite(MotdirrV, HIGH);    //Richtung links mit Taste <
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        RichtungRV = 1;
        digitalWrite(MotdirlH, LOW);    //Richtung links mit Taste <
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        RichtungLH = 0;
        digitalWrite(MotdirrH, HIGH);    //Richtung links mit Taste <
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
        RichtungRH = 1;
      }
      
      if (adrL_code == 0x09) //rechts kippen
      {
        Richtung = 0;
        richt = "rechts kippen  ";
        digitalWrite(MotdirlV, HIGH);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        RichtungLV = 1;
        digitalWrite(MotdirrV, LOW);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        RichtungRV = 0;
        digitalWrite(MotdirlH, HIGH);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        RichtungLH = 1;
        digitalWrite(MotdirrH, LOW);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
        RichtungRH = 0;
      }

      if ((adrL_code == 0x40) && (Nivmotorwahl == "kippen"))  //vor kippen
      {
        Richtung = 0;
        richt = "vor kippen  ";
        digitalWrite(MotdirlV, LOW);    //Richtung links mit Taste <
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        RichtungLV = 0;
        digitalWrite(MotdirrV, LOW);    //Richtung links mit Taste <
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        RichtungRV = 0;
        digitalWrite(MotdirlH, HIGH);    //Richtung links mit Taste <
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        RichtungLH = 1;
        digitalWrite(MotdirrH, HIGH);    //Richtung links mit Taste <
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
        RichtungRH = 1;
      }
      if ((adrL_code == 0x19) && (Nivmotorwahl == "kippen"))  //zurück kippen
      {
        Richtung = 0;
        richt = "rückwärts kippen  ";
        digitalWrite(MotdirlV, HIGH);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        RichtungLV = 1;
        digitalWrite(MotdirrV, HIGH);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        RichtungRV = 1;
        digitalWrite(MotdirlH, LOW);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        RichtungLH = 0;
        digitalWrite(MotdirrH, LOW);    //Richtung rechts mit Taste >
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
        RichtungRH = 0;
      }

        lcd.setCursor (0,3);
        lcd.print(Nivmotorwahl+ " " + richt +"  ");

            

    if ((Nivmotorwahl == "alle") || (Nivmotorwahl == "LV") || (Nivmotorwahl == "kippen")) LVNiveau();  //links Vorne

    if ((Nivmotorwahl == "alle") || (Nivmotorwahl == "LH") || (Nivmotorwahl == "kippen")) LHNiveau();  //links Hinten  

    if  ((Nivmotorwahl == "alle") || (Nivmotorwahl == "RV") || (Nivmotorwahl == "kippen")) RVNiveau();   //rechts Vorne  
    
    if ((Nivmotorwahl == "alle") || (Nivmotorwahl == "RH") || (Nivmotorwahl == "kippen")) RHNiveau();    //rechts Hinten
}    

    





void Niveau()
{
  //Serial.println("Anfang");
  //lcd.setCursor (0,2);
  //lcd.print ("                ");
  lcd.setCursor (0,2);
  lcd.print ("x=");
  lcd.setCursor (8,2);
  lcd.print ("y=");
  //lcd.setCursor (14,2);
  //lcd.print ("z=   ");

  x = analogRead (xpin);
  delay(1);
  xp = x - x_zero;
  if (automatik == 1) xmittelwert();  
  

  y = analogRead (ypin);
  delay(1);
  yp = y - y_zero;
  

  
  z = analogRead (zpin);
  delay(1);
  zp = z - z_zero;
    
  lcd.setCursor (3,2);
  lcd.print ((String) xp + "  ");
  //Serial.println(xp);
  lcd.setCursor (11,2);
  lcd.print ((String) yp + "  ");
  //Serial.println(xp);
  //lcd.setCursor (16,1);
  //lcd.print ((String) zp + "  ");
  //Serial.println(xp);

  if ((xp == p)  && (automatik == 1))  
  {
    automatik = 0;
    lcd.setCursor (0,3);
    lcd.print ("x-Achse gerade ");
  }
  else xNiv();
  
  
  if ((yp == p) && (automatik == 1))
  {
    lcd.setCursor (0,3);
    lcd.print ("y-Achse gerade ");
  }
  else //yNiv();

  if ((xp == p)  && (yp == p) && (automatik == 1))  
  {
    automatik = 0;
    lcd.setCursor (0,3);
    lcd.print ("Ich stehe gerade ");
  }

}

void xmittelwert()
{
  int xparray[100];
  for (int i = 0; i < 100; i=i+1) {
    xparray[i] = 0;
  }
  int x = 0;
  int xi = x - 300;
  int xpcounter = 0;
  int xpvalue = 0;

  long readtimer = millis()+50;
    do
    {
      x = analogRead (xpin);
      delay(1);
      xp = x - x_zero;
      xi = x - 300;      
      xparray[xi] = xparray[xi] + 1;
      if (xpcounter <= xparray[xi])
      {
         xpcounter = xparray[xi];
         xpvalue = xp;
      }
    } while (readtimer >= millis());
    Serial.println(xparray[xi]);
    Serial.println(xpcounter);
    Serial.println(xpvalue);
    xp = xpvalue;
    
    xparray[yi] = {0};
    xpcounter = 0;
    xpvalue = 0;
}



void xNiv()
  {
    
    if ((xp != p) && (automatik == 1))
    {
      neuems = millis();
      int speed = 200;
      //Serial.println("xp = " + (String) xp + " ");
      if (xp <= p)
      {
        digitalWrite(MotdirlV, LOW);
        RichtungLV = 0;
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        digitalWrite(MotdirlH, HIGH);
        RichtungLH = 1;
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        digitalWrite(MotdirrV, LOW);
        RichtungRV = 0;
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        digitalWrite(MotdirrH, HIGH);
        RichtungRH = 1;
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
      }
      if (xp >= p)
      {
        digitalWrite(MotdirlV, HIGH);
        RichtungLV = 1;
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        digitalWrite(MotdirlH, LOW);
        RichtungLH = 0;
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        digitalWrite(MotdirrV, HIGH);
        RichtungRV = 1;
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        digitalWrite(MotdirrH, LOW);
        RichtungRH = 0;
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
      }
      
      if (xp != p)
      {  
        xtimer = (millis()/1000);
        LVNiveau();
        LHNiveau();
        RVNiveau();
        RHNiveau();
      }
      if (xp == p) motoren_stoppen();
    }
  }

void yNiv()
  {
    
    if ((yp != p) && (automatik == 1))
    {
      neuems = millis();
      int speed = 200;
      //Serial.println("yp = " + (String) yp + " ");
      if (yp <= p)
      {
        digitalWrite(MotdirlV, LOW);
        RichtungLV = 0;
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        digitalWrite(MotdirlH, LOW);
        RichtungLH = 0;
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        digitalWrite(MotdirrV, HIGH);
        RichtungRV = 1;
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        digitalWrite(MotdirrH, HIGH);
        RichtungRH = 1;
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
      }
      if (yp >= p)
      {
        digitalWrite(MotdirlV, HIGH);
        RichtungLV = 1;
        digitalWrite(MotsleeplV, HIGH);   //Motor lV aufwecken
        digitalWrite(MotdirlH, HIGH);
        RichtungLH = 1;
        digitalWrite(MotsleeplH, HIGH);   //Motor lH aufwecken
        digitalWrite(MotdirrV, LOW);
        RichtungRV = 0;
        digitalWrite(MotsleeprV, HIGH);   //Motor rV aufwecken
        digitalWrite(MotdirrH, LOW);
        RichtungRH = 0;
        digitalWrite(MotsleeprH, HIGH);   //Motor rH aufwecken
      }
      
      if (yp != p)
      {  
        ytimer = (millis()/1000);
        LVNiveau();
        LHNiveau();
        RVNiveau();
        RHNiveau();
      }
      if (yp == p) motoren_stoppen();      
    }
  }


void LVNiveau()
    {  
      MotlVobenstate = digitalRead(MotlVoben);
      MotlVuntenstate = digitalRead(MotlVunten);
      if (((RichtungLV == 1 && MotlVobenstate == 1) || (RichtungLV == 0 && MotlVuntenstate == 0)) || (TEST == 1))
      {
        motoran = 1;
        digitalWrite(MotspeedlV, HIGH);   //Motor lV aktivieren
        state = digitalRead(MotspeedlV);
        MotlVStromvalue = analogRead(MotlVStrom);
      }  
      else
      {
        motoran = 1;
        digitalWrite(MotspeedlV, LOW);   //Motor lV stop
        lcd.setCursor (0,1);
        lcd.print (" lV am Anschlag   ");  
        Serial.println (" lV am Anschlag   ");  
      }
    }

    
void LHNiveau()
    {
      MotlHobenstate = digitalRead(MotlHoben);
      MotlHuntenstate = digitalRead(MotlHunten);
      if ((RichtungLH == 1 && MotlHobenstate == 1) || (RichtungLH == 0 && MotlHuntenstate == 0) || (TEST == 1))
                
      {
        motoran = 1;
        digitalWrite(MotspeedlH, HIGH);   //Motor lH aktivieren
        state = digitalRead(MotspeedlH);
        MotlHStromvalue = analogRead(MotlHStrom);
      }  
      else
      {
        digitalWrite(MotspeedlH, LOW);   //Motor lH stop
        lcd.setCursor (0,1);
        lcd.print (" lH am Anschlag   ");  
        Serial.println (" lH am Anschlag   ");  
      }
    }

void RVNiveau()
    {
      MotrVobenstate = digitalRead(MotrVoben);
      MotrVuntenstate = digitalRead(MotrVunten);
      if ((RichtungRV == 1 && MotrVobenstate == 1) || (RichtungRV == 0 && MotrVuntenstate == 0) || (TEST == 1))
      {
        motoran = 1;
        digitalWrite(MotspeedrV, HIGH);   //Motor lV aktivieren
        state = digitalRead(MotspeedrV);
        MotlVStromvalue = analogRead(MotrVStrom);
      }  
      else
      {
        motoran = 1;
        digitalWrite(MotspeedrV, LOW);   //Motor rV stop
        lcd.setCursor (0,1);
        lcd.print (" rV am Anschlag   ");  
        Serial.println (" rV am Anschlag   ");  
      }
    }

void RHNiveau()
    {
      MotrHobenstate = digitalRead(MotrHoben);
      MotrHuntenstate = digitalRead(MotrHunten);
      if ((RichtungRH == 1 && MotrHobenstate == 1) || (RichtungRH == 0 && MotrHuntenstate == 0) || (TEST == 1))
      {
        motoran = 1;
        digitalWrite(MotspeedrH, HIGH);   //Motor rH aktivieren
        state = digitalRead(MotspeedrH);
        MotlHStromvalue = analogRead(MotrHStrom);
      }  
      else
      {
        digitalWrite(MotspeedrH, LOW);   //Motor rH stop
        lcd.setCursor (0,1);
        lcd.print (" rH am Anschlag   ");  
        Serial.println (" rH am Anschlag   ");  
      }
    }




void LcdHub()
{
        lcd.setCursor (0,1);
        lcd.print (" Hub_Motoren        ");
        lcd.setCursor (0,2);
        lcd.print ("Strom L.            ");
        lcd.setCursor (0,3);
        lcd.print("Strom R.            ");  

}

void LcdBox()
{
        lcd.setCursor (0,1);
        lcd.print ("   Lift-Box       ");
        lcd.setCursor (0,2);
        lcd.print("Lift eingefahren  ");  
        lcd.setCursor (0,3);
        lcd.print("Box angehoben     ");  

}

void LcdSetup()
{
        lcd.setCursor (0,1);
        lcd.print ("   Einstellungen  ");
        lcd.setCursor (0,2);
        lcd.print("                  ");  
        lcd.setCursor (0,3);
        lcd.print("                  ");  

}

void LcdNiv()
{
        lcd.setCursor (0,1);
        lcd.print (" Niveau_Motoren  ");  
        lcd.setCursor (0,3);
        lcd.print((String) "Niveaumotor " + Nivmotorwahl + "   ");
        Niveau();
        int Niveauanzeige = millis();

}



void motoren_stoppen()
{
          motoran = 0;
          //Niveau-Motor-Steuerung nach Taste loslassen stoppen
          digitalWrite(MotspeedlV, LOW);   //Motor lV stop
          digitalWrite(MotsleeplV, LOW);   //Motor lV schlafen
          digitalWrite(MotspeedlH, LOW);   //Motor lH stop
          digitalWrite(MotsleeplH, LOW);   //Motor lH schlafen
          digitalWrite(MotspeedrV, LOW);   //Motor rV stop
          digitalWrite(MotsleeprV, LOW);   //Motor rV schlafen
          digitalWrite(MotspeedrH, LOW);   //Motor rH stop
          digitalWrite(MotsleeprH, LOW);   //Motor rH schlafen
          richt = " ";
    
          // HubMotor stop
          for (int sp = Hubspeed; sp > 0; sp=sp-2)
          {
            digitalWrite(HubMotspeedL, LOW);
            digitalWrite(HubMotspeedR, LOW);
            delay(1);
          }
          Serial.println("Motoren stoppen");      
          Serial.println(Niveaumotor);      
          Schrittanzahl_R = 1;
          Schrittanzahl_L = 1;
          lcd.setCursor (16,2);
          lcd.print ("    ");
          lcd.setCursor (16
          ,3);
          lcd.print ("    ");


}




void schlafmodusaus()
{
      digitalWrite(Standbyaus, HIGH);
      delay(1000);
      if ((digitalRead(Standbyaus) == HIGH) && (lcdaus == 1))
      {
        // LCD-Anzeige
        lcd.begin(20,4);
        lcd.setCursor (0,0);
        lcd.print ("Volki`s Wohni-Lift   ");
        lcdaus = 0;
        if (Hubmotor == 1) LcdHub();
        if (Niveaumotor == 1) LcdNiv();
        if (LiftBox == 1) LcdBox();
        lcdaus = 0;
      }
      delay(10);
      digitalWrite(Standbyaus, LOW);
}


void einstellungen()
{
    
    // mit Taste Stop/Mode zwischen Box, Niveau- und Hubmotor schalten
    if ((adrL_code == 0x43) && (Modeschalter <= millis()/1000) && (TEST == 0) && (SetUp == 0))
    {
      lcd.setCursor (0,2);
      lcd.print ("                    ");
      
      if (Mode == "Box")
      {
        Niveaumotor = 0;
        Hubmotor = 1;
        LiftBox = 0;
        LcdHub();
        Mode = "Hub";
      }
      else if (Mode == "Niv")
      {
        Niveaumotor = 0;
        Hubmotor = 0;
        LiftBox = 1;
        LcdBox();
        Mode = "Box";
      }
      else if (Mode == "Hub")
      {
        Niveaumotor = 1;
        Hubmotor = 0;
        LiftBox = 0;
        LcdNiv();
        Mode = "Niv";
      }
      Modeschalter = millis()/1000 +1;
     //serial.println(Mode);
    }

    // Motorgeschwindigkeit mit den Tasten "Vol-, >||, Vol+"
  if (Hubmotor == 1)
  {
    if (adrL_code == 0x45 && Hubspeed >= 25)
    {
      Hubspeed = Hubspeed - 25.5;
      //Serial.println(Hubspeed);
      lcd.setCursor (0,2);
      lcd.print((String) "Leistung " + Hubspeed / 255 * 100 +" % ");
      delay(500);
    }
    if (adrL_code == 0x47 && Hubspeed <= 230)
    {
      Hubspeed = Hubspeed + 25.5;
      //Serial.println(Hubspeed);
      lcd.setCursor (0,2);
      lcd.print((String) "Leistung " + Hubspeed / 255 * 100 +" % ");
      delay(500);
    }
    if (adrL_code == 0x46)
    {
      Hubspeed = 255;
      //Serial.println(Hubspeed);
      lcd.setCursor (0,2);
      lcd.print((String) "Leistung " + Hubspeed / 255 * 100 +" % ");
      delay(500);
    }
  }

// Setup Mode
    if ((adrL_code == 0x44) && (SetUp == 0) && (Modeschalter <= millis()/1000))
    {
      SetUp = 1;
      for (int i=0; i<=4; i++)
      {
         lcd.setCursor (0,i);
         lcd.print("                    ");
         delay(100);
      }
      lcd.setCursor (0,1);
      lcd.print("SETUP-Mode          ");
      lcd.setCursor (0,2);
      lcd.print("                    ");
      Modeschalter = millis()/1000 +1;
    }

    if ((adrL_code == 0x44) && (SetUp == 1) && (Modeschalter <= millis()/1000))
    {
      SetUp = 0;
      for (int i=1; i<=3; i++)
      {
         lcd.setCursor (0,i);
         lcd.print("                    ");
         if (i <= 2)
         {
           lcd.setCursor (0,i+1);
           lcd.print("SETUP-Mode          ");
         }
         delay(500);
      }
      lcd.setCursor (0,0);
      lcd.print ("Volki`s Wohnilift   ");
      if (Hubmotor == 1) {LcdHub();}
      if (Niveaumotor == 1) {LcdNiv();}
      if (LiftBox == 1) {LcdBox();}
      Modeschalter = millis()/1000 +1;
    }

    if (SetUp == 1) { SetupModus(); }
}

void SetupModus()
{

//Testmodus einschalten und ausschalten (Tastenkombination = SETUP -> STOP/MODE)
    if ((adrL_code == 0x43) && (TEST == 1) && (Modeschalter <= millis()/1000))
    {
      TEST = 0;
      lcd.setCursor (0,0);
      lcd.print ("                  ");
      Modeschalter = millis()/1000 +1;
    }

    if ((adrL_code == 0x43) && (SetUp == 1) && (TEST == 0) && (Modeschalter <= millis()/1000))
    {
      TEST = 1;
      lcd.setCursor (0,0);
      lcd.print ("!Achtung! Testmodus ");
      Modeschalter = millis()/1000 +1;
    }
    


// Batterie abschalten (Tastenkombination = SETUP -> Umkehr -> ENTER/SAVE)
    if ((adrL_code == 0x15) && (einaus == 2))  
    {
      aktuellems = 0-3600000;
      for (int i=0; i<=3; i++)
      {
        lcd.setCursor (0,i+1);
        lcd.print("                    ");
        lcd.setCursor (0,i);
        lcd.print("Und Tschuess xx      ");
        delay(500);
        lcd.setCursor (0,i);
        lcd.print("                    ");
      }
      digitalWrite(Standbyein, HIGH);
      delay(200);
      digitalWrite(Standbyein, LOW);
      delay(5000);
      digitalWrite(abschalten, HIGH);
    }
    else if ((adrL_code == 0x15) && (einaus == 2)) {einaus = 1;}

    if ((adrL_code == 0x0D) && (SetUp == 1))
    {
      einaus = 2;
      lcd.setCursor (0,1);
      lcd.print("Ausschalten 2       ");
      lcd.setCursor (0,2);
      lcd.print("dann mit ENTER/SAVE ");
    }
    else if ((adrL_code == 0x0D) && (einaus == 1)) {einaus = 0;}

/*
    if ((adrL_code != 0x15) && (adrL_code != 0x0D) && (adrL_code != 0x44) && (einaus >= 1))
      {
      einaus = 0;
      lcd.setCursor (0,0);
      lcd.print ("Volki`s Wohnilift   ");
      LcdHub();
      }

*/
    if ((SetUp == 1) && (Hubmotor == 1) && (Modeschalter <= millis()/1000) && ((adrL_code == 0x16) || (adrL_code == 0x0C) || (adrL_code == 0x18) || (adrL_code == 0x5E) || (adrL_code == 0x08) || (adrL_code == 0x1C) ||
               (adrL_code == 0x5A) || (adrL_code == 0x42) || (adrL_code == 0x52) || (adrL_code == 0x4A)))
    {
      if ((adrL_code == 0x16) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "0";}
      if ((adrL_code == 0x0C) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "1";}
      if ((adrL_code == 0x18) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "2";}
      if ((adrL_code == 0x5E) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "3";}
      if ((adrL_code == 0x08) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "4";}
      if ((adrL_code == 0x1C) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "5";}
      if ((adrL_code == 0x5A) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "6";}
      if ((adrL_code == 0x42) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "7";}
      if ((adrL_code == 0x52) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "8";}
      if ((adrL_code == 0x4A) && (daempfer.toInt() <= 99)) {daempfer = daempfer + "9";}
      Modeschalter = millis()/1000 +1;
    }
/*    else if ((adrL_code != 0x16) || (adrL_code != 0x0C) || (adrL_code != 0x18) || (adrL_code != 0x5E) || (adrL_code != 0x08) || (adrL_code != 0x1C) ||
               (adrL_code != 0x5A) || (adrL_code != 0x42) || (adrL_code != 0x52) || (adrL_code != 0x4A))
    {
      daempfer = " ";
      lcd.setCursor (0,2);
      lcd.print("                    ");
      lcd.setCursor (0,3);
      lcd.print("                    ");
    }
*/
    if (daempfer.toInt() >= 1)
    {
      synchfaktor = daempfer.toInt();
      lcd.setCursor (0,2);
      lcd.print((String)"Modeschalter"+Modeschalter);
      lcd.setCursor (0,3);
      lcd.print((String) "daempf."+synchfaktor);
    }
    if ((adrL_code == 0x15) && (daempfer.toInt() >=0) && (daempfer.toInt() <=100))
    {
      synchfaktor = daempfer.toInt();
      daempfer = "";
      lcd.setCursor (0,2);
      lcd.print("                    ");
      lcd.setCursor (0,3);
      lcd.print("                    ");

    }
            
    
    
//Motorselektion für Niveaumotoren
    if ((Niveaumotor == 1) && (automatik == 0))
    {
      lcd.setCursor (0,3);
      lcd.print("                    ");

      if (adrL_code == 0x0C) Nivmotorwahl = "LV";     // Taste 1
    
      if (adrL_code == 0x42) Nivmotorwahl = "LH";     // Taste 7
    
      if (adrL_code == 0x5E) Nivmotorwahl = "RV";     // Taste 3
    
      if (adrL_code == 0x4A) Nivmotorwahl = "RH";     // Taste 9
    
      if (adrL_code == 0x1C) Nivmotorwahl = "alle";   // Taste 5
    
      if (adrL_code == 0x18) Nivmotorwahl = "vor kippen"; // Taste 2

      if (adrL_code == 0x08) Nivmotorwahl = "links kippen"; // Taste 4

      if (adrL_code == 0x5A) Nivmotorwahl = "rechts kippen"; // Taste 6

      if (adrL_code == 0x52) Nivmotorwahl = "zurück kippen"; // Taste 8

      lcd.setCursor (0,3);
      lcd.print((String) "Motoren " + Nivmotorwahl );
    }
        

//Autonivilierung einschalten
    if ((SetUp == 1) && (Niveaumotor == 1) && (adrL_code == 0x15) && (automatik == 0) && (tastentimer <= millis()))
    {
      automatik = 1;
      motoran = 1;
      adrL_code = 0;
      tastentimer = millis()+1000;
      //Serial.println(automatik);
      lcd.setCursor (0,3);
      lcd.print ("auto. nivilieren ");
    }
    else if ((adrL_code == 0x0D) && (automatik == 1) && (tastentimer <= millis()))
    {
      automatik = 0;
      tastentimer = millis()+1000;
      //Serial.println(automatik);
      lcd.setCursor (0,3);
      lcd.print((String) "Niveaumotor " + Nivmotorwahl + "   ");
    }

}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.02.2021, 17:02
Beitrag #15
RE: Motorsteuerung
Ich habe nun doch noch ein RC-Glied rein gehängt. Jetzt funktioniert es wirklich sauber. Hätte ich eigentlich selber wissen müssen. Hab mal Rundfunk- und Fernsehtechniker gelernt. Aber in einem halben Jahrhundert vergisst man viel.
Vor allem, wenn man drei Berufe in so ein Projekt reinpackt.
Anbei noch der Aufbau des Schrittzählers.


Angehängte Datei(en) Thumbnail(s)
   
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.02.2021, 18:59
Beitrag #16
RE: Motorsteuerung
Super sauber aufgebaut SmileExclamation

https://www.youtube.com/watch?v=Fnzn85oWM_Q
Hier was zum Thema Deutsche Politik Angry
Und hier zum Thema richtige Politik Big Grin
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
Smile Motorsteuerung mit Taster Eggi123 11 4.412 26.02.2017 15:48
Letzter Beitrag: MicroBahner
  Motorsteuerung für Rover ? Carlo 0 2.018 08.03.2016 19:26
Letzter Beitrag: Carlo
  Vorstellung und Frage zur Motorsteuerung papla 1 2.634 19.01.2014 10:55
Letzter Beitrag: rkuehle

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste