Servoantrieb mit Geber simulation

Hallo zusammen,

ich bin neu hier und hab da gleich mal ein Problem.
Ich möchte einen Servo drehen lassen und dazu eine Impulsgeberausgabe simulieren.

Beides für sich bekomme ich schon hin aber die Kombination ist komisch...

Ich bin jetzt nicht der Oberheld was Programmieren angeht, da fehlen halt noch die Grundlagen.

Mein Problem ist das ich solange wie der Servo sich dreht ich in Abhängigkeit von der Rotationsgeschwindigkeit den 2Bit Zähler (simuliert einen AB Geber) laufen lassen will.

Wenn jemand da was hat oder eine Idee hat wie ich hier am besten anfange währe ich über jeden Tipp
dankbar.
Am ende soll das ein Antrieb für einen Aufzug Simulator in klein werden.

Danke schon mal :slight_smile:

spezi1805:
Beides für sich bekomme ich schon hin aber die Kombination ist komisch...

Zeig doch mal :slight_smile:

Du möchtest also einen Dauerdrehservo (360°) zum Antrieb nutzen und als Istposition einen Encoder?

Grüße Uwe

Hi,

ich hab noch nicht wirklich was fertig außer so ein paar test´s :confused:
Mal eine etwas genauere Beschreibung, ich will eigentlich einen Industrie Umrichter simulieren. Für die Aufzugsteuerung brauche ich einen Zähler der in Echt ein 64 puls 2Spur TTL geber ist. Da ich aber das ganze als Tischmodell bauen möchte hab ich keinen Platz für die echten Komponenten.

Meine eigentliche Verwirrung ist wie ich einen Zähler hin bekomme der in Abhängigkeit der gewählten Geschwindigkeit Zählt und den Wert auf zwei pin´s ausgibt.

Ich denke morgen Bastele ich mal so die einzelnen Fragmente zusammen, hab aber jetzt schonden verdacht das das alles nichts wird.

Danke schon mal für euer Interesse, für den Fall das wiedererwartend doch was mit Sinn und Funktion dabei rauskommt stelle ich das Morgen mal hier ein. 8)

spezi1805:
... ich will eigentlich einen Industrie Umrichter simulieren.

Was ist das? Meinst Du einen Frequenzumrichter?

spezi1805:
Meine eigentliche Verwirrung ist wie ich einen Zähler hin bekomme der in Abhängigkeit der gewählten Geschwindigkeit Zählt und den Wert auf zwei pin´s ausgibt.

Das IDE-Beispiel BlinkWithoutDelay könnte ein Anfang sein. Anstelle eine LED blinken zu lassen, zählst Du eine Variable rauf: 0, 1, 2 ,3, 0, 1 ... und gibst die Bits 0 und 1 auf Ausgänge.

Also willst Du mit Arduino einen Encoder simulieren?

spezi1805:
Meine eigentliche Verwirrung ist ...

Meine Verwirrung ist, dass ich nicht die Spur verstehe, was Du vorhast. Garniere Deine Rückmeldung mit Links, damit ich etwas zu lesen habe :slight_smile:

Gruß

Gregor

Danke für die vielen Antworten...

Ich hab da mal was fertig gemacht, finde ich pers aber noch nicht so ellegant.

Bitte ignoriert mal die fehlende, nicht saubere Form. Soweit geht das mit einem 360grad Servo(modifizierter Modellbauservo).

Mir fehlt noch eine Idee wie ich den Start verhindern kann wenn keine Geschwindigkeit gewählt wurde, die Geswindigkeit aber nicht gelöscht wird wenn nach dem Start das Eingangssignal weg geht.

Ansonsten binn ich für jede Anregung, Kommentar, Watsch´n oder was auch immer gerne da

Bitte setze Deinen Sketch in Codetags (</> oben links), damit er von allen lesbar ist.
Anhänge werden kaum gelesen.

Gruß Tommy

Sorry,

// Antriebsimulation mit 3 Geschwindigkeiten und Richtungsauswahl. Gebersimulation bis zu 4bit Zähler
//Mit counter kann 2, 3 oder 4Bit eingestellt werden hex03, hex07 oder hex0f
// Mit velocity wird die Drehgeschwindigkeit definiert
//in speed1, speed2 und speed3 stehen die Geschwindigkeiten

#define PORTLED2 2 // Definieren nun 4 LEDs
#define PORTLED3 3 // fuer PD2,PD3,PD4,PD5
#define PORTLED4 4 //
#define PORTLED5 5
int buttonPin1 = 7;    // integer variable buttonPin1 up
int buttonPin2 = 8;    // integer variable buttonPin2 down
int buttonPin3 = 10;      // integer für buttonPin3 speed1
int buttonPin4 = 11;      // integer für buttonPin3 speed1
int buttonPin5 = 12;      // integer für buttonPin3 speed1


#include <Servo.h>

Servo myservo;  

int pos = 0;    // variable to store the servo position
int stop_position = 90;
int velocity = 0;
int speed1 = 10;
int speed2 = 20;
int speed3 = 40;

void setup() { // Startet die Initialisierung
myservo.attach(9);  // attaches the servo on pin 9 to the servo object
myservo.write(90);  
pinMode(buttonPin1,INPUT_PULLUP);   // Pin7 ist jetzt ein Eingang
pinMode(buttonPin2,INPUT_PULLUP);   // Pin8 ist jetzt ein Eingang
pinMode(buttonPin3,INPUT_PULLUP);   // Pin10 ist jetzt ein Eingang
pinMode(buttonPin4,INPUT_PULLUP);   // Pin11 ist jetzt ein Eingang
pinMode(buttonPin5,INPUT_PULLUP);   // Pin12 ist jetzt ein Eingang  
pinMode(PORTLED2,OUTPUT); // Port 2 als Ausgang schalten
pinMode(PORTLED3,OUTPUT); // Port 3 als Ausgang schalten
pinMode(PORTLED4,OUTPUT); // Port 4 als Ausgang schalten
pinMode(PORTLED5,OUTPUT); // Port 5 als Ausgang schalten
}
void loop() {
  if(digitalRead(buttonPin3) == LOW)
  {
    velocity =10;
  }
   if(digitalRead(buttonPin4) == LOW)
  {
    velocity =20;
  }
   if(digitalRead(buttonPin5) == LOW)
  {
    velocity =40;
  }
  //if(digitalRead(buttonPin3)==HIGH && digitalRead(buttonPin4)==HIGH&& digitalRead(buttonPin5)==HIGH)
 // {
 //   velocity = 0;
 // }
  
  // Fahrt in Richtung ab
  if(digitalRead(buttonPin1)==HIGH && digitalRead(buttonPin2)==HIGH)
  {
    myservo.write(90);
  }
  
 if (digitalRead(buttonPin1)==LOW && digitalRead(buttonPin2)==HIGH)
  { 
static int counter = 0; // der Zaehlerstand bleibt erhalten

    myservo.write(stop_position - velocity);              // tell servo to go to position in variable 'pos'
    delay(5);                       // waits 5ms for the servo to reach the position
if (counter & 1) { // Bit 0 pruefen
digitalWrite(PORTLED4,HIGH); // rechte LED
} else digitalWrite(PORTLED4,LOW); //
if (counter & 2) { // Bit 1 pruefen
digitalWrite(PORTLED5,HIGH); // linke LED
} else digitalWrite(PORTLED5,LOW); // naechste
if (counter & 4) { // Bit 2 pruefen
digitalWrite(PORTLED3,HIGH); // // auf 1 setzen
} else digitalWrite(PORTLED3,LOW); // Reihenfolge !
if (counter & 8) { // Bit 3 pruefen
digitalWrite(PORTLED2,HIGH); // Dann erst LED 2 bei Bit 4
} else digitalWrite(PORTLED2,LOW); //
delay(100); // Eine weitere Sekunde warten = 1000ms
counter = (counter - 1)& 0x3; // 0..15 Zaehler dann wieder auf 0 durch Maske

  }
  // Fahrt in Richtung auf
 if (digitalRead(buttonPin1)==HIGH && digitalRead(buttonPin2)==LOW)
  { 
static int counter = 0; // der Zaehlerstand bleibt erhalten

    myservo.write(stop_position + velocity);              // tell servo to go to position in variable 'pos'
    delay(5);                       // waits 15ms for the servo to reach the position
    
if (counter & 1) { // Bit 0 pruefen
digitalWrite(PORTLED4,HIGH); // rechte LED
} else digitalWrite(PORTLED4,LOW); //
if (counter & 2) { // Bit 1 pruefen
digitalWrite(PORTLED5,HIGH); // linke LED
} else digitalWrite(PORTLED5,LOW); // naechste
if (counter & 4) { // Bit 2 pruefen
digitalWrite(PORTLED3,HIGH); // // auf 1 setzen
} else digitalWrite(PORTLED3,LOW); // Reihenfolge !
if (counter & 8) { // Bit 3 pruefen
digitalWrite(PORTLED2,HIGH); // Dann erst LED 2 bei Bit 4
} else digitalWrite(PORTLED2,LOW); //
delay(100); // Eine weitere Sekunde warten = 1000ms
counter = (counter + 1)& 0x3; // 0..15 Zaehler dann wieder auf 0 durch Maske
  } 
}

spezi1805:
Ansonsten binn ich für jede Anregung, Kommentar, Watsch´n oder was auch immer gerne da

Du willst es, Du kriegst es :slight_smile:

int buttonPin1 = 7;    // integer variable buttonPin1 up
int buttonPin2 = 8;    // integer variable buttonPin2 down
int buttonPin3 = 10;      // integer für buttonPin3 speed1
int buttonPin4 = 11;      // integer für buttonPin3 speed1
int buttonPin5 = 12;      // integer für buttonPin3 speed1

Das sind Konstanten, keine Variablen. Außerdem sind die Benennungen nicht aussagekräftig. Sowas wie buttonPinUP fände ich besser.

const byte buttonPin1 = 7;    // integer variable buttonPin1 up
const byte buttonPin2 = 8;    // integer variable buttonPin2 down
const byte buttonPin3 = 10;      // integer für buttonPin3 speed1
const byte buttonPin4 = 11;      // integer für buttonPin3 speed1
const byte buttonPin5 = 12;      // integer für buttonPin3 speed1

Mal #define, mal const byte finde ich ungeschickt.

Sind das nicht auch Konstanten:

int speed1 = 10;
int speed2 = 20;
int speed3 = 40;

Auch eine Konstante:

const unsigned int stop_position = 90;

Die solltest Du auch verwenden:

 myservo.write(stop_position);

Würde ich als globale Variable definieren, 8 Bit würden aber auch genügen (int8_t):

   static int counter = 0; // der Zaehlerstand bleibt erhalten

Als Anregung:

digitalWrite(PORTLED2, ((counter >> 3) & 0x1));

@agmue:

Danke für die Anregungen. Ich werde mal versuchen diese Umzusetzen, teste das ganze dann und setze den code hier rein.

Eine Frage vorne weg,

digitalWrite(PORTLED2, ((counter >> 3) & 0x1));

was ist hier der vorteil gegenüber meiner Lösung?

Den rest habe ich, vielleicht, verstanden und versuch den mal umzusetzen.

Ach ja, bei mir schaut eine Watsch´n anders aus... warst noch sehr nett zu mir :slight_smile:

spezi1805:

digitalWrite(PORTLED2, ((counter >> 3) & 0x1));

was ist hier der vorteil gegenüber meiner Lösung?

Anstelle einer Konstanten HIGH/LOW ist auch ein variabler Term erlaubt, was zu einer kompakteren Schreibweise führt. Aber mache es, wie Du magst.

spezi1805:
... warst noch sehr nett zu mir :slight_smile:

Ich gebe mir Mühe, klappt nicht immer.

Hallo zusammen,

hab mal versucht die Anregungen umzusetzen...

// Antriebsimulation mit 3 Geschwindigkeiten und Richtungsauswahl. Gebersimulation bis zu 4bit Zähler
//Mit counter kann 2, 3 oder 4Bit eingestellt werden hex03, hex07 oder hex0f
// Mit velocity wird die Drehgeschwindigkeit definiert
//in speed1, speed2 und speed3 stehen die Geschwindigkeiten

#define PORTLED2 2            // Zähler Bit3
#define PORTLED3 3            // Zähler Bit2
#define PORTLED4 4            // Zähler Bit1
#define PORTLED5 5            // Zähler Bit0
#define buttonPinUp 7         // Eingang Richtung auf     
#define buttonPinDown 8       // Eingang Richtung ab  
#define buttonPinSpeed1 10    // Geschwindigkeit 1     
#define buttonPinSpeed2 11    // Geschwindigkeit 2     
#define buttonPinSpeed3 12    // Geschwindigkeit 3      
#define buttonPinStopp 13     // Eingang Stopp
//#define StopPinOut 6          //Ausgang keine Geschwindigkeit
#include <Servo.h>

Servo myservo;  

int pos = 0;    // Startposition Servo
int stop_position = 90; // Servo definierte Position zuweisen
int velocity = 0; // Drehgeschwindigkeit Servo
int speed1 = 100;  // Zähler Skalierung Gesch. 1
int speed2 = 200;  // Zähler Skalierung Gesch. 2
int speed3 = 400;  // Zähler Skalierung Gesch. 3
int speedwahl = 0; // ??? keine Ahnung ob dasso funktioniert soll den Zähler skalieren
void setup()
{                                        // Startet die Initialisierung
myservo.attach(9);                      // Servo an PWM Pin 9
myservo.write(stop_position);           // Servo in Neutralstellung
pinMode(buttonPinUp,INPUT_PULLUP);      // Pin7 ist jetzt ein Eingang "Auf"
pinMode(buttonPinDown,INPUT_PULLUP);    // Pin8 ist jetzt ein Eingang "Ab"
pinMode(buttonPinSpeed1,INPUT_PULLUP);  // Pin10 ist jetzt ein Eingang "Gesch.1"
pinMode(buttonPinSpeed2,INPUT_PULLUP);  // Pin11 ist jetzt ein Eingang "Gesch.2"
pinMode(buttonPinSpeed3,INPUT_PULLUP);  // Pin12 ist jetzt ein Eingang "Gesch.3" 
pinMode(buttonPinStopp, INPUT_PULLUP);  // Pin13 ist der Stopp eingang zum anhalten 
pinMode(PORTLED2,OUTPUT);               // Port 2 als Ausgang schalten "Zähler Bit0"
pinMode(PORTLED3,OUTPUT);               // Port 3 als Ausgang schalten "Zähler Bit1"
pinMode(PORTLED4,OUTPUT);               // Port 4 als Ausgang schalten "Zähler Bit2"
pinMode(PORTLED5,OUTPUT);               // Port 5 als Ausgang schalten "Zähler Bit3"
Serial.begin (9600);
}
void loop()
{

  if(digitalRead(buttonPinStopp) == LOW)  //Geschwindigkeit und Zählgeschwindigkeit speed1
        {
          myservo.write(stop_position);
     Serial.println ("Stooooooooooopppppppp")
        }
    if(digitalRead(buttonPinSpeed1) == HIGH && digitalRead(buttonPinSpeed2) == HIGH && digitalRead(buttonPinSpeed3) == HIGH)
    {
   Serial.println ("keine Gesch");
   myservo.write(stop_position);      
    }
    else
    {
  if(digitalRead(buttonPinSpeed1) == LOW )  //Geschwindigkeit und Zählgeschwindigkeit speed1
        {
           velocity =10;
           speedwahl = speed3;
           Serial.println ("V 1");
        }
   if(digitalRead(buttonPinSpeed2) == LOW )   //Geschwindigkeit und Zählgeschwindigkeit speed2
        {
           velocity =20;
           speedwahl = speed2;
           Serial.println ("V 2");
        }
   if(digitalRead(buttonPinSpeed3) == LOW )   //Geschwindigkeit und Zählgeschwindigkeit speed3
        {
            velocity =40;
            speedwahl = speed1;
            Serial.println ("V 3");
        }
    
 
 // Fahrt in Richtung ab
  if(digitalRead(buttonPinUp)==HIGH && digitalRead(buttonPinDown)==HIGH)  //wenn keine Richtung dann Servo in neutralposition "steht"
        {
          myservo.write(stop_position);
        }
  
 if (digitalRead(buttonPinUp)==LOW && digitalRead(buttonPinDown)==HIGH )   //Abfrage Eingang AB
       { 
       
          static int counter = 0; // der Zaehlerstand bleibt erhalten
          myservo.write(stop_position - velocity);              // Servorichtung bestimmen
          delay(5);
          Serial.println ("AB");                      
          if (counter & 1) 
          {                                        // Zähler 
            digitalWrite(PORTLED4,HIGH); 
          } 
          else digitalWrite(PORTLED4,LOW); 
          if (counter & 2) 
          { 
          digitalWrite(PORTLED5,HIGH); 
          } 
          else digitalWrite(PORTLED5,LOW); 
          if (counter & 4)
          { 
          digitalWrite(PORTLED3,HIGH); 
          } 
          else digitalWrite(PORTLED3,LOW); 
          if (counter & 8)
          {
          digitalWrite(PORTLED2,HIGH); 
          }
          else digitalWrite(PORTLED2,LOW); 
          delay(speedwahl);                                        // Geschwindigkeit der Zählschleife
          counter = (counter - 1)& 0x3;                             // Bestimmt max Zählwert
           Serial.println (counter);
       }
  // Fahrt in Richtung auf
      if (digitalRead(buttonPinUp)==HIGH && digitalRead(buttonPinDown)==LOW )
         
         {
         
          static int counter = 0; // der Zaehlerstand bleibt erhalten
          myservo.write(stop_position + velocity);              // Servorichtung bestimmen
          delay(5);
          Serial.println ("AUF");                       
          if (counter & 1)
          {                                        // Zähler
          digitalWrite(PORTLED4,HIGH); 
          }
          else digitalWrite(PORTLED4,LOW);
          if (counter & 2)
          { 
          digitalWrite(PORTLED5,HIGH); 
          }
          else digitalWrite(PORTLED5,LOW); 
          if (counter & 4)
          { 
          digitalWrite(PORTLED3,HIGH); 
          }
          else digitalWrite(PORTLED3,LOW); 
          if (counter & 8)
          { 
          digitalWrite(PORTLED2,HIGH); 
          }
          else digitalWrite(PORTLED2,LOW); 
          delay(speedwahl);                                            // Geschwindigkeit der Zählschleife
          counter = (counter + 1)& 0x3;                                 // Bestimmt max Zählwert
           Serial.println (counter);
    }
    }       
 }

Das mit dem Zähler hab ich nicht so recht hin bekommen, steh da wohl auf einer sehr langen Leitung.
Der Code funktioniert so, wenn es aber noch Sachen zu verbessern gibt bin ich für Anregungen immer zu haben. Man Lernt halt doch mit den Sachen die man Falsch oder Umständlich gemacht hat.

@agmue
Kannst du mir mal zwei Zeilen von deiner Zähler variante geben, dann fällt hoffe ich er Groschen.

Wenn das Projekt fertig ist mach ich mal ein Video... kann aber noch dauern.

spezi1805:
@agmue
Kannst du mir mal zwei Zeilen von deiner Zähler variante geben, dann fällt hoffe ich er Groschen.

Gerne doch, wenn ich denn wüßte, was Du meinst :confused:

Wenn Du Konstanten, die wegoptimiert werden, als Variablen definierst, verschwendest Du Variablenspeicher:

const unsigned int stop_position = 90; // Servo definierte Position zuweisen
const unsigned int speed1 = 100;  // Zähler Skalierung Gesch. 1
const unsigned int speed2 = 200;  // Zähler Skalierung Gesch. 2
const unsigned int speed3 = 400;  // Zähler Skalierung Gesch. 3

Ein delay(400) zusammen mit Tastendrücken ist keine gute Idee. Du solltest stattdessen besser millis() verwenden.

Eine ordentliche Priorisierung (Stopp vor kleiner vor großer Geschwindigkeit) fände ich von Vorteil:

  if (digitalRead(buttonPinStopp) == LOW)
  {
    myservo.write(stop_position);
    Serial.println ("Stooooooooooopppppppp")
  }
  else if (digitalRead(buttonPinSpeed1) == LOW ) //Geschwindigkeit und Zählgeschwindigkeit speed1
  {
    velocity = 10;
    speedwahl = speed3;
    Serial.println ("V 1");
  }
  else if (digitalRead(buttonPinSpeed2) == LOW )  //Geschwindigkeit und Zählgeschwindigkeit speed2
  {
    velocity = 20;
    speedwahl = speed2;
    Serial.println ("V 2");
  }
  else if (digitalRead(buttonPinSpeed3) == LOW )  //Geschwindigkeit und Zählgeschwindigkeit speed3
  {
    velocity = 40;
    speedwahl = speed1;
    Serial.println ("V 3");
  }
  else
  {
    Serial.println ("keine Gesch");
    myservo.write(stop_position);
  }

spezi1805:
Der Code funktioniert so, wenn es aber noch Sachen zu verbessern gibt bin ich für Anregungen immer zu haben. Man Lernt halt doch mit den Sachen die man Falsch oder Umständlich gemacht hat.

Dann lerne vor allem Anderen, Deinen Code möglichst lesbar zu machen und so zu formatieren, dass für einen Code-Fremden (wie mich) auf einen Blick klar ist, wie der Code strukturiert ist. D. h. zum Beispiel passend einrücken und Klammern einheitlich setzen.

Wenn Du Deinen Code so formatierst, werden Dir wahrscheinlich viele Dinge sehr viel schneller klar. Und die Fehlersuche gestaltet sich obendrein deutlich angenehmer.

Gruß

Gregor

@agmue:
Die großen delay sind nur zur besseren Darstellung. In meinem Versuchsaufbau sind da noch LED´s dran und ich wollte die blinken sehen. Wenn das in ein Modell eingebaut wird werden das so ungefähr 10ms max sein. Ich habe die Konstanten Speed 1 bis 3 denke ich unglücklich gewählt, da ich in velocity mit einem größeren Wert eine höhere Drehzahl erreiche ich aber mit Speed1... bei einem größeren Wert ein langsameres Zählen habe.
Hier ist die Abfrage doch >>> wenn nicht Stop dann Geschwindigkeit möglich

V1 ist die kleinste Geschwindigkeit und V3 die größte
Oder hab ich da was falsch verstanden?

if (digitalRead(buttonPinStopp) == LOW)
  {
    myservo.write(stop_position);
    Serial.println ("Stooooooooooopppppppp")
  }
  else if (digitalRead(buttonPinSpeed1) == LOW ) //Geschwindigkeit und Zählgeschwindigkeit speed1
  {
    velocity = 10;
    speedwahl = speed3;
    Serial.println ("V 1");
  }
  else if (digitalRead(buttonPinSpeed2) == LOW )  //Geschwindigkeit und Zählgeschwindigkeit speed2
  {
    velocity = 20;
    speedwahl = speed2;
    Serial.println ("V 2");
  }
  else if (digitalRead(buttonPinSpeed3) == LOW )  //Geschwindigkeit und Zählgeschwindigkeit speed3
  {
    velocity = 40;
    speedwahl = speed1;
    Serial.println ("V 3");
  }
  else
  {
    Serial.println ("keine Gesch");
    myservo.write(stop_position);
  }

Wie gregorss Schreibt muß ich erstmal an der Form arbeiten bevor ich hier komplexere Sachen anfange.

Was ich nicht verstanden habe ist, wie ich diese Zeile in meinen Zähler einbauen kann und was die ersetzt.

digitalWrite(PORTLED2, ((counter >> 3) & 0x1));

Ansonsten gebe ich mir beim nächsten mal mehr mühe mit der äußeren Form und bedanke mich noch mal für die Denkanstöße...

LG Peter

spezi1805:
Was ich nicht verstanden habe ist, wie ich diese Zeile in meinen Zähler einbauen kann und was die ersetzt.

Alt:

     if (counter & 1)
      { // Zähler
        digitalWrite(PORTLED4, HIGH);
      }
      else digitalWrite(PORTLED4, LOW);
      if (counter & 2)
      {
        digitalWrite(PORTLED5, HIGH);
      }
      else digitalWrite(PORTLED5, LOW);
      if (counter & 4)
      {
        digitalWrite(PORTLED3, HIGH);
      }
      else digitalWrite(PORTLED3, LOW);
      if (counter & 8)
      {
        digitalWrite(PORTLED2, HIGH);
      }
      else digitalWrite(PORTLED2, LOW);

Neu zum Probieren:

digitalWrite(PORTLED4, (counter & 0x1));
digitalWrite(PORTLED5, ((counter >> 1) & 0x1));
digitalWrite(PORTLED3, ((counter >> 2) & 0x1));
digitalWrite(PORTLED2, ((counter >> 3) & 0x1));

Wobei counter = (counter + 1) & 0x3; nicht stimmt, dann funktionieren nur zwei LEDs. Die Reihenfolge von PORTLED4 und PORTLED5 ist auch nicht verständlich.

Wenn man erstmal zu wühlen anfängt :smiley:

spezi1805:
Wie gregorss Schreibt muß ich erstmal an der Form arbeiten bevor ich hier komplexere Sachen anfange.

Ich kann's nur nochmal wiederholen: „Schön programmieren“ hilft nicht nur dem Code-fremden Leser sondern insbesondere auch Dir, weil der Kopf für andere Sachen frei ist, als sich merken zu müssen, wo ein Block anfängt und aufhört. Und die Fehlersuche wird erheblich einfacher. Im Grunde ist das „schön Programmieren“ etwas für faule Leute :slight_smile:

Gruß

Gregor

Danke für die Antworten...

mal kurz zur Erklärung für die paar Zeilen zuviel Code, es gibt Aufzugsteuerungen die mit 2bit(AB Geber) arbeiten und es gibt welche die mit 4bit funktionieren. Da ich hier ein bisschen vorausschauend sein wollte (man glaubt es kaum) habe ich hier absichtlich einen 4bit Zähler gebaut und den nur bis bin3 zählen lassen. Das mit den bescheuert vergebenen Benennungen liegt tatsächlich an meiner anfänglichen Verwirrtheit...

Danke für die erklärenden Zeilen zum BinZähler, ich glaub jetzt verstehe ic wie du es gemeint hasst. Ist echt einfacher :slight_smile:

JA beim nächsten mal werde ich mich echt bemühen von Anfang an Ordnung zu halten beim Programmieren, ich glaube der Ansatz von mir erst den einen Teil und dann den Rest zu schreiben und am Schluß alles zusammenzuklatschen war nicht so gut (echt Sch___) das werde ich beim nächsten Projekt anders angehen.

Ich setze die Anregungen jetzt noch um und dann geht es an den Bau von dem Teilchen.