Arduino Forum

International => Deutsch => Topic started by: kgbrus on Sep 22, 2020, 11:13 am

Title: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Sep 22, 2020, 11:13 am
Hallo zusammen,

zunächst möchte ich mich kurz Vorstellen, mein Name ist Kay bin 53 Jahre alt und mache die ersten Gehversuche mit Arduino. Ich benutze den Arduino STM32F103.

2 Programme hab ich schon gemacht um meine Modellbahn zu steuern.

Ich verzweifle  immer an der Stelle, wenn ich den "delay" Befehl durch "Millis" ersetzen will. Mal klappt es mal nicht. Trotz mehrfaches ausprobieren der Nachtwächterschaltung und Blink without delay kapiere ich das einfach nicht.
Ev hilft es mir ja, wenn mir jemand von euch sagt, was an meinem Code falsch ist.

Code: [Select]
LSBG1State = digitalRead(LSBG1);  // Abfrage ob Zug auf Gleis 1 steht.
            if (LSBG1State == HIGH)
                  {
                    digitalWrite (W1G, HIGH);
                   RELAIS1G_timestore = millis();
                  }
               
                 if (millis() - RELAIS1G_timestore> 1000 ) //Schaltzeit Relais 1 Sek.
                   {
                      digitalWrite(W1G, LOW);
                      W1GState = LOW;
                   }

 

W1G ist der Ausgang für ein Relais, dieses soll für 1 Sekunde anziehen und dann wieder abfallen.

Das Relais zieht an, fällt aber nicht mehr ab. Ich verzweifel hier gerade..

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: HotSystems on Sep 22, 2020, 11:19 am
Hallo,

der STM32F103 ist doch sicher der Controller und als Arduino hat der bestimmt einen anderen Namen.

Poste einfach mal einen Link deines Boards, das ist dann verständlicher.
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 22, 2020, 11:22 am
Quote
der STM32F103 ist doch sicher der Controller und als Arduino hat der bestimmt einen anderen Namen.
Es gibt keine Arduinos mit STM32F103

Der übliche Name ist "Blue Pill Board" (https://www.google.com/search?q=Blue+Pill+Board&tbm=isch)
Suche mal danach, und du wirst erschlagen.
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 22, 2020, 11:24 am
a) mit codeschnippseln tun wir uns schwer.
b) drücke mal STRG-T in deiner IDE und mach die Einrückungen schön
c) statte deinen Code halt mit Serial.print Ausgaben aus, und verfolge welche deine Bedingungen erfüllt ist und dann siehst du auch warum dein Code nicht macht was du dir vorstellst.

VERMUTLICH ist halt LSBG1State  noch immer High, daher ist die erste Bedingung wieder erfüllt und es schaltet ein.
Solche Sachen erkennst du aber schön mit Serial.print Ausgaben und kannst daher deine Logik anpassen.

add on: wenn das Weichenantriebe sind, dann würde ich da einen anderen Ansatz verfolgen...
Title: Re: Mal wieder der Milis Befehl
Post by: HotSystems on Sep 22, 2020, 11:25 am
Es gibt keine Arduinos mit STM32F103

Der übliche Name ist "Blue Pill Board"
Suche mal danach, und du wirst erschlagen.
Danke....dann lass ich es lieber. ;)
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 11:34 am
Zunächst einmal vielen Dank für die Antworten und die Hilfe,

es handelt sich um dieses https://www.az-delivery.de/products/stm32f103c8t6?_pos=1&_sid=bbf5ca81a&_ss=r

Board und da ist doch ein STM32F103 drauf? Entschuldigt, wenn ich mich da falsch ausgedrückt habe.

Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :-)


Soll ich den kompletten code hier rein kopieren? incl setup? Meine Frage lautet, ob ich im Code einen Fehler gemacht habe, da der teil ab If (millis) wohl vom Programm ignoriert wird.


Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: Tommy56 on Sep 22, 2020, 11:44 am
Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :-)
So wie er jetzt ist, werden wohl mögliche Helfer nichts finden.

Soll ich den kompletten code hier rein kopieren? incl setup?
Ja.

Gruß Tommy
Title: Re: Mal wieder der Milis Befehl
Post by: HotSystems on Sep 22, 2020, 11:45 am
Board und da ist doch ein STM32F103 drauf? Entschuldigt, wenn ich mich da falsch ausgedrückt habe.

Der Controller ist drauf, aber es ist kein Arduino.
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 22, 2020, 11:51 am
Quote
Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :-)
dann hast sowieso einen Fehler oder das ist so eine IF-Wurst - die kann sowieso niemand mehr überblicken - nicht mal mehr du.

Da ist was faul.
Restlliches Post von mir hast auch gelesen?
Title: Re: Mal wieder der Milis Befehl
Post by: Peter-CAD-HST on Sep 22, 2020, 11:58 am
Moin
mit
Code: [Select]
LSBG1State = digitalRead(LSBG1);  // Abfrage ob Zug auf Gleis 1 steht.
if (LSBG1State == HIGH)
{
  digitalWrite (W1G, HIGH);
  RELAIS1G_timestore = millis();
}

wird die millis()-Eieruhr immer wieder neu aufgezogen, solange ein Zug auf Gleis 1 steht.
Probier mal die folgende Verriegelung aus * ungetestet *
Code: [Select]
LSBG1State = digitalRead(LSBG1); 
if (LSBG1State == HIGH &&  digitalRead(LSBG1) == LOW) 
{
  digitalWrite ( digitalRead(LSBG1), HIGH);
  RELAIS1G_timestore = millis();
}

Viel Erfolg
Gruß Peter
und gesund bleiben
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 22, 2020, 12:01 pm
Quote
Bei STRG& T rückt mir die IDE alles nach links, dann finde ich nix mehr :-)
Der von Arduino benutzte Code Formatierer ist fein einstellbar.

In der C/C++ Welt haben sich 2 Formatierungsstile quasi durchgesetzt.
1. K&R
2. Allman

K&R ist die default Einstellung.
Du verwendest eher Allman


Suche die Datei formatter.conf, diese liegt bei mir in Laufwerk:\Programme\arduino\lib
Füge folgende Zeile hinzu
Code: [Select]
style=allman

Title: Re: Mal wieder der Milis Befehl
Post by: my_xy_projekt on Sep 22, 2020, 12:12 pm
Ich verzweifle  immer an der Stelle, wenn ich den "delay" Befehl durch "Millis" ersetzen will.

Ev hilft es mir ja, wenn mir jemand von euch sagt, was an meinem Code falsch ist.
Zum einrücken war schion gesagt ....
Dein Problem ist nicht millis().

Du musst Dir den Status des PIN merken und das der erst in den Ausgangszustand (LOW) muss, bevor wieder neu ausgelöst wird.
Code: [Select]

if (!LSBG1State && digitalRead (LSBG1)) // Abfrage ob Zug auf Gleis 1 steht.
{
  LSBG1State = HIGH;
  digitalWrite (W1G, HIGH);
  RELAIS1G_timestore = millis();
}
if (!digitalRead (LSBG1)  // Wenn kein Zug auf dem Gleis:
{
LSBG1State = LOW;  // Status zurücksetzen
}

if (millis() - RELAIS1G_timestore > 1000) //Schaltzeit Relais 1 Sek.
{
digitalWrite (W1G, LOW);
  W1GState = LOW;
}
Title: Re: Mal wieder der Milis Befehl
Post by: my_xy_projekt on Sep 22, 2020, 12:21 pm
Moin,
ungetestet
Code: [Select]
LSBG1State = digitalRead(LSBG1);  
if (LSBG1State == HIGH &&  digitalRead(LSBG1) == LOW)  

Das kann nicht.
Ich denke, Du wolltest W1G oder W1GState verwenden.
if (LSBG1State == HIGH &&  W1G == LOW)  

Ich habe das absichtlich nicht so gemacht, weil der Code nicht vollständig und nicht klar ist wo was zu welchem Zweck verwendet wird...
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 22, 2020, 12:42 pm
Der STM32F103 kann mittels Arduino-IDE programmiert werden, wird aber von STMicroelectronics hergestellt. Dieses Forum finanziert sich durch den Verkauf von Arduinos und thematisiert folglich diese, weshalb genau genommen Fragen zum STM32F103 hier fehl am Platze sind. Unser Moderator ist aber glücklicherweise großzügig und läßt auch Fragen zu Nicht-Arduinos zu. Damit er nicht aufgeschreckt wird, haben wir Dich schon mal über Deinen kleinen Irrtum aufgeklärt.

Deine Frage hat aber eigentlich mit Deiner Hardware nichts zu tun, auf einem UNO wäre das nicht anders.

Spekulativ hat Deine Frage auch nur am Rande mit millis zu tun, denn grundsätzlich sieht das bei Dir richtig aus. Eher geht es um die Auswertung von sich ändernden Zuständen, also Flankenerkennung.

Möglicherweise findest Du die Bibliothek MobaTools (https://github.com/MicroBahner/MobaTools) hilfreich.



Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 22, 2020, 12:57 pm
einen hab ich noch.
Imho ruft so ein Weichenantrieb regelrecht nach OOP oder will man die millis für jeden einzelne Weiche imm wieder manuell neu anlegen?

so zum Anfangen, mal nur die Weiche in OOP und die Gleisrückmeldung noch alt:

kompiliert, aber ungetestet
Code: [Select]

class Antrieb
{
  private:
    const byte pin;
    uint32_t previousMillis;

  public:
    Antrieb(byte pin) : pin(pin) {}
    void begin() {                      // einmal im Setup aufrufen
      pinMode(pin, OUTPUT);
    }
    void pulse()                        // wenn man schalten will
    {
      digitalWrite(pin, HIGH);
      previousMillis = millis();
    }
    void run()                          // laufend im loop aufrufen, damit sich der Magnetartikel auch wieder abschaltet
    {
      if (digitalRead(pin) == HIGH && millis() - previousMillis > 1000)
      {
        digitalWrite(pin, LOW);
      }
    }
};

//Weichen Antriebe anlegen und Pins zuordnen
Antrieb w1g(3);
Antrieb w1b(4);

// old style Gleisrückmeldungen:
const byte LSBG1 = 10;
byte previousLSBG1State;                         

void setup() {
  // put your setup code here, to run once:
  w1g.begin();
  w1b.begin();
}

void loop() {
  // Logik zum "Einschalten" ....

  // gleis schaltet von frei auf besetzt
 
  byte LSBG1State = digitalRead(LSBG1);
  if (LSBG1State == HIGH && previousLSBG1State == LOW)
  {
    w1g.pulse();
    previousLSBG1State == LSBG1State;
  }
  if (LSBG1State == LOW && previousLSBG1State == HIGH);
  {
    // beim Verlassen was anderes tun
    previousLSBG1State == LSBG1State;
  }
 
  //usw

  // alle Weichenantriebe aufrufen - vieleicht ist einer zum abschalten...
  w1g.run();
  w1b.run();
}



Title: Re: Mal wieder der Milis Befehl
Post by: Tommy56 on Sep 22, 2020, 01:31 pm
Da würde sich ein Blick ins Tutorial Von delay bis zur Methode (https://www.wikinger-tommy.de/rentner/index.html) von Rentner lohnen.

Gruß Tommy
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 01:35 pm
@ all vielen Dank, genau die Art von Hilfe hab ich mir erwartet, ich dachte die ganze Zeit das das am milis Befehl liegt, da der Ablauf mit dem delay Befehl funktioniert. Der Fehler liegt woanders.

Das Programm soll ein freies Gleis im Schattenbahnhof suchen (LSBG1) ist eine Lichtschranke, die anzeigt das das Gleis besetzt ist, oder wenn alle Gleise besetzt sind den einfahrenden Zug am SBH vorbei leiten. Deshalb wird LSBG1 in dem Zusammenhang sich nicht ändern.. Dann muss ich mal gucken wie ich das löse.
Das hat mir aber schon viel weiter geholfen.

@combie style alleman hab ich eingefügt, ist jetzt besser.




@noiaska: Das sind keine Weichenantriebe, wie zB beim Märklin C Gleis. Das sind Märklin M Gleise. Hier wird einfach eine Spule auf Masse vom Gleis geschaltet. Die schalte ich über ein Relais.
W1A bedeutet "Weiche 1 auf abbiegen" schalten. W1G bedeutet "Weiche 1 auf geradeaus" schalten usw.
Wie wäre dein anderer Ansatz?

In deinem letzten Post gehst du von Weichenantrieben aus, die man Digital ansprechen kann?

@agumue Danke das schaue ich mir mal genauer an.
@my_xy_project: Danke für den Code, könnte schon die Lösung sein.

Vielen Dank für die Hilfe



Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 01:42 pm
Hier noch der Code:

Sorry beim ersten Versuch war der Post zu lang. (Limit 9000 Zeichen) beim 2ten mal kam die Meldung ich muss 5 Minuten warten bis zum nächsten Post..


Code: [Select]
/* Weichenschaltung der Gleise 1 -5 Version 2_1
                Funktionen:
                1. Weichenschaltung neu komplett neu aufgesetzt
                2. Programm läuft immer nur, wenn Zug in SBH einfährt (LSHaupt)
                3. Programmierung LS Haupt
                4. V6.0
                Version 7.0 Delay Befehl durch millies ersetzt.
*/
// Umbenenen der STM Pins



// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const int LSBG1 = PA8;   // Lichtschranke Gleisbesetzt Gleis 1
const int LSBG2 = PB15;   // Lichtschranke Gleisbesetzt Gleis 2
const int LSBG3 = PB14;   // Lichtschranke Gleisbesetzt Gleis 3
const int LSBG4 = PB13;   // Lichtschranke Gleisbesetzt Gleis 4
const int LSBG5 = PB12;   // Lichtschranke Gleisbesetzt Gleis 5
int LSBG1State = 0;
int LSBG2State = 0;
int LSBG3State = 0;
int LSBG4State = 0;
int LSBG5State = 0;


// Lichtschranke SBH Haupt
const int LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH
int LSHauptState = 0;



// Ausgänge für Relais  der Weichenstellung weiche 1-5
const int W1A = PA0;          // Weiche 1 Abbiegen
const int W1G = PA1;          // Weiche 1 Geradeaus
const int W2A = PA2;          // Weiche 2 Abbiegen
const int W2G = PA3;          // Weiche 2 Geradeaus
const int W3A = PA4;          // Weiche 3 Abbiegen
const int W3G = PA5;          // Weiche 3 Geradeaus
const int W4A = PA6;          // Weiche 4 Abbiegen
const int W4G = PA7;          // Weiche 4 Geradeaus
const int WHauptA = PB0;      // Hauptweiche Abbiegen
const int WHauptG = PB1;     // Hauptweiche Geradeaus
int W1AState = 0;
int W1GState = 0;
int W2AState = 0;
int W2GState = 0;
int W3AState = 0;
int W3GState = 0;
int W4AState = 0;
int W4GState = 0;
int W5AState = 0;
int W5GState = 0;
int WHauptAState = 0;
int WHauptGState = 0;


// variable definieren
// Variablen Relais Ausgaänge für Weichen
bool geschaltetW1A = false;        // Variable für Weiche1 Abbiegen
bool geschaltetW1G = false;        // Variable für Weiche1 Geradeaus
bool geschaltetW2A = false;        // Variable für Weiche2 Abbiegen
bool geschaltetW2G = false;        // Variable für Weiche2 Geradeaus
bool geschaltetW3A = false;        // Variable für Weiche3 Abbiegen
bool geschaltetW3G = false;        // Variable für Weiche3 Geradeaus
bool geschaltetW4A = false;        // Variable für Weiche4 Abbiegen
bool geschaltetW4G = false;        // Variable für Weiche4 Geradeaus
bool geschaltetW5A = false;        // Variable für Weiche5 Abbiegen
bool geschaltetW5G = false;        // Variable für Weiche5 Geradeaus
bool geschaltetWHauptA = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHauptG = false;    // Variable für Weiche3 Geradeaus

int empfindlichkeit = 200;



unsigned long RELAIS1G_timestore;  // Variable Speicher für Systemzeit.Weiche1
unsigned long RELAIS1A_timestore;
unsigned long RELAIS2G_timestore;  // Variable Speicher für Systemzeit.Weiche2
unsigned long RELAIS2A_timestore;
unsigned long RELAIS3G_timestore;  // Variable Speicher für Systemzeit.Weiche3
unsigned long RELAIS3A_timestore;
unsigned long RELAIS4G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS4A_timestore;
unsigned long RELAIS5G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS5A_timestore;
unsigned long RELAISHauptG_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAISHauptA_timestore;

// Variablen für die Counter damit Befehl nur einmal ausgeführt wird. Erst nach Zustandswechsel der LSBG wieder erneut
/*unsigned long CounterWHauptA = 0;
  unsigned long CounterWHauptA1 = 0;
  unsigned long CounterWHauptG = 0;
  unsigned long CounterW1A = 0;
  unsigned long CounterW1Ageschaltet = 0;
  unsigned long CounterW2A = 0;
  unsigned long CounterW3A = 0;
  unsigned long CounterW4A = 0;
  unsigned long CounterW5A = 0;


void setup()
{
  // put your setup code here, to run once:



  // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
  pinMode(LSBG1, INPUT);
  pinMode(LSBG2, INPUT);
  pinMode(LSBG3, INPUT);
  pinMode(LSBG4, INPUT);
  pinMode(LSBG5, INPUT);
  pinMode(LSHaupt, INPUT);

  // Pin Mode für Lichtschranken Gleiseinfahrt Gleis 1 - 5 rausgenommen



  // Pin Mode für Gleis an schalten
  pinMode(W1A, OUTPUT);
  pinMode(W1G, OUTPUT);
  pinMode(W2A, OUTPUT);
  pinMode(W2G, OUTPUT);
  pinMode(W3A, OUTPUT);
  pinMode(W3G, OUTPUT);
  pinMode(W4A, OUTPUT);
  pinMode(W4G, OUTPUT);
  pinMode(WHauptA, OUTPUT);
  pinMode(WHauptG, OUTPUT);
}

void loop()



{
  LSHauptState = digitalRead(LSHaupt);     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
  if (LSHauptState == HIGH)
  {
    LSBG1State = digitalRead(LSBG1);    // abfrage ob SBH voll
    LSBG2State = digitalRead(LSBG2);
    LSBG3State = digitalRead(LSBG3);
    LSBG4State = digitalRead(LSBG4);
    LSBG5State = digitalRead(LSBG5);

    if (LSBG1State == HIGH && LSBG2State == HIGH && LSBG3State == HIGH && LSBG4State == HIGH && LSBG5State == HIGH)  // Abfrage ob alle Gleise besetzt sind
    {
      digitalWrite (WHauptA, HIGH);
      RELAISHauptA_timestore = millis();
    }
    if (millis() - RELAISHauptA_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptA, LOW);
      WHauptAState = LOW;
    }

    else
      //    if (LSBG1State == LOW || LSBG2State == LOW || LSBG3State == LOW || LSBG4State == LOW || LSBG5State == LOW)  // Abfrage ob alle Gleise besetzt sind                                          // nicht alle Gleise sind besetzt
    {
      digitalWrite (WHauptG, HIGH);
      RELAISHauptG_timestore = millis();
    }
    if (millis() - RELAISHauptG_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptG, LOW);
      WHauptGState = LOW;
    }


    LSBG1State = digitalRead(LSBG1);  // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      digitalWrite (W1G, HIGH);
      RELAIS1G_timestore = millis();
    }

    if (millis() - RELAIS1G_timestore > 1000 ) //Schaltzeit Relais 1 Sek.
    {
      digitalWrite(W1G, LOW);
      W1GState = LOW;
    }

    if (LSBG1State == LOW)
    {
      digitalWrite (W1A, HIGH);
      RELAIS1A_timestore = millis();
    }

    if (millis() - RELAIS1A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W1A, LOW);
      W1AState = LOW;
    }

    LSBG2State = digitalRead(LSBG2);  // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      digitalWrite (W2G, HIGH);
      RELAIS2G_timestore = millis();
    }

    if (millis() - RELAIS2G_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W2G, LOW);
      W2GState = LOW;
    }

    if (LSBG2State == LOW)
    {
      digitalWrite (W2A, HIGH);
      RELAIS2A_timestore = millis();
    }

    if (millis() - RELAIS2A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W2A, LOW);
      W2AState = LOW;
    }

    LSBG3State = digitalRead(LSBG3);   // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      digitalWrite (W3G, HIGH);
      RELAIS3G_timestore = millis();
    }

    if (millis() - RELAIS3G_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W3G, LOW);
      W3GState = LOW;
    }

    if (LSBG3State == LOW)
    {
      digitalWrite (W3A, HIGH);
      RELAIS3A_timestore = millis();
    }

    if (millis() - RELAIS3A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W3A, LOW);
      W3AState = LOW;
    }

    LSBG4State = digitalRead(LSBG4);   // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      digitalWrite (W4G, HIGH);
      RELAIS4G_timestore = millis();
    }

    if (millis() - RELAIS4G_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W4G, LOW);
      W4GState = LOW;
    }

    if (LSBG4State == LOW)
    {
      digitalWrite (W4A, HIGH);
      RELAIS4A_timestore = millis();
    }

    if (millis() - RELAIS4A_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(W4A, LOW);
      W4AState = LOW;
    }

    LSBG5State = digitalRead(LSBG5);

  }


}


Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 22, 2020, 01:50 pm
Quote
In deinem letzten Post gehst du von Weichenantrieben aus, die man Digital ansprechen kann?
nein, schau dir das noch mal an.

In der Klasse ist ein ganz normaler digitialWrite HIGH und ein digitalWrite LOW fürs abschalten. So wie in deinem Code für einen Antrieb auch.

Die Klasse beschreibt wie ein Antrieb funktioniert: Wir brauchen etwas fürs Setup, etwas zum Schalten und die Überwachung, dass nach 1 Sekunde der Magnetartikel wieder abschaltet. Ganz das gleiche wie bei dir auch.

Der Unterschied ist, ich brauche für 2 (oder 10 wie bei dir) Weichenantriebe nur einmal definieren was so ein Antrieb kann und wie er nach Zeitablauf wieder abschaltet.

Nach der Klassendefinition, lege ich zwei konkrete Objekte an. Dabei gibts einen Namen für den Antrieb und die Zuordnung von einem Pin.

Bei dir steht der Code fürs abschalten 10 mal drinnen - für jeden einzelnen Weichenantrieb. Das bläht den Code auf  und kann zu Copy-Paste fehlern führen.






Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 02:04 pm
@noiaska, ahh verstanden. Ich bin absoluter Neuling in C++ und hab mit Klassen noch nichts gemacht, das muss ich mich erst mal einlesen. BZw ich denke das ist noch etwas zu früh für mich.
Prinzipiell hast du aber Recht, das deine Lösung die bessere ist.

Hier ist der Code mit dem delay Befehl, der macht genau, was er soll:
Code: [Select]
/* Weichenschaltung der Gleise 1 -5 Version 2_1
                Funktionen:
                1. Weichenschaltung neu komplett neu aufgesetzt
                2. Programm läuft immer nur, wenn Zug in SBH einfährt (LSHaupt)
                3. Programmierung LS Haupt
                4. V6.0
*/
// Umbenenen der STM Pins



// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const int LSBG1 = PA8;   // Lichtschranke Gleisbesetzt Gleis 1
const int LSBG2 = PB15;   // Lichtschranke Gleisbesetzt Gleis 2
const int LSBG3 = PB14;   // Lichtschranke Gleisbesetzt Gleis 3
const int LSBG4 = PB13;   // Lichtschranke Gleisbesetzt Gleis 4
const int LSBG5 = PB12;   // Lichtschranke Gleisbesetzt Gleis 5
int LSBG1State = 0;
int LSBG2State = 0;
int LSBG3State = 0;
int LSBG4State = 0;
int LSBG5State = 0;


// Lichtschranke SBH Haupt
const int LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH
int LSHauptState = 0;



// Ausgänge für Relais  der Weichenstellung weiche 1-5
const int W1A = PA0;          // Weiche 1 Abbiegen
const int W1G = PA1;          // Weiche 1 Geradeaus
const int W2A = PA2;          // Weiche 2 Abbiegen
const int W2G = PA3;          // Weiche 2 Geradeaus
const int W3A = PA4;          // Weiche 3 Abbiegen
const int W3G = PA5;          // Weiche 3 Geradeaus
const int W4A = PA6;          // Weiche 4 Abbiegen
const int W4G = PA7;          // Weiche 4 Geradeaus
const int WHauptA = PB0;      // Hauptweiche Abbiegen
const int WHauptG = PB1;     // Hauptweiche Geradeaus
int W1AState = 0;
int W1GState = 0;
int W2AState = 0;
int W2GState = 0;
int W3AState = 0;
int W3GState = 0;
int W4AState = 0;
int W4GState = 0;
int W5AState = 0;
int W5GState = 0;
int WHauptAState = 0;
int WHauptGState = 0;


// variable definieren
// Variablen Relais Ausgaänge für Weichen
bool geschaltetW1A = false;        // Variable für Weiche1 Abbiegen
bool geschaltetW1G = false;        // Variable für Weiche1 Geradeaus
bool geschaltetW2A = false;        // Variable für Weiche2 Abbiegen
bool geschaltetW2G = false;        // Variable für Weiche2 Geradeaus
bool geschaltetW3A = false;        // Variable für Weiche3 Abbiegen
bool geschaltetW3G = false;        // Variable für Weiche3 Geradeaus
bool geschaltetW4A = false;        // Variable für Weiche4 Abbiegen
bool geschaltetW4G = false;        // Variable für Weiche4 Geradeaus
bool geschaltetW5A = false;        // Variable für Weiche5 Abbiegen
bool geschaltetW5G = false;        // Variable für Weiche5 Geradeaus
bool geschaltetWHauptA = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHauptG = false;    // Variable für Weiche3 Geradeaus

int empfindlichkeit = 200;


unsigned long RELAIS1G_timestore;  // Variable Speicher für Systemzeit.Weiche1
unsigned long RELAIS1A_timestore;
unsigned long RELAIS2G_timestore;  // Variable Speicher für Systemzeit.Weiche2
unsigned long RELAIS2A_timestore;
unsigned long RELAIS3G_timestore;  // Variable Speicher für Systemzeit.Weiche3
unsigned long RELAIS3A_timestore;
unsigned long RELAIS4G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS4A_timestore;
unsigned long RELAIS5G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS5A_timestore;
unsigned long RELAISHauptG_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAISHauptA_timestore;

// Variablen für die Counter damit Befehl nur einmal ausgeführt wird. Erst nach Zustandswechsel der LSBG wieder erneut
unsigned long CounterWHauptA = 0;
unsigned long CounterWHauptA1 = 0;
unsigned long CounterWHauptG = 0;
unsigned long CounterW1A = 0;
unsigned long CounterW1Ageschaltet = 0;
unsigned long CounterW2A = 0;
unsigned long CounterW3A = 0;
unsigned long CounterW4A = 0;
unsigned long CounterW5A = 0;

// delay zeit um zwischenräume zwischen Wagons abzufangen
unsigned long LSBG1_timestore_akt = 0;
unsigned long LSBG1_timestore_alt = 0;
unsigned long LSBG1_delay (3000);
unsigned long LSBG1High_timestore_akt = 0;
unsigned long LSBG1High_timestore_alt = 0;
unsigned long LSBG2_timestore_akt = 0;
unsigned long LSBG2_timestore_alt = 0;
unsigned long LSBG2_delay (3000);
unsigned long LSBG2High_timestore_akt = 0;
unsigned long LSBG2High_timestore_alt = 0;
unsigned long LSBG3_timestore_akt = 0;
unsigned long LSBG3_timestore_alt = 0;
unsigned long LSBG3_delay (3000);
unsigned long LSBG3High_timestore_akt = 0;
unsigned long LSBG3High_timestore_alt = 0;
unsigned long LSBG4_timestore_akt = 0;
unsigned long LSBG4_timestore_alt = 0;
unsigned long LSBG4_delay (3000);
unsigned long LSBG4High_timestore_akt = 0;
unsigned long LSBG4High_timestore_alt = 0;
unsigned long LSBG5_timestore_akt = 0;
unsigned long LSBG5_timestore_alt = 0;
unsigned long LSBG5_delay (3000);
unsigned long LSBG5High_timestore_akt = 0;
unsigned long LSBG5High_timestore_alt = 0;








void setup()
{
  // put your setup code here, to run once:



  // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
  pinMode(LSBG1, INPUT);
  pinMode(LSBG2, INPUT);
  pinMode(LSBG3, INPUT);
  pinMode(LSBG4, INPUT);
  pinMode(LSBG5, INPUT);
  pinMode(LSHaupt, INPUT);

  // Pin Mode für Lichtschranken Gleiseinfahrt Gleis 1 - 5 rausgenommen



  // Pin Mode für Gleis an schalten
  pinMode(W1A, OUTPUT);
  pinMode(W1G, OUTPUT);
  pinMode(W2A, OUTPUT);
  pinMode(W2G, OUTPUT);
  pinMode(W3A, OUTPUT);
  pinMode(W3G, OUTPUT);
  pinMode(W4A, OUTPUT);
  pinMode(W4G, OUTPUT);
  pinMode(WHauptA, OUTPUT);
  pinMode(WHauptG, OUTPUT);
}

void loop()



{
  LSHauptState = digitalRead(LSHaupt);     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
  if (LSHauptState == HIGH)
  {
    LSBG1State = digitalRead(LSBG1);    // abfrage ob SBH voll
    LSBG2State = digitalRead(LSBG2);
    LSBG3State = digitalRead(LSBG3);
    LSBG4State = digitalRead(LSBG4);
    LSBG5State = digitalRead(LSBG5);

    if (LSBG1State == HIGH && LSBG2State == HIGH && LSBG3State == HIGH && LSBG4State == HIGH && LSBG5State == HIGH)  // Abfrage ob alle Gleise besetzt sind
    {
      digitalWrite (WHauptA, HIGH);
      delay(1000);
      digitalWrite (WHauptA, LOW);
    }
    else
      //    if (LSBG1State == LOW || LSBG2State == LOW || LSBG3State == LOW || LSBG4State == LOW || LSBG5State == LOW)  // Abfrage ob alle Gleise besetzt sind                                          // nicht alle Gleise sind besetzt
    {
      digitalWrite (WHauptG, HIGH);
      delay(1000);
      digitalWrite (WHauptG, LOW);
    }

    LSBG1State = digitalRead(LSBG1);  // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      digitalWrite (W1G, HIGH);
      delay (1000);
      digitalWrite (W1G, LOW);
    }
    if (LSBG1State == LOW)
    {
      digitalWrite (W1A, HIGH);
      delay (1000);
      digitalWrite (W1A, LOW);
    }
    LSBG2State = digitalRead(LSBG2);  // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      digitalWrite (W2G, HIGH);
      delay (1000);
      digitalWrite (W2G, LOW);
    }
    if (LSBG2State == LOW)
    {
      digitalWrite (W2A, HIGH);
      delay (1000);
      digitalWrite (W2A, LOW);
    }
    LSBG3State = digitalRead(LSBG3);   // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      digitalWrite (W3G, HIGH);
      delay (1000);
      digitalWrite (W3G, LOW);
    }
    if (LSBG3State == LOW)
    {
      digitalWrite (W3A, HIGH);
      delay (1000);
      digitalWrite (W3A, LOW);
    }
    LSBG4State = digitalRead(LSBG4);   // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      digitalWrite (W4G, HIGH);
      delay (1000);
      digitalWrite (W4G, LOW);
    }
    if (LSBG4State == LOW)
    {
      digitalWrite (W4A, HIGH);
      delay (1000);
      digitalWrite (W4A, LOW);
    }
    LSBG5State = digitalRead(LSBG5);
    delay (10000);
  }


}


Damit ich das richtig verstehe, ich kann den delay Befehl nicht so einfach als Funktion durch Millies ersetzten? Da muss ich andere Bedungen schaffen?
Title: Re: Mal wieder der Milis Befehl
Post by: Tommy56 on Sep 22, 2020, 02:06 pm
Das alles wird in dem Tutorial, was ich in #15 verlinkt habe, erklärt. Nur lesen muss man es.

Gruß Tommy
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 02:12 pm
@Tommy56, das hab ich mir schon gedacht, nur noch nicht in Gänze getan.



Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 22, 2020, 03:12 pm
Auch dein "Delay" Sketch ließe sich übersichtlich einkürzen.

Sind dir Arrays ein Begriff oder dass man einer Funktion einen Parameter übergeben könnte?

Also so was

Code: [Select]

void pulse(byte pin)
{
   digitalWrite (pin, HIGH);
   delay (1000);
   digitalWrite (pin, LOW);
}


und dann rufst nur auf:

pulse(W3G);

jedes mal 2 Zeilen gespart...
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 22, 2020, 03:31 pm
Hallo Kay,
Ich benutze den Arduino STM32F103.
2 Programme hab ich schon gemacht um meine Modellbahn zu steuern.
Dass der STM32F103 kein Arduino ist, wurde dir ja schon klargemacht ;) . Nun unterstützt die IDE den ja erstmal auch gar nicht. Welche Erweiterung der IDE verwendest Du denn, und wie programmierst Du deinen  Baustein? ( Interessant wäre auch noch, was dich zum STM32F1 geführt hat. Für einen Einsteiger ist der ja nicht gerade erste Wahl, und für deine Aufgaben hätte es ein Standard-Arduino oder ein Klon auch getan ).

Aber sei's drum. Die MobaTools wurden Dir von agmue schon empfohlen. Sie unterstützen grundsätzlich auch die STM32F1 Prozessoren, setzen aber eine bestimmten IDE-Erweiterung dafür voraus ( die von Roger Clark (https://github.com/rogerclarkmelbourne/Arduino_STM32) ). Deshalb auch die Frage, welche IDE-Erweiterung Du einsetzt.

Eine Einführung in die Programmierung ohne delay() aus Modellbahnersicht findest Du auch hier (https://www.stummiforum.de/viewtopic.php?f=21&t=163493). Die Beispiele setzen allerdings die MobaTools voraus.

Ich kann dir auch nur empfehlen, dich einmal mit Funktionen und Arrays zu befassen. Die gehören definitiv zu den ersten Grundlagen, und würden auch einiges an deinem Programm vereinfachen. Sich vorher mit Klassen zu befassen wäre aus meiner Sicht den 3.Schritt vor dem ersten zu tun :)
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 03:59 pm
Hallo Microbahner,

Ich benutze Arduiono 1.8.13 dazu gibt es die Board Verwalter http://dan.drown.org/stm32duino/package_STM32duino_index.json

da ist der Generetic STM32F103 dabei.

Warum STM32? Ist zwar eine längere Geschichte aber hier die Kurzform: Das Board kostet fast nix ca 3,-€ :-)
Aber ein bisschen was muß ich dazu doch noch sagen. Ich bin im Vertrieb von Elektronik tätig. Unsere Entwicklungsabteilung arbeitet mit dem STM. Ich hab mich lange Zeit gewehrt an meiner Moba was digital zu machen.
Ich wollte die Steuerungen zunächst diskret (ich hab mal Radio Fernsehtechniker gelernt) aufbauen. Da bin ich aber kläglich gescheitert. Auch deshalb weil Märklin ja mit AC arbeitet.
Der Vorteil beim digitalen ist ja auch, wenn ich was ändern will, oder Funktionen hinzufügen will bleibt die Hardware relativ gleich.
Und vor nem halben Jahr hab ich dann unserem Entwicklungsleiter nachgegeben, er meinte das es relativ einfach ist mit dem Arduino. Und das ist ja auch so.
Prinzipiell bin ich ja auch schon relativ weit gekommen. Das Programm um die Loks auf den Abstellgleisen abzubremsen bis die die Endposition erreicht haben funktioniert. Zuerst mit dem delay und mittlerweile mit dem millis Befehl. Den ich wie ich nun wiedre gemarkt habe, da wohl nur zufällig richtig eingesetzt habe...
Der zweite Teil des programms, das Schalten der Weichen, funktioniert mit dem Delay Befehl einwandfrei. Es sei denn die Loks kommen zu schnell hintereinander.

Gruß

Kay

Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 04:04 pm
Auch dein "Delay" Sketch ließe sich übersichtlich einkürzen.

Sind dir Arrays ein Begriff oder dass man einer Funktion einen Parameter übergeben könnte?

Also so was

Code: [Select]

void pulse(byte pin)
{
   digitalWrite (pin, HIGH);
   delay (1000);
   digitalWrite (pin, LOW);
}


und dann rufst nur auf:

pulse(W3G);

jedes mal 2 Zeilen gespart...
Da hab ich mich noch nicht mit beschäftigt, deshalb zu meinem Verständnis ein paar Fragen:
1. Pulse ist der Name der Funktion?
2. Was bedeutet das (byte pin)?
3. Die Zeile pulse(W3G) bedeutet für das Programm: Führe Funktion "Pulse" am Pin W3G aus?

Die Funktionen werden im "void setup" oder davor definiert?

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 22, 2020, 04:59 pm
Hallo Kay,
Ich benutze Arduiono 1.8.13 dazu gibt es die Board Verwalter http://dan.drown.org/stm32duino/package_STM32duino_index.json
Über den Link von Dan Drown wird soweit ich weis der Core von Roger Clark installiert. Da sollten dann auch die MobaTools funktionieren.
Wie lädst Du den Sketch auf deine BluePill? Hast Du einen Bootloader draufgebrannt?

Da hab ich mich noch nicht mit beschäftigt,
Das solltest Du dringend tun. Funktionen und Arrays sind absolut wichtige Grundlagen für eine übersichtliche Programmierung.
Lesestoff:
-Zwar kein professionelles Buch, aber eine Einführung von 'Einsteiger zu Einsteiger' ist die Code-Referenz (https://www.arduinoforum.de/referenz.php) im Nachbarforum.
-Oder hier ein Online-Tutorial (http://www.cplusplus.com/doc/tutorial/) zu C++, allerdings in Englisch.

Die Funktionen werden im "void setup" oder davor definiert?
Funktionen kannst Du nicht schachteln, also davor definieren. Jede Funktion, die Du nutzt, muss vorher definiert oder deklariert werden ( damit der Compiler weis, wie sie aufzurufen ist ). In der Arduino-IDE kannst Du sie auch nach dem ersten Aufruf definieren, die IDE ergänzt dann automatisch die fehlende Deklaration. Und meistens funktioniert das auch - ist aber ein Spezifikum der Arduino-Ide, kein C++ Standard.

1. Pulse ist der Name der Funktion?
2. Was bedeutet das (byte pin)?
3. Die Zeile pulse(W3G) bedeutet für das Programm: Führe Funktion "Pulse" am Pin W3G aus?
1. ja
2. Dass Du der Funktion beim Aufruf einen 'byte' Wert übergeben musst.
3. ja, überall wo in der Funktion 'pin' steht, wird nun der Wert W3G verwendet.
Title: Re: Mal wieder der Milis Befehl
Post by: Doc_Arduino on Sep 22, 2020, 05:00 pm
Hallo,

Code: [Select]
void pulse(byte pin)
{
   digitalWrite (pin, HIGH);
   delay (1000);
   digitalWrite (pin, LOW);
}


Das ist eine Funktionsdefinition.

pulse ist der Name der Funktion.
pin ist der Parameter der mit angegeben bzw. mit übergeben werden muss, der Einzige in diesem Bsp.
Dieser Parameter pin hat den Datentyp byte.
Außerdem ist der Parameter pin eine lokale Variable. Sie ist nur in der Funktion sichtbar. Bringt sehr große Vorteile mit sich.

Quote
Die Funktionen werden im "void setup" oder davor definiert?
Innerhalb setup werden keine Funktionen definiert. Entweder vor setup oder nach loop.
Schau dir mal diverse Bsp. der IDE an oder stöbere im Forum.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 05:27 pm
@franz Peter,

Das mit dem Bootloader und USB hat bei meinem Laptop nicht geklappt.
Also benutze ich einen FTDI Adapter.
Ob die Quellen der links gleich sind kann ich dir nicht sagen, müsste ich ausprobieren.

Um mir die Sache einfacher zu machen, gehe ich einen Schritt zurück und werde die delay Version als Funktion umsetzen. Das vereinfacht die Sache. Das Ergebnis werde ich dann hier posten. Und dann mich mit dem millies Befehl auseinander setzen.

Zu den MobaTools sehe ich mir an. Aber eigentlich möchte ich was eigenes machen und nicht copy und paste. Dann verstehe ich nie, wie das funktioniert

Dank an Dich und an Doc Arduino für die Erklärungen zu Funktionen

Gruss
Kay
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 22, 2020, 05:37 pm
Quote
1. Pulse ist der Name der Funktion?
2. Was bedeutet das (byte pin)?
3. Die Zeile pulse(W3G) bedeutet für das Programm: Führe Funktion "Pulse" am Pin W3G aus?
1 und 2 haben dir die anderen ja schon super erklärt.

zu 3:
ja, mit pulse(W3G) übergibst du der Funktion den Inhalt der Variable W3G ... da steht dein Pin drinnen und in der Folge wird dann die Funktion ausgeführt ausgeführt.



Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 22, 2020, 06:02 pm
Es sei denn die Loks kommen zu schnell hintereinander.
Das ist genau der Grund für die Verwendung von millis: Blockadearme Programmierung zur quasi parallelen Verarbeitung von Informationen.

Schleife { Gleis 1 → Gleis 2 → Gleis 3 → ... → Gleis n}



Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 22, 2020, 06:08 pm
Zu den MobaTools sehe ich mir an. Aber eigentlich möchte ich was eigenes machen und nicht copy und paste.
Du wirst merken, wenn Du dir das anschaust: Da ist nix mit Copy und Paste. Die MobaTools sind eine Library, so wie viele andere auch, die Du teilweise benutzt ohne es zu merken. Du programmierst ja auch nicht auf der nackten HW ;) .
Letzendlich sind es Klassen, die Du benutzen kannst, ohne selbst Klassen erstellen zu müssen. Es sind keine fertigen Lösungen (Allerdings sind Beispiele für die Nutzung dabei). Wenn Du so willst ist es ein Werkzeugkasten, der die vorhanden Werkzeuge der Arduino IDE ergänzt, und die Handhabung erleichtert ( aber auch die muss man erst lernen ).

Die Logik deines Programms kommt immer noch von Dir, da helfen die MobaTools nichts. Und auch z.B. die Logik, wie man delay-frei programmiert ändert sich nicht. In meinem Link oben habe ich versucht, das Modellbahner-like zu erklären. Das musst Du verstehen. Nur das Werkzeug dafür ist leichter zu handhaben als die millis.
Das Verständnis für Funktionen, Arrays und später evtl. Strukturen und Klassen nehmen dir die MobaTools auch nicht ab. C++ lernen musst Du trotzdem ;) .
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 22, 2020, 07:07 pm
Das ist genau der Grund für die Verwendung von millis: Blockadearme Programmierung zur quasi parallelen Verarbeitung von Informationen.

Schleife { Gleis 1 → Gleis 2 → Gleis 3 → ... → Gleis n}




Genau deshalb mache ich das ja ☺

Du wirst merken, wenn Du dir das anschaust: Da ist nix mit Copy und Paste. Die MobaTools sind eine Library, so wie viele andere auch, die Du teilweise benutzt ohne es zu merken. Du programmierst ja auch nicht auf der nackten HW ;) .
Letzendlich sind es Klassen, die Du benutzen kannst, ohne selbst Klassen erstellen zu müssen. Es sind keine fertigen Lösungen (Allerdings sind Beispiele für die Nutzung dabei). Wenn Du so willst ist es ein Werkzeugkasten, der die vorhanden Werkzeuge der Arduino IDE ergänzt, und die Handhabung erleichtert ( aber auch die muss man erst lernen ).

Die Logik deines Programms kommt immer noch von Dir, da helfen die MobaTools nichts. Und auch z.B. die Logik, wie man delay-frei programmiert ändert sich nicht. In meinem Link oben habe ich versucht, das Modellbahner-like zu erklären. Das musst Du verstehen. Nur das Werkzeug dafür ist leichter zu handhaben als die millis.
Das Verständnis für Funktionen, Arrays und später evtl. Strukturen und Klassen nehmen dir die MobaTools auch nicht ab. C++ lernen musst Du trotzdem ;) .
Dann nehme ich die ☺

Das wird etwas dauern, aber das bekomme ich schon hin.

Ps Super Hilfsbereit seid ihr!!!
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 08:19 am
Vielen Dank für die Hilfe, ich hab jetzt die delay Version mit einer Funktion versehen, die ich an entsprechender Stelle im Programmablauf aufrufe.

Code: [Select]
/* Weichenschaltung der Gleise 1 -5 Version 2_1
                Funktionen:
                1. Weichenschaltung neu komplett neu aufgesetzt
                2. Programm läuft immer nur, wenn Zug in SBH einfährt (LSHaupt)
                3. Programmierung LS Haupt
                4. V6.0
                5. V7.0 funktioniert nicht.
                6.V8.0 Einzelne Zeilen im Programm durch Funktion ersetzt
*/
// Umbenenen der STM Pins



// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const int LSBG1 = PA8;   // Lichtschranke Gleisbesetzt Gleis 1
const int LSBG2 = PB15;   // Lichtschranke Gleisbesetzt Gleis 2
const int LSBG3 = PB14;   // Lichtschranke Gleisbesetzt Gleis 3
const int LSBG4 = PB13;   // Lichtschranke Gleisbesetzt Gleis 4
const int LSBG5 = PB12;   // Lichtschranke Gleisbesetzt Gleis 5
int LSBG1State = 0;
int LSBG2State = 0;
int LSBG3State = 0;
int LSBG4State = 0;
int LSBG5State = 0;


// Lichtschranke SBH Haupt
const int LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH
int LSHauptState = 0;



// Ausgänge für Relais  der Weichenstellung weiche 1-5
const int W1A = PA0;          // Weiche 1 Abbiegen
const int W1G = PA1;          // Weiche 1 Geradeaus
const int W2A = PA2;          // Weiche 2 Abbiegen
const int W2G = PA3;          // Weiche 2 Geradeaus
const int W3A = PA4;          // Weiche 3 Abbiegen
const int W3G = PA5;          // Weiche 3 Geradeaus
const int W4A = PA6;          // Weiche 4 Abbiegen
const int W4G = PA7;          // Weiche 4 Geradeaus
const int WHauptA = PB0;      // Hauptweiche Abbiegen
const int WHauptG = PB1;     // Hauptweiche Geradeaus
int W1AState = 0;
int W1GState = 0;
int W2AState = 0;
int W2GState = 0;
int W3AState = 0;
int W3GState = 0;
int W4AState = 0;
int W4GState = 0;
int W5AState = 0;
int W5GState = 0;
int WHauptAState = 0;
int WHauptGState = 0;


// variable definieren
// Variablen Relais Ausgaänge für Weichen
bool geschaltetW1A = false;        // Variable für Weiche1 Abbiegen
bool geschaltetW1G = false;        // Variable für Weiche1 Geradeaus
bool geschaltetW2A = false;        // Variable für Weiche2 Abbiegen
bool geschaltetW2G = false;        // Variable für Weiche2 Geradeaus
bool geschaltetW3A = false;        // Variable für Weiche3 Abbiegen
bool geschaltetW3G = false;        // Variable für Weiche3 Geradeaus
bool geschaltetW4A = false;        // Variable für Weiche4 Abbiegen
bool geschaltetW4G = false;        // Variable für Weiche4 Geradeaus
bool geschaltetW5A = false;        // Variable für Weiche5 Abbiegen
bool geschaltetW5G = false;        // Variable für Weiche5 Geradeaus
bool geschaltetWHauptA = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHauptG = false;    // Variable für Weiche3 Geradeaus

int empfindlichkeit = 200;


// Variablen für Lichtschranke Gleis besetzt

bool Gleisbesetzt1 = false;         // Variable für LSBG1
bool Gleisbesetzt2 = false;         // Variable für LSBG2
bool Gleisbesetzt3 = false;         // Variable für LSBG3
bool Gleisbesetzt4 = false;         // Variable für LSBG4
bool Gleisbesetzt5 = false;         // Variable für LSBG5
bool GleisbesetztAll1 = false;       // Variable für alle Gleise besetzt  Benutzt!
bool GleisbesetztAll2 = false;       // Variable für alle Gleise besetzt  Benutzt!
bool UnterbrechungWagon1 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon2 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon3 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon4 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen
bool UnterbrechungWagon5 = false; // Variable um Unterbrechungen der Lichtschranke Abzufangen


unsigned long RELAIS1G_timestore;  // Variable Speicher für Systemzeit.Weiche1
unsigned long RELAIS1A_timestore;
unsigned long RELAIS2G_timestore;  // Variable Speicher für Systemzeit.Weiche2
unsigned long RELAIS2A_timestore;
unsigned long RELAIS3G_timestore;  // Variable Speicher für Systemzeit.Weiche3
unsigned long RELAIS3A_timestore;
unsigned long RELAIS4G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS4A_timestore;
unsigned long RELAIS5G_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAIS5A_timestore;
unsigned long RELAISHauptG_timestore;  // Variable Speicher für Systemzeit.Weiche5
unsigned long RELAISHauptA_timestore;

// Variablen für die Counter damit Befehl nur einmal ausgeführt wird. Erst nach Zustandswechsel der LSBG wieder erneut
unsigned long CounterWHauptA = 0;
unsigned long CounterWHauptA1 = 0;
unsigned long CounterWHauptG = 0;
unsigned long CounterW1A = 0;
unsigned long CounterW1Ageschaltet = 0;
unsigned long CounterW2A = 0;
unsigned long CounterW3A = 0;
unsigned long CounterW4A = 0;
unsigned long CounterW5A = 0;



// Funktionen

void Weicheschalt(byte pin)                // Funktion zum Schalten der Weichen, diese wird bei bedarf aufgerufen
{
  digitalWrite (pin, HIGH);
  delay (1000);
  digitalWrite (pin, LOW);
}

void setup()
{
  // put your setup code here, to run once:



  // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
  pinMode(LSBG1, INPUT);
  pinMode(LSBG2, INPUT);
  pinMode(LSBG3, INPUT);
  pinMode(LSBG4, INPUT);
  pinMode(LSBG5, INPUT);
  pinMode(LSHaupt, INPUT);

  // Pin Mode für Lichtschranken Gleiseinfahrt Gleis 1 - 5 rausgenommen



  // Pin Mode für Gleis an schalten
  pinMode(W1A, OUTPUT);
  pinMode(W1G, OUTPUT);
  pinMode(W2A, OUTPUT);
  pinMode(W2G, OUTPUT);
  pinMode(W3A, OUTPUT);
  pinMode(W3G, OUTPUT);
  pinMode(W4A, OUTPUT);
  pinMode(W4G, OUTPUT);
  pinMode(WHauptA, OUTPUT);
  pinMode(WHauptG, OUTPUT);
}

void loop()
{

  LSHauptState = digitalRead(LSHaupt);                                         // Abfrage ob Zug einfährt. Lichtschranke an der Zufahrt
  if (LSHauptState == HIGH)
  {
    LSBG1State = digitalRead(LSBG1);                                            // abfrage ob SBH voll
    LSBG2State = digitalRead(LSBG2);
    LSBG3State = digitalRead(LSBG3);
    LSBG4State = digitalRead(LSBG4);
    LSBG5State = digitalRead(LSBG5);

    if (LSBG1State == HIGH && LSBG2State == HIGH && LSBG3State == HIGH && LSBG4State == HIGH && LSBG5State == HIGH)  // Abfrage ob alle Gleise besetzt sind
    {
      Weicheschalt(WHauptA);
    }
    else                                                                         // nicht alle Gleise sind besetzt
    {
      Weicheschalt(WHauptG);
    }

    LSBG1State = digitalRead(LSBG1);                                            // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      Weicheschalt(W1G);
    }
    if (LSBG1State == LOW)
    {
      Weicheschalt(W1A);
    }
    LSBG2State = digitalRead(LSBG2);                                            // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      Weicheschalt(W2G);
    }
    if (LSBG2State == LOW)
    {
      Weicheschalt(W2A);
    }
    LSBG3State = digitalRead(LSBG3);                                             // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      Weicheschalt(W3G);
    }
    if (LSBG3State == LOW)
    {
      Weicheschalt(W3A);
    }
    LSBG4State = digitalRead(LSBG4);                                               // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      Weicheschalt(W4G);
    }
    if (LSBG4State == LOW)
    {
      Weicheschalt(W4A);
    }
  }
}


Das funktioniert schon mal prima.

Als nächstes dann die Delay Funktion durch Millis ersetzten...

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 08:42 am
Kleiner Nachtrag bzw Nachfrage:

Wird der Programmablauf durch die Verwendung von Funktionen beschleunigt?

Zumindest wirkt sich das hier so aus.
Beispiel:
Wenn ein Zug in den SBH einfährt schalte ich die Gleise hinter dem Zug (Einfahrt SBH) für 10 Sekunden ab, damit kein 2ter Zug in den SBH einfahren kann.
In der Programmversion ohne die Funktion, war die Zeitspanne zu kurz, sprich wenn der 2te Zug anfuhr reagierte das Programm nicht auf die Lichtschranke um die Weichen umzustellen.

Jetzt, also im Programm mit Funktion, reagiert der einwandfrei. Dann bräuchte ich in diesem Fall erstmal nicht auf millis umzustellen.

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 08:50 am
Hallo Kay,
Als nächstes dann die Delay Funktion durch Millis ersetzten...
mein Vorschlag wäre, als nächstes erstmal auf Arrays umzustellen. Das erleichtert alles was danach kommt ganz wesentlich.

Wird der Programmablauf durch die Verwendung von Funktionen beschleunigt?
Nein, prinzipiell nicht. Aber vielleicht hast Du bei der Umstellung den ganzen Ablauf geändert.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 09:24 am
Wenn ich das Prinzip der Arrays (Ein pool von Zahlen bzw Werten auf die man zugreifen kann) richtig verstanden habe, erkenne ich nicht wo ich die in meinem Programm sinnvoll nutzen kann.

Was kann/soll ich denn in meinem Programm auf Arrays umstellen?

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 23, 2020, 09:49 am
Quote
Was kann/soll ich denn in meinem Programm auf Arrays umstellen?
Du hast in deinem Programm durchnummerierte Variablen.
Weiche 1 bis 5 o.ä.

Das führt zu Codeduplikaten.
zu Copy&Paste Fehlern
erschwert die Wartung. (jeder Fehler muss an 5 Stellern korrigiert werden)

Das ist böse böse und nochmal böse.


Mein Rat:
Verschiedene Dinge in Strukturen
Gleiche artige Dinge in Arrays

Hier:
Alle Daten einer Weiche in eine Struktur.
Alle Weichen Strukturen in ein Array.
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 09:55 am
Was kann/soll ich denn in meinem Programm auf Arrays umstellen?
Vom Prinzip her kannst Du alles, was Du in den Variablennamen durchnumerierst jeweils als ein Array definieren. Also z.B. statt
Code: [Select]
int W1AState = 0;
int W1GState = 0;
int W2AState = 0;
int W2GState = 0;
int W3AState = 0;
int W3GState = 0;
int W4AState = 0;
int W4GState = 0;
int W5AState = 0;
int W5GState = 0;
definierst Du 2 Arrays:
Code: [Select]
int WAState[5];
int WGState[5];
Das machst du überall, wo du die Namen durchnumeriert hast.

Edit: Da die Zahl der Arrayelemente fast überall gleich ist, und auch voneinander abhängt, solltest Du das auch am Anfang als Konstante definieren, und nicht überall fest z.B. die '5' reinschreiben.

Hinterher im Programm hast Du immer mehrere Anweisungsblöcke, die sich nur durch diese Nummer im Variablennamen unterscheiden. Da brauchst Du dann nur noch einen Anweisungsblock, bei dem Du in einer for-Schleife den Index durchzählst.
Das spart viel Tipperei, vermeidet Copy/Paste Fehler und lässt sich einfach erweitern/ändern. Gerade auch im Hinblick auf die Umstellung zum delay-freien Programmablauf. Auch deshalb solltest Du das vorher machen und als erstes angehen.

P.S. Combies Vorschlag mit Strukturen ist natürlich noch besser, erfordert aber auch erstmal das Verständnis für Strukturen. Da musst Du entscheiden ob Du dir dieses Wissen  aneignest bevor es weitergeht, oder ob Du es erstmal bei Arrays belässt.
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 23, 2020, 10:29 am
Quote
Du entscheiden ob Du dir dieses Wissen  aneignest bevor es weitergeht, oder ob Du es erstmal bei Arrays belässt.
Da er da sowieso durch muss, plädiere ich dafür sofort das richtige zu lernen, als mit dem falschen anzufangen.

Umlernen ist immer schwieriger als sofort das richtige lernen.
Man bekommt Gewohnheiten und Falsches kaum wieder aus dem Kopf heraus. Gerade in Not, oder wenn man unsicher ist, fällt man zurück in alte Irrtümer.

Das hat evolutionäre Gründe, als noch hinter jedem Strauch ein Löwe lauern konnte. 
Da waren schnelle Entscheidungen ohne vollständiges Wissen erforderlich.
Das Verhalten ist beim Bau einer Modellbahn nicht wirklich erforderlich, ja, eher hinderlich.

Hier besteht die Chance sofort das richtige zu lernen.

Eine Weiche zu betrachten, diese in eine Struktur/Klasse zu stopfen.
Das dann auf viele Weichen in einem Array auszuweiten.
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 10:39 am
Da er da sowieso durch muss, plädiere ich dafür sofort das richtige zu lernen, als mit dem falschen anzufangen.

Umlernen ist immer schwieriger als sofort das richtige lernen.
Ok, sehe ich jetzt nicht ganz so eng. Würde in letzter Konsequenz bedeuten, dass man ein 1000 seitiges C++ Buch von Anfang bis Ende durcharbeiten muss, bevor man sein erstes Projekt starten dürfte. Denn mit jedem weiteren Wissen dürfte das Projekt am Ende anders aussehen.

Letzendlich muss er das entscheiden. Der Schritt von seinem Code-Wust zu den Arrays ist auf jeden Fall größer und bringt mehr als dann der Schritt zu Strukturen. Andererseits - soo kompliziert ist das mit den Strukturen jetzt auch nicht ...
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 23, 2020, 11:01 am
Hach... ich weiß....

Halte allerdings Strukturen für wichtiger, als Arrays.
Ist allerdings nur eine persönliche Einstellung.


Im Grunde hangelt man sich sowieso von Fehler zu Fehler.
Es ist jeweils interessant, wie lange man im Fehler verharrt.
Denn verharren wird zur Gewohnheit.
Und damit zementiert es.

Youtube Tipp:  "Kate Gregory Stop Teaching C"
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 11:12 am
Nicht streiten :-)

Vielleicht etwas allgemeines, ich will nicht der C++ Guru werden und werde auch nicht, glaub ich, Seitenweise Programme schreiben.
Ich möchte nur Abläufe auf meiner analogen Modellbahn steuern. Das von mir verwendete Board hat "nur" 26 ein bzw Ausgänge. Sprich die Programme werden eher klein bleiben.

Ich möchte auch keinen verschrecken, der mir Tips gibt weil ich Dinge (erstmal) nicht umsetzte.

Deshalb auch nochmals zu den Arrays zurück. Die machen doch hauptsächlich Sinn, wenn Variablen im Programm mehrfach auftauchen?
Die Variablen für die Weichen (zB W1A) tauchen aber nur einmal auf.

Bei Funktionen ist es mir klar, anstelle von 10 mal 3 Anweisungen. nur 1 mal 3 Anweisungen und auf die von 10 Verschiedenen Stellen zugreifen.

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 11:31 am
Nicht streiten :-)
Wer streitet hier :) ?

Deshalb auch nochmals zu den Arrays zurück. Die machen doch hauptsächlich Sinn, wenn Variablen im Programm mehrfach auftauchen?
Nein, das hat damit nichts zu tun.

Die Variablen für die Weichen (zB W1A) tauchen aber nur einmal auf.
zum einen taucht auch die mehrfach auf, zum anderen geht es darum, dass Du auch noch W2A, W3A und W4A hast. Und die kannst Du alle in einem Array zusammenfassen.

Mit Arrays wird z.B. aus diesem Bandwurm:
Code: [Select]
   LSBG1State = digitalRead(LSBG1);                                            // Abfrage ob Zug auf Gleis 1 steht.
    if (LSBG1State == HIGH)
    {
      Weicheschalt(W1G);
    }
    if (LSBG1State == LOW)
    {
      Weicheschalt(W1A);
    }
    LSBG2State = digitalRead(LSBG2);                                            // Abfrage ob Zug auf Gleis 2 steht.
    if (LSBG2State == HIGH)
    {
      Weicheschalt(W2G);
    }
    if (LSBG2State == LOW)
    {
      Weicheschalt(W2A);
    }
    LSBG3State = digitalRead(LSBG3);                                             // Abfrage ob Zug auf Gleis 3 steht.
    if (LSBG3State == HIGH)
    {
      Weicheschalt(W3G);
    }
    if (LSBG3State == LOW)
    {
      Weicheschalt(W3A);
    }
    LSBG4State = digitalRead(LSBG4);                                               // Abfrage ob Zug auf Gleis 4 steht.
    if (LSBG4State == HIGH)
    {
      Weicheschalt(W4G);
    }
    if (LSBG4State == LOW)
    {
      Weicheschalt(W4A);
    }


diese kurze Schleife:
Code: [Select]
   for ( int GleisIx = 0; GleisIx<AnzahlGLeise, GleisIx++ ) {
    LSBGState[GleisIx] = digitalRead(LSBG[GleisIx]);         // Abfrage ob Zug auf GleisIx steht.
    if (LSBGState[GleisIx] == HIGH)
    {
      Weicheschalt(WG[GleisIx]);
    }
    if (LSBGState[GleisIx] == LOW)
    {
      Weicheschalt(WA[GleisIx]);
    }
  }

Und das hast Du an vielen Stellen so!
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 23, 2020, 11:48 am
Was kann/soll ich denn in meinem Programm auf Arrays umstellen?
Ohne Veränderung der Logik könnte es so aussehen (ungetestet):

Code: [Select]
const byte AnzahlGleise = 5;
const byte AnzahlWeichen = AnzahlGleise - 1;
enum {Gleis1, Gleis2, Gleis3, Gleis4, Gleis5};

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};
bool LSBGState[AnzahlGleise] = {0, 0, 0, 0, 0};

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH
bool LSHauptState = 0;

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlWeichen] = {PA0, PA2, PA4, PA6};          // Weichen Abbiegen
const byte WG[AnzahlWeichen] = {PA1, PA3, PA5, PA7};          // Weichen Geradeaus
const byte WHauptA = PB0;      // Hauptweiche Abbiegen
const byte WHauptG = PB1;     // Hauptweiche Geradeaus
bool WAState[AnzahlWeichen] = {0, 0, 0, 0};
bool WGState[AnzahlWeichen] = {0, 0, 0, 0};
bool WHauptAState = 0;
bool WHauptGState = 0;

// variable definieren
// Variablen Relais Ausgaänge für Weichen
bool geschaltetWA[AnzahlGleise] = {false, false, false, false, false};    // Variable für Weichen Abbiegen
bool geschaltetWG[AnzahlGleise] = {false, false, false, false, false};    // Variable für Weichen Geradeaus
bool geschaltetWHauptA = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHauptG = false;    // Variable für Weiche3 Geradeaus

unsigned long RELAISA_timestore[AnzahlGleise] = {0, 0, 0, 0, 0}; // Variable Speicher für Systemzeit.Weichen Abbiegen
unsigned long RELAISG_timestore[AnzahlGleise] = {0, 0, 0, 0, 0}; // Variable Speicher für Systemzeit.Weichen Geradeaus
unsigned long RELAISHauptA_timestore;
unsigned long RELAISHauptG_timestore;

// Variablen für die Counter damit Befehl nur einmal ausgeführt wird. Erst nach Zustandswechsel der LSBG wieder erneut
unsigned long CounterWHauptA = 0;
unsigned long CounterWHauptA1 = 0;
unsigned long CounterWHauptG = 0;
unsigned long CounterW1A = 0;
unsigned long CounterW1Ageschaltet = 0;
unsigned long CounterW2A = 0;
unsigned long CounterW3A = 0;
unsigned long CounterW4A = 0;
unsigned long CounterW5A = 0;

void setup()
{
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
    pinMode(LSBG[g], INPUT);
  }
  pinMode(LSHaupt, INPUT);

  for (byte w = 0; w < AnzahlWeichen; w++)
  {
    // Pin Mode für Gleis an schalten
    pinMode(WA[w], OUTPUT);
    pinMode(WG[w], OUTPUT);
  }
  pinMode(WHauptA, OUTPUT);
  pinMode(WHauptG, OUTPUT);
}

void loop()
{
  LSHauptState = digitalRead(LSHaupt);     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
  if (LSHauptState == HIGH)
  {
    for (byte g = 0; g < AnzahlGleise; g++)
    {
      LSBGState[g] = digitalRead(LSBG[g]);    // abfrage ob SBH voll
    }

    if (LSBGState[Gleis1] == HIGH && LSBGState[Gleis2] == HIGH && LSBGState[Gleis3] == HIGH && LSBGState[Gleis4] == HIGH && LSBGState[Gleis5] == HIGH) // Abfrage ob alle Gleise besetzt sind
    {
      digitalWrite (WHauptA, HIGH);
      RELAISHauptA_timestore = millis();
    }
    if (millis() - RELAISHauptA_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptA, LOW);
      WHauptAState = LOW;
    }

    else
      //    if (LSBGState[Gleis1] == LOW || LSBG2State == LOW || LSBG3State == LOW || LSBG4State == LOW || LSBG5State == LOW)  // Abfrage ob alle Gleise besetzt sind                                          // nicht alle Gleise sind besetzt
    {
      digitalWrite (WHauptG, HIGH);
      RELAISHauptG_timestore = millis();
    }
    if (millis() - RELAISHauptG_timestore > 1000 ) //Schaltzeit Relais
    {
      digitalWrite(WHauptG, LOW);
      WHauptGState = LOW;
    }

    for (byte g = 0; g < AnzahlGleise; g++)
    {
      LSBGState[g] = digitalRead(LSBG[g]);  // Abfrage ob Zug auf Gleis g steht.
      if (LSBGState[g] == HIGH)
      {
        digitalWrite (WG[g], HIGH);
        RELAISG_timestore[g] = millis();
      }

      if (millis() - RELAISG_timestore[g] > 1000 ) //Schaltzeit Relais 1 Sek.
      {
        digitalWrite(WG[g], LOW);
        WGState[g] = LOW;
      }

      if (LSBGState[g] == LOW)
      {
        digitalWrite (WA[g], HIGH);
        RELAISA_timestore[g] = millis();
      }

      if (millis() - RELAISA_timestore[g] > 1000 ) //Schaltzeit Relais
      {
        digitalWrite(WA[g], LOW);
        WAState[g] = LOW;
      }
    }
  }
}
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 12:57 pm
Das ist der Punkt an dem ich Angst bekomme ;)
Jetzt hab ich aber verstanden wozu Arrays da sind, um mich daran zu begeben muß ich mir aber noch ein paar Grundlagen beibringen. Denn wenn ich ehrlich bin blicke ich durch meinen Code besser durch als durch die beiden Array Codes von euch.... Da fehlt mir doch noch so einiges.

Zum Üben werde ich jetzt als erstes mal in dem anderen Programm von mir, die einzelnen Zeilen durch Funktionen ersetzten.

Gruß und nochmals Danke für die Hilfe


Kay

Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 23, 2020, 01:37 pm
Quote
Vielleicht etwas allgemeines, ich will nicht der C++ Guru werden und werde auch nicht, glaub ich, Seitenweise Programme schreiben.
Betrachte es so: "seitenweise" sind deine ersten Programme auch schon gewesen. Künftig wirst du durch geschickte Anwendung nur ein MEHR an Funktionalität in deine Programme packen ohne dass sie wesentlich länger werden.

Irgendwann kommen vieleicht Start-Ziel Fahrten hinzu, dann eine Flankensicherung, dann...
Das ist das schöne an Software - es ist schneller umgebaut als eine Weiche im Gleisschotter.
Geht etwas nicht wie gewünscht, na dann halt wieder alten Sketch draufgespielt und weiter gespielt.

Mach mal dein Funktionendingens und dann gib bescheid wenns der nächste Schritt werden soll.

Ob Array oder Struct ist so eine Sache. Tendenziell würde ich auch das Array nehmen, aber in Hinsicht auf die zukommende Tipparbeit, würde ich fast eher mit dem struct weitermachen um dann die Änderung in einem Aufwasch zu machen...


Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 03:10 pm
Das ist der Punkt an dem ich Angst bekomme ;)
Must Du nicht, wir sind ja bei dir  :D .

Jetzt hab ich aber verstanden wozu Arrays da sind, um mich daran zu begeben muß ich mir aber noch ein paar Grundlagen beibringen.
Das ist doch schonmal eine gute Grundlage. Hast Du dir den obigen Link zur 'delay-freien Programmierung (https://www.stummiforum.de/viewtopic.php?f=21&t=163493&sid=7037bcf33f7d56f6f7ccdc29ce4c2c21)' schonmal angeschaut? Beim 2. Teil habe ich da auch was zu Arrays geschrieben in einer ähnlichen Anwendung.

@noiasca:
Ob Array oder Struct ist so eine Sache.
Das ist keine Alternative. Arrays können Structs nicht ersetzen und umgekehrt. Array's braucht man in diesem Fall immer. Struct's wäre noch eine Erweiterung der Strukturierung. Dann käme man zu 'Arrays of Structs'.
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 23, 2020, 04:18 pm
ich meinte auch nicht entweder oder verwenden, sondern welches der beiden der nächste Schritt sein soll (siehe Satz davor!).
brauchen wird er beides...
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 04:24 pm
Sorry, dann hatte ich das falsch verstanden. Um den Sketch einzudampfen und die Tipparbeit bei weiteren Schritten zu reduzieren, sind aber erstmal die Arrays angebracht. Wo Structs Tipparbeit ersparen ( ausser bei der Variablendefinition ) sehe ich erstmal nicht. Beim Zugriff auf die Elemente ist es eher mehr Tipperei ;) .
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 23, 2020, 05:23 pm
Vorsicht: Es folgt eine Meinung.


Wie schon mal gesagt, aus meiner Sicht zählt hier das Mantra:
> Fasse zusammen, was zusammen gehört.

Das ist in erster Linie die Struktur pro Weiche.
In zweiter Line, die Weichen in einem Array.

Polemik:
Erst die Weichen Bestandteile in ein halbes Dutzend Arrays zu pressen, um die in nächsten Schritt wieder raus zu holen, ist das freimütige und eigentlich unnötige Eingeständnis eines Irrweges.


Aber wie auch immer....
Meine Sorge/Verwirrung soll es nicht sein.
Und dass die Multiarray Variante verwirrt, haben wir ja eben gesehen.
> Das ist der Punkt an dem ich Angst bekomme ;)
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 23, 2020, 05:27 pm
jetzt bekomme ich fast Angst wenn sich deine Meinung mit meiner deckt ...
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 05:36 pm
Das ist in erster Linie die Struktur pro Weiche.
In zweiter Line, die Weichen in einem Array.
Vorsicht, auch eine Meinung ;) :
Dann aber erstmal das ganze Programm für eine Weiche/2 GLeise mit Struct neu erstellen, und dann per Array auf mehrere Gleise aufbohren. Wir reden hier über ein bereits existierendes Programm. Den Bandwurm wie er jetzt ist, erst auf Struct zu ändern, und dann per Array einzudampfem macht mMn erst Recht keinen Sinn.

Ich befürchte allerdings, das wir mit dieser Diskussion unseren Kay komplett verwirren.


P.S. Ich kenne auch kein C++ Buch, dass die Struct vor den Arrays erklärt.
Title: Re: Mal wieder der Milis Befehl
Post by: Tommy56 on Sep 23, 2020, 05:45 pm
Manches Mal ist es sinnvoller, das Bestehende (uneffektive) beiseite zu legen und neu anzufangen. Sonst verwirrt man sich in den eigenen Beschränkungen des Altcodes.

Gruß Tommy
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 05:56 pm
Vorsicht, auch eine Meinung ;) :
Dann aber erstmal das ganze Programm für eine Weiche/2 GLeise mit Struct neu erstellen, und dann per Array auf mehrere Gleise aufbohren. Wir reden hier über ein bereits existierendes Programm. Den Bandwurm wie er jetzt ist, erst auf Struct zu ändern, und dann per Array einzudampfem macht mMn erst Recht keinen Sinn.

Ich befürchte allerdings, das wir mit dieser Diskussion unseren Kay komplett verwirren.


P.S. Ich kenne auch kein C++ Buch, dass die Struct vor den Arrays erklärt.
Da ich eh nix verstanden hab, hab ich auch nicht zugehört :-)

Falls es nicht anders geht, würde ich ja auch den Sketch neu machen. Nur würde ich mal behaupten, das ich zunächst noch einiges lernen muss. Bzw einiges noch besser verstehen muss. Sonst fang ich noch mehrfach neu an. Das schöne ist, ich hab ja was lauffähiges was ich nach und nach verbessern und ausbauen kann.
Es wird ja auch nicht der letztte Sketch bleiben.
Pendelzug, ampelschaltung, Blitzer mit geschwindigkeitsmessung. Tag / nachtschaltung. Beleuchtungssimulation in Häusern....
Also noch viele Möglichkeiten Bandwürmer zu Basteln :-)
Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 23, 2020, 06:30 pm
Quote
P.S. Ich kenne auch kein C++ Buch, dass die Struct vor den Arrays erklärt.
Das erste Buch welches ich aus dem Regal gezogen habe.
Der  C++ Programmierer(C++14) von Ulrich Breymann
struct Seite 85
Array Seite 201

Seitenzahlen dem Register entnommen.

---

Aber das ist mir nicht wichtig, da meiner Ansicht nach die konkrete Anwendung die Reihenfolge vorgibt.
In Lehre und Ausbildung mag das anders sein.


Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 23, 2020, 06:32 pm
Quote
Pendelzug, ampelschaltung, Blitzer mit geschwindigkeitsmessung. Tag / nachtschaltung. Beleuchtungssimulation in Häusern....
dann wird's Zeit für millis ... gell ...
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 06:40 pm
dann wird's Zeit für millis ... gell ...
Japp, womit wir wieder beim Eingangsposting wären.

Gruss

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 23, 2020, 06:59 pm
Das schöne ist, ich hab ja was lauffähiges was ich nach und nach verbessern und ausbauen kann.
Nun ja, das kann ich leider nicht bestätigen. Ich habe allerdings keinen Schattenbahnhof, keinen STM32, da bin ich mit einer Aussage mal ganz vorsichtig. Aber wenn ich Dein Programm (mit delay) auf einen Mega2560 umschreibe und LEDs anschließe, bekomme ich eine Blinkschaltung. Wie das mit der Funktion eines Schattenbahnhofs zusammenhängen soll, erschließt sich mir nicht.

Mein Programm in #44 macht dieses Blinken auch, so gesehen gibt es eine Übereinstimmung.

Was also ist die eigentliche Idee? Wird diese Idee von Deinem Programm wirklich realisiert?

Wenn Du zu #44 Fragen hättest, könntest Du fragen.

Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 23, 2020, 08:14 pm
Hallo agmue,

Das Programm macht folgendes:
Bei der Einfahrt in den SBH (Lichtschranke LSHaupt) wird auf 4 Gleisen geschaut ob da ein Zug steht (lichtschranken LSGB1 - 4)
Dementsprechend wird einer der beiden Anschlüsse der jeweiligen weiche geschaltet.

Beispiel:
Lok steht auf Gleis 1. LSBG1 ist High. Eine weitere Lok fährt in den SBH LShaupt geht auf High. Somit wird der Anschluss von weiche 1 der auf geradeaus schaltet (W1G)für 1 Skunde auf Higv geschaltet. Die genauso bei den Gleisen 2, 3 ,4 . Die Weichenstellung für Gleis5 ergibt sich dann automatisch.
Sind alle 5 Gleise besetzt, wird die Weiche vor dem SBH (WhauptA) auf abbiegen geschaltet, damit der einfahrrnd3 Zug am SBH vorbei geleitet wird.

Das funktioniert auch.

Morgen lade ich dein Programm mal in ein Board und probiere das aus. Danke

Gruss

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 23, 2020, 08:41 pm
Das funktioniert auch.
Glaube ich Dir, nur noch nicht in menem Kopf :)

Ich hätte die Weiche auf Vorbeifahrt gewechselt, wenn die Lichtschranke besetzt meldet. Du machst das erst, wenn der nächste Zug kommt. Dann liegt das Blinken wohl an LShaupt. Da denke ich nochmal drüber nach.

Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 23, 2020, 11:11 pm
Das Programm macht folgendes:
Bei der Einfahrt in den SBH (Lichtschranke LSHaupt) wird auf 4 Gleisen geschaut ob da ein Zug steht (lichtschranken LSGB1 - 4)
Dementsprechend wird einer der beiden Anschlüsse der jeweiligen weiche geschaltet.
Solange die Haupt-LS belegt ist, werden die Weichen aber ständig geschaltet. Immer eine nach der anderen und dann wieder von vorne. Wenn man da jetzt Led's anschließt blinkt es eben.

Ob das für die Antriebe so gut ist, ist eine andere Frage....
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 07:22 am
Ja die schalten immer wenn ein Zug einfährt. Das geht, ist aber auf Dauer blöd, da hast Du Recht.
Deshalb kommt noch eine Variable hinzu, die gesetzt wird, wenn das Gleis besetzt ist und die Weiche dann einmal geschaltet hat, selbiges natürlich auch wenn das Gleis frei ist. Deshalb sind die Variablen "geschaltetW1A" usw ja schon definiert.
Vorher wollte ich aber den Teil des umschalten lauffähig haben und den millis Befehl umgesetzt haben.
Ich will Stück für Stück die Funktionen programmieren, sonst Blicke ich nicht mehr durch. 

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 07:29 am
Nun ja, das kann ich leider nicht bestätigen. Ich habe allerdings keinen Schattenbahnhof, keinen STM32, da bin ich mit einer Aussage mal ganz vorsichtig. Aber wenn ich Dein Programm (mit delay) auf einen Mega2560 umschreibe und LEDs anschließe, bekomme ich eine Blinkschaltung. Wie das mit der Funktion eines Schattenbahnhofs zusammenhängen soll, erschließt sich mir nicht.

Mein Programm in #44 macht dieses Blinken auch, so gesehen gibt es eine Übereinstimmung.

Was also ist die eigentliche Idee? Wird diese Idee von Deinem Programm wirklich realisiert?

Wenn Du zu #44 Fragen hättest, könntest Du fragen.


So, hab den Code getestet. Geht LSHaupt auf High, ziehen die Relais an. Fallen aber nicht mehr ab.

Blöde Frage von mir: Ich hab den Sketch in eine leere IDE kopiert, muß ich dabei irgendwas beachten?

GRuß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: Doc_Arduino on Sep 24, 2020, 11:45 am
Hallo,

wenn der Sketch fehlerfrei kompiliert, dann fehlt dem nichts. Dann liegt der Fehler nur in der Logik in dessen was man programmiert hat. Zum debuggen baut man gern serielle Ausgaben rein um zu sehen ob irgendwelche Zähler oder Statusvariablen etc. reagieren oder ob der Programmablauf überhaupt an einer bestimmten Stelle vorbeikommt und abgearbeitet wird oder eben auch nicht.
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 24, 2020, 12:34 pm
Wie sieht denn die Gleisharfe Deines Schattenbahnhofs aus?



(https://forum.arduino.cc/index.php?action=dlattach;topic=706058.0;attach=382991)
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 01:39 pm
sieht so aus:

(https://up.picr.de/39503864gm.jpg)


Bei deiner Zeichnung fehlt das umfahrungsgleis

Gruß

Kay.
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 24, 2020, 02:05 pm
Bei deiner Zeichnung fehlt das umfahrungsgleis
Bei mir wäre das Gleis 5. Wenn keine Weiche auf Abbiegen steht, fährt der Zug durch. Das ist einfacher zu programmieren. Aber sooo einfach willst Du es ja nicht ::)

Und Weiche 1 gehört zu Gleis 5, nicht gut.

Ich denke ...

Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 02:31 pm
Bei mir wäre das Gleis 5. Wenn keine Weiche auf Abbiegen steht, fährt der Zug durch. Das ist einfacher zu programmieren. Aber sooo einfach willst Du es ja nicht ::)

Und Weiche 1 gehört zu Gleis 5, nicht gut.

Ich denke ...


Ne ich kann 5 Loks abstellen, und kann immer noch durchfahren du nur 4 :-)

Einfach ist das so auch für Gleis 5 brauch ich keine Weichen extra zu stellen, das ergibt sich.

Das ist noch ne alte Zeichung, sorry Weiche 1 ist bei Gleis 5.
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 24, 2020, 02:37 pm
Und Weiche 1 gehört zu Gleis 5, nicht gut.
Ja, sowas sollte man nicht machen. Das fällt einem irgendwann auf die Füße.

Und Die Idee von agmue, dass Umfahrgleis einfach als 6. Gleis zu definieren ( 5 Schattenbahnhofgleise hast Du ja schon ) hat auch was. Die Ruhestellung aller Weichen führt durchs Umfahrgleis. Ist ein Schattenbahnhofgleis frei, wird die entsprechende Weiche gestellt, wenn nicht, geht's automatisch durchs Umfahrgleis. Allerdings ist die wieweit das schon fest aufgebaut ist. So wie es jetzt in deinem Plan aussieht, muss man für die Sbf-Einfaht dann evtl. 2 Weichen stellen.
Sieht nach einem guten Plan aus  8)

------------------------------------------

Ne ich kann 5 Loks abstellen, und kann immer noch durchfahren du nur 4 :-)
Ist ja nur ne Frage von ein Gleis mehr ;)

Einfach ist das so auch für Gleis 5 brauch ich keine Weichen extra zu stellen, das ergibt sich.
Für's Programm ist es aber einfacher für den Sonderfall 'Sbf belegt' nichts tun zu müssen.

Das ist noch ne alte Zeichung, sorry Weiche 1 ist bei Gleis 5.
Bei deiner Zeichnung ist doch W1 bei Gleis 5. Und genau das ist ja das Problem: Weiche 1 sollte die Zufahrt zu Gleis 1 steuern - das wäre konsequent. Geht dann bis Weiche 5, die die Zufahrt zu GLeis 5 steuert und ansonsten geradeaus durch.

Aber programmtechnisch machbar ist das alles - ist nur eben die Frage wie es am einfachsten ist :D
Title: Re: Mal wieder der Milis Befehl
Post by: Tommy56 on Sep 24, 2020, 02:43 pm
Aber programmtechnisch machbar ist das alles - ist nur eben die Frage wie es am einfachsten ist :D
Und bei welcher Variante man auch in 2 Jahren noch den Überblick hat.

Gruß Tommy
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 02:55 pm
Ja, sowas sollte man nicht machen. Das fällt einem irgendwann auf die Füße.

Und Die Idee von agmue, dass Umfahrgleis einfach als 6. Gleis zu definieren ( 5 Schattenbahnhofgleise hast Du ja schon ) hat auch was. Die Ruhestellung aller Weichen führt durchs Umfahrgleis. Ist ein Schattenbahnhofgleis frei, wird die entsprechende Weiche gestellt, wenn nicht, geht's automatisch durchs Umfahrgleis. Allerdings ist die wieweit das schon fest aufgebaut ist. So wie es jetzt in deinem Plan aussieht, muss man für die Sbf-Einfaht dann evtl. 2 Weichen stellen.
Sieht nach einem guten Plan aus  8)

------------------------------------------
Ist ja nur ne Frage von ein Gleis mehr ;)
Für's Programm ist es aber einfacher für den Sonderfall 'Sbf belegt' nichts tun zu müssen.
Bei deiner Zeichnung ist doch W1 bei Gleis 5. Und genau das ist ja das Problem: Weiche 1 sollte die Zufahrt zu Gleis 1 steuern - das wäre konsequent. Geht dann bis Weiche 5, die die Zufahrt zu GLeis 5 steuert und ansonsten geradeaus durch.

Aber programmtechnisch machbar ist das alles - ist nur eben die Frage wie es am einfachsten ist :D
Das ist ein alter Plan... Weiche 1 ist selbstredend an Gleis 1 und weiche 2 an Gleis 2 usw

der Gleisplan ist folgender:

(https://up.picr.de/39504202kz.jpg)

2 SBH´s die folgende Funktionen haben sollen:
1. Ein Zug rein, ein anderer raus
2. Ein Zug rein, selber zug raus (Wende)
3. Ein Zug an der einen seite der Platte rein und an der anderen wieder raus.
4. Beide SBH,s sollen unabhängig voneinander funktionieren.

Ein paar Eckdaten:

Die beiden Ovale links oben und rechts unten sind Wendeln, da die SBHS auf der untersten von 3 Ebenen liegen.

Mir ist gestern auch noch aufgefallen, das ich die Weichen nicht abhängig von der Gleiseinfahrt machen darf, also so wie ich es jetzt gelöst habe.

Es ist noch nix gebaut, sprich ich kann auch den Gleisplan noch ändern, in alle Einfahrten und die Umfahrung hintereinander.

Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 24, 2020, 03:24 pm
Naming Things - eins der 2 Probleme in der Computertechnik.

Eigentlich soll es dem Code komplett egal sein, ob Gleis 1 oder 5 das Durchfahrts-Gleis ist, ebenso ob die zweite Weiche 1 oder Franzi heißt.

Wenn du in das Gleis 1 willst und du über die Weiche Franzi im Bogen einfahren musst, dann bau deine Funktionen (Methoden) so, dass du ihr mitgibst

Mit der Weiche Franzi
Auf Abbiegen
ins Gleis 1

p.s. Bitte poste Bilder ins Forum - nicht auf externe Hoster...





Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 24, 2020, 04:34 pm
Es ist noch nix gebaut, sprich ich kann auch den Gleisplan noch ändern, in alle Einfahrten und die Umfahrung hintereinander.
Dann würde ich das noch entsprechend anpassen - ist mMn einfach 'geradliniger' und direkter umsetzbar. Vielleicht ergäb sich damit sogar noch die Möglichkeit ein weiteres Gleis unterzubringen.

(https://forum.arduino.cc/index.php?action=dlattach;topic=706058.0;attach=383021)
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 24, 2020, 05:06 pm
sieht so aus:

(https://up.picr.de/39503864gm.jpg)

Was hast Du denn mit den LS am Gleisanfang vor? In deinem Sketch kommen die gar nicht vor. Und wer schaltet den Fahrstrom ab, damit der Zug auch im Sbf-Gleis stehen bleibt?

Mein Sbf funktioniert ähnlich - da sind auch jeweils LS am Blockende. Die schalten aber den Fahrstrom per HW aus. Es war mir zu 'kitzelig' mich da vollkommen auf den Prozessor zu verlassen - im Bahnverkehr gilt 'safety first'  ;)
Ich nutze allerdings auch die Zufahrtgleise/Wendel zum Abstellen von Zügen. Das sind dann einfach hintereinanderliegende Blockabschnitte. So komme ich immerhin auf imsgesamt gut 50 Blöcke ( Die verwaltet übrigens ein ganz normaler 8-Bit ATMega. Und ohne Structs und Klassen ;) . Das gab die Programmiersprache die ich damals benutzt hatte gar nicht her. ).

P.S. Wie sind deine LS angebracht - d.h. was passiert bei den Lücken zwischen den Wagen? Gibt es da jeweils eine Impuls, oder überbrückt die LS das. Auch sowas muss man gegebenenfalls in der SW berücksichtigen.
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 24, 2020, 05:16 pm
Käme doch nur auf die Fahrrichtung an: bei der Einfahrt über West W1 fragst auf den ersten LOW/HIGH von LSBG5 (der vorderste Wagen ab), LSEG5 wird mit jeden Wagen pulsen, aber soll egal sein.
Einfahrt über Ost, dürfte es nicht geben, weil da keine Weichen beschriftet sind.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 05:28 pm
Hallo Franz Peter,

LSH in der Zeichnung ist LSHaupt im Sketch.
Die Abschaltung der Gleise, bzw die Fahrt der Lokomotive bis zum erreichen der Endposition LSBGxübernimmt ein anderer Arduino. Der schaltet auch die Zufahrt zum SBH ab, wenn LShaupt schaltet
Das Programm hab ich theoretisch fertig, theoretisch weil, Bandwurm :-)

Bist du im Forum Alte Modellbahn? Wenn ja könntest du in meinen thread "neue Anlage "mein Nick ist da KGBRUS, schauen. Da steht alles drin.
Da dort aber niemand auf meine Arduino Berichte reagiert, denke ich mal nicht :-)
Zum Abfangen der Zwischenräume werde ich zwei oder drei Lichtschranken nebeneinander betreiben. Brauche ich aber nur bei LSEGx sprich bei der Einfahrt in die Einzelnen Gleise

Gruss

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 24, 2020, 05:33 pm
Käme doch nur auf die Fahrrichtung an: bei der Einfahrt über West W1 fragst auf den ersten LOW/HIGH von LSBG5 (der vorderste Wagen ab), LSEG5 wird mit jeden Wagen pulsen, aber soll egal sein.
Einfahrt über Ost, dürfte es nicht geben, weil da keine Weichen beschriftet sind.
Von Prinzip richtig nur muss bei LSEG (lichtschranke Einfahrt) sichergestellt werden, das der Zug nicht so steht, das die LS zwischen 2 Wagons durch scheint. Dann steht der Rest noch auf dem Hauptgleis. Sprich, wenn LSBG (lichtschranke gleis besetzt) und LSEG high sind, ist der Zug zu lang für das Gleis und muss wieder raus fahren.
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 24, 2020, 05:51 pm
Die Abschaltung der Gleise, bzw die Fahrt der Lokomotive bis zum erreichen der Endposition LSBGxübernimmt ein anderer Arduino. Der schaltet auch die Zufahrt zum SBH ab, wenn LShaupt schaltet
Das Programm hab ich theoretisch fertig, theoretisch weil, Bandwurm :-)
Ist das nicht unnötig kompliziert und aufwändig? Das schafft ein Arduino doch alles locker. Und der weis dann auch über alles Bescheid und es ist keine Abstimmung notwendig. Das Fahren, Stoppen und Weichenstellen gehört doch logisch alles zusammen.

Bist du im Forum Alte Modellbahn?
Wie Du schon vermutet hast - nein. Wenn treibe ich mich eher im Stummiforum rum. Wenn bei meinem Fuhrpark auch ein paar über 40 Jahre alte Schätzchen dabei sind, ist es insgesamt doch eher eine moderne MoBa - auch wenn keine einzige Lok einen Decoder hat ;)

Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 24, 2020, 05:55 pm
Quote
Von Prinzip richtig nur muss bei LSEG (lichtschranke Einfahrt) sichergestellt werden,
Das ist doch auch einfach: wenn das LSBG meldet (also ein Zug angekommen) und die letzten Statuswechsel von LSEG noch "jung" oder LSEG sogar HIGH ist, heißt das dass der Zug da drüber ragt. Damit hast du das Kriterium den Zug weiterzuschicken.

Wobei sinnvoller wäre, vorher die Zuglänge zu ermitteln und ihn dann auf ein passendes - lang genuges - freies Gleis zu senden. Ich nehme an, das macht man in echt auch so, und das "Weiterschicken" ist eher der Worstcase ;-)
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 24, 2020, 06:26 pm
Wobei sinnvoller wäre, vorher die Zuglänge zu ermitteln und ihn dann auf ein passendes - lang genuges - freies Gleis zu senden.
Sicher, so mache ich das in meinem Sbf auch.
Aber wir sollten ihn nicht gleich überfordern und verschrecken  ;) . Immer eins nach dem anderen. Mit der einfacheren Variante kann er auch erstmal Erfahrung sammeln  8)
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 24, 2020, 07:58 pm
Zu Deiner Variante mit delay: Da die Weichen alle nacheinender geschaltet werden, benögt der Schaltzyklus 5 Sekunden oder mehr. Da fällt das "Blinken" nicht so auf. Mit millis geht der Zyklus schneller, da merkt man es dann. Man könnte Deine delay-Variante beschleunigen, in dem erst alle Weichen gestellt werden, dann die Verzögerung, dann alle Ausgänge auf LOW. Dann braucht es nur eine Sekunde.

Neben der Problematik mit den millis fehlt mir eine (gut erkennbare) Schrittkette (=endlicher Automat, =finite state machine). Ja, das jetzt auch noch. Ist bei mir nur ein switch/case und zumindest für mich erschließt sich der Ablauf viel einfacher. Ein Vergleich der Anzahl der Variablen macht das schon plausibel.

Dein Durchfahrgleis kannst Du später ergänzen, ich bleibe vorerst bei meiner einfachen Harfe. Durchfahrgleis ist mit D markiert.

Ne ich kann 5 Loks abstellen, und kann immer noch durchfahren du nur 4 :-)
Und schon habe ich ein Gleis ergänzt:

(https://forum.arduino.cc/index.php?action=dlattach;topic=706058.0;attach=383055)

Das passende Programm (ungetestet):

Code: [Select]
const byte AnzahlGleise = 5;
enum {Gleis1, Gleis2, Gleis3, Gleis4, Gleis5};

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlGleise] = {PA0, PA2, PA4, PA6, PB0};          // Weichen Abbiegen
const byte WG[AnzahlGleise] = {PA1, PA3, PA5, PA7, PB1};          // Weichen Geradeaus

// variable definieren
unsigned long RELAIS_timestore = 0; // Variable Speicher für Impulszeit Weichen

enum {EINFAHRT, UMFAHRUNG, STELLEN, WARTEN, AUS};
byte schritt = {EINFAHRT};

void setup()
{
  for (byte g = Gleis1; g < AnzahlGleise; g++)
  {
    // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
    pinMode(LSBG[g], INPUT_PULLUP);
  }
  pinMode(LSHaupt, INPUT_PULLUP);

  for (byte g = Gleis1; g < AnzahlGleise; g++)
  {
    // Pin Mode für Gleis an schalten
    pinMode(WA[g], OUTPUT);
    pinMode(WG[g], OUTPUT);
  }
}

void loop()
{
  switch (schritt)
  {
    case EINFAHRT:
      if (digitalRead(LSHaupt))     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
      {
        schritt = STELLEN;
      }
      break;
    case STELLEN:
      for (byte g = Gleis1; g < AnzahlGleise; g++)
      {
        if (digitalRead(LSBG[g]))     // Abfrage ob SBH voll
        {
          digitalWrite (WG[g], HIGH);
        }
        else
        {
          digitalWrite (WA[g], HIGH);
        }
      }
      RELAIS_timestore = millis();
      schritt = WARTEN;
      break;
    case WARTEN:
      if (millis() - RELAIS_timestore >= 1000)
      {
        for (byte g = Gleis1; g < AnzahlGleise; g++)
        {
          digitalWrite (WG[g], LOW);
          digitalWrite (WA[g], LOW);
        }
        schritt = AUS;
      }
      break;
    case AUS:
      if (!digitalRead(LSHaupt))     // Abfrage ob Zug nicht mehr einfährt. Lichtschranke an der Zufahrt
      {
        schritt = EINFAHRT;
      }
      break;
  }
}

Was macht das bei Dir?

Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 24, 2020, 09:58 pm
Man könnte Deine delay-Variante beschleunigen, in dem erst alle Weichen gestellt werden, dann die Verzögerung, dann alle Ausgänge auf LOW. Dann braucht es nur eine Sekunde.
Da die Weichen beim Umschalten einen rel. hohen Stromimpuls ziehen, ist das nacheinander Schalten definitiv die bessere Methode, als alle auf einen Schlag umschalten zu lassen. Wobei 1sek da schon sehr viel ist. Eine Weiche mit Magnetspulenantrieb, die 1Sek zum Umschalten braucht ist kaputt.

(ungetestet):
Da ich ja so eine Blue Pill habe, kann ich nach einem Kurztest sagen, dass es mal grundsätzlich tut ( Mit Leds für die Weichen, und Steckkabel als LS ) ;) . Aber es schaltet eben auch alle Weichen auf einen Schlag um, was ich vermeiden würde.
Der endliche Automat ist definitiv der richtige Ansatz ( aber wo ist er das nicht ... :D ). Und aus meiner Sicht gehöt das Schalten des Fahrwegs und das Schalten der Fahrspannung ebenso definitiv zusammen. Man muss die kleinen Dinger ja nicht maßlos unterfordern - und erst Recht nicht so einen 32-Bitter. Der stirbt ja vor Langeweile  :smiley-twist:
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 08:08 am
Moin zusammen,

Denkt Ihr bitte daran, das ich blutiger Anfänger bin? :-) Ich beschäftige mich gerade mal 3 Monate damit und bin froh das ich irgendwas hin bekommen habe, was so einigermaßen tut, was ich will.
Nach millis sind wir dann über Funktionen auf Strukturen und nun bei endlichen Automaten gelandet... Für mich (noch) Raketenwissenschaft :-)
Also hösch langsam mit die jungen Pferde :-)

Hier ein Video vom SBH der von 2 extrem gelangweilten STM´s gesteuert wird.
https://youtu.be/dzpy0XcvznU (https://youtu.be/dzpy0XcvznU)


Nun zur Beantwortung der in den letzten Threads aufgetauchten Fragen

1. Warum arbeite ich mit 2 Boards?
Erstens stellt das Board 26 I/O´s die nach dem booten schon so verwendet werden können zur Verfügung (ohne Remap).  Ich benötige für die bisherige Lösung aber 27,
Der zweite Grund ist, das das Board nun mal nix Kostet, und zu guter letzt bleiben die Programme kurz. Ich hab ja erst jetzt von euch aufgezeigt bekommen, wie man Bandwürmer verhindert.
Das vereinfacht für mich auch die ganze Sache, da ich mich beim programmieren auf die einzelnen Abschnitte konzentrieren kann. Später zusammenzuführen sollte ja nicht so das Problem sein.

2. Ändern des SBH
den zu Ändern ist kein Problem.

3. länge eines Zuges erkennen und auf passendes Gleis schicken
Das ist bei mir nicht notwendig, da alle Gleise in den SBH´s gleich Lang sind. Die Gleise sind ca 1,8mtr lang. Wird wohl eher nicht vorkommen aber sicher ist sicher bei der Bahn,

4. Schalten der Weichen
Da die Weichen einen eigen Trafo bekommen sollte das bei 30VA wenig ausmachen. Da muß ich aber noch Rechnen bzw Testen. Edit: 5 Weichen gleichzeitig sind zu viel!
Zu der einen Sekunde, die das Relais anzieht. Ich denke 1 Sekunde ist eine gute Zeit, da so sichergestellt ist, das die Weiche auch zuverlässig schaltet. Wenn ich die Weichen über einen Taster mit der Hand schalte dürfte das mindestens eine Sekunde sein. Die sind dann auch nie Kaputt :-)

5. Wann sollen die Weichen geschaltet werden?
Richtig ist, das das schalten jeder Weiche bei einfahrt eines Zuges Blödsinn ist. Aber für mich am einfachsten zu realisieren :-). Es wird noch eine Variable (die ist oben im Sketch auch schon drin "geschaltet" eingepflegt, die nur ein einmaliges schalten zu lässt.

6. Sketch von Agmue
Dankeschön, den werde ich gleich testen.

Ich hoffe ich keine Frage bzw Anmerkung übersehen

Nun aber zu meinen Fragen.

Wenn ich in meinem letzten sketch, bei dem ich den delay Befehl in eine Funktion gelegt habe, eben diesen delay mit millis ersetzten will, muss ich den auch als Variable  mit dem Bezug Pin machen?

aus dem:
Code: [Select]
void Weicheschalt(byte pin)                // Funktion zum Schalten der Weichen, diese wird bei bedarf aufgerufen
{
  digitalWrite (pin, HIGH);
  delay (1000);
  digitalWrite (pin, LOW);
}


wird sowas:
Code: [Select]
void Weicheschalt(byte pin)                // Funktion zum Schalten der Weichen, diese wird bei bedarf aufgerufen
{
  digitalWrite (pin, HIGH);
  Relaistimestore(Pin) = millis()
  digitalWrite (pin, LOW);
}


Brauche ich das Pin hinter Relaistimestore? Ich weis das es so nicht funktioniert mir gehts nur um das "PIN"

Noch ein Frage, es gibt keinen befehl, der einen Ausgang für Zeitraum x auf HIGH Pegel hält, der nicht den Prozessor zum anhalten biringt? es muß über den millis Befehl realisiert werden?


Also "hold HIGH for 20 Secounds..."

Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 25, 2020, 09:00 am
Hier ein Video vom SBH der von 2 extrem gelangweilten STM´s gesteuert wird.
Ich liebe es anschaulich, Danke!

Brauche ich das Pin hinter Relaistimestore?
Nein, es genügt eine Zeit.

5 Weichen gleichzeitig sind zu viel!
Vor ein paar Jahren habe ich mich mal mit einer Modelleisenbahnsimulation beschäftigt, da konnte ich so viel Weichen gleichzeitig schalten, wie ich brauchte ::)

Nach millis sind wir dann über Funktionen auf Strukturen und nun bei endlichen Automaten gelandet...
Bei mir ohne Funktionen und Strukturen :)

Felder, millis und Schrittkette kann ich Dir nicht ersparen, wenn Du das einigermaßen zukunftssicher lösen möchtest.

6. Sketch von Agmue
Dankeschön, den werde ich gleich testen.
Da hätte ich dann auch noch eine Variante mit dem Schalten der Weichen nacheinander (ungetestet):

Code: [Select]
const byte AnzahlGleise = 5;
const uint32_t STELLZEIT = 1000; // in Millisekunden

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlGleise] = {PA0, PA2, PA4, PA6, PB0};          // Weichen Abbiegen
const byte WG[AnzahlGleise] = {PA1, PA3, PA5, PA7, PB1};          // Weichen Geradeaus

// variable definieren
uint32_t RELAIS_timestore = 0; // Variable Speicher für Impulszeit Weichen

enum {EINFAHRT, STELLEN, AUS};
byte schritt = EINFAHRT;
byte gleis = 0; // Gleis 1 entspricht dem Zähler 0

void setup()
{
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
    pinMode(LSBG[g], INPUT_PULLUP);
  }
  pinMode(LSHaupt, INPUT_PULLUP);

  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Gleis an schalten
    pinMode(WA[g], OUTPUT);
    pinMode(WG[g], OUTPUT);
  }
}

void loop()
{
  switch (schritt)
  {
    case EINFAHRT:
      if (digitalRead(LSHaupt))     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
      {
        gleis = 0;
        schritt = STELLEN;
      }
      break;
    case STELLEN:
      if (millis() - RELAIS_timestore >= STELLZEIT)
      {
        if (gleis > 0)
        {
          digitalWrite (WG[gleis - 1], LOW);
          digitalWrite (WA[gleis - 1], LOW);
        }
        if (gleis < AnzahlGleise)
        {
          if (digitalRead(LSBG[gleis]))     // Abfrage ob SBH voll
          {
            digitalWrite (WG[gleis], HIGH);
          }
          else
          {
            digitalWrite (WA[gleis], HIGH);
          }
          RELAIS_timestore = millis();
          gleis++;
        }
        else
        {
          schritt = AUS;
        }
      }
      break;
    case AUS:
      if (!digitalRead(LSHaupt))     // Abfrage ob Zug nicht mehr einfährt. Lichtschranke an der Zufahrt
      {
        schritt = EINFAHRT;
      }
      break;
  }
}
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 09:28 am
Denkt Ihr bitte daran, das ich blutiger Anfänger bin? :-)
Wir bemühen uns ;). Und das muss ja nicht so bleiben 8) .

Hier ein Video vom SBH der von 2 extrem gelangweilten STM´s gesteuert wird.
Mir fällt auf, dass Die Züge beim Einfahren in ihr Gleis mehrfach stoppen/starten. Möglich, dass das an der Aufteilung auf 2 Prozessoren liegt, die nichts voneinander wissen. Aber das ist nicht sauber und sollte eigentlich nicht sein. Möglich dass da noch was drin ist, dass dir später auf die Füße fällt.

Erstens stellt das Board 26 I/O´s die nach dem booten schon so verwendet werden können zur Verfügung (ohne Remap).  Ich benötige für die bisherige Lösung aber 27,
Dafür gibt es Port-Expander. Ok, Du bist da noch nicht so tief drin, aber das ist eigentlich kein Hexenwerk. In meinem Sbf verwaltet der Hauptprozessor über 200 I/Os. Das ist grundsätzlich auch kein Problem.

Der zweite Grund ist, das das Board nun mal nix Kostet
Das ist kein Argument. Wichtig ist, was technisch die sinnvolle Lösung ist. Ich behaupt mal glatt, dass die 1-Prozessor Lösung am Ende auch die einfachere ist ( auch wenn Du das jetzt vielleicht noch nicht glaubst ;) )

Später zusammenzuführen sollte ja nicht so das Problem sein.
Vorausgesetzt Du berücksichtigst das von Anfang an, so wie ich das in meinem schon angesprochenen Link erklärt habe. Wenn nicht, fängst Du u.U. beim Zusammenführen wieder von vorn an.

Die sind dann auch nie Kaputt :-)
Ich habe auch nicht gemeint, dass die durch den 1-Sekunden Impuls kaputt gehen. Ich hatte nur gemeint, wenn sie wirklich einen 1-Sekunden Impuls brauchen, dass sie dann nicht mehr in Ordnung sind. Aber wenn Du nicht immer alle, sondern nur die notwendigen Weichen schaltest, geht es ja eh schneller.


Brauche ich das Pin hinter Relaistimestore? Ich weis das es so nicht funktioniert mir gehts nur um das "PIN"
Nein, Ausschalten darfst Du das Relais an der Stelle noch nicht.

Noch ein Frage, es gibt keinen befehl, der einen Ausgang für Zeitraum x auf HIGH Pegel hält, der nicht den Prozessor zum anhalten biringt? es muß über den millis Befehl realisiert werden?
Nein, sowas gibt es nicht direkt. Etwas einfacher geht es mMn mit dem Timer der MobaTools. Du kannst die pro Weiche einen Timer definieren. Am Anfang des lopp rufst Du eine Funktion auf, die grundsätzlich beim Ablauf des Timers das Weichen-Relais abschaltet. So in der Art
Code: [Select]
If ( WTimer[1].expired() ) digitalWrite( Rel[1], LOW );
 In deiner Weichenschalt-Funktion startest Du den Timer mit WTimer[1].setTime(1000);
Ist natürlich jetzt nur prinzipiell - im echten Programm steht da natürlich nicht fest '1' als Weichennummer und DU musst ja auch nach geradeaus und Abzweig berücksichtigen. Beim Timerablauf könntest Du da aber auch einfach immer beide abschalten.
Die Weichen dann nacheinander schalten zu lassen, ist bei der blockadefreien Variante etwas aufwändiger - wenn immer nur die notwendigen Weichen geschaltet werden aber vielleicht auch nicht notwendig. Edit: agmue war ja schnell, und hat schon was gezeigt ;)



Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 09:31 am
Felder, millis und Schrittkette kann ich Dir nicht ersparen, wenn Du das einigermaßen zukunftssicher lösen möchtest.
Das sehe ich auch so. Das sind absolute Basics - da musst Du durch. Funktionen finde ich auch wichtig - aber da bist Du ja schon dran. Und die delay-freie Programmierung kann man sich mit den MobaTools etwas einfacher gestalten - aber das ist Ansichtssache. Meine Stummi-Kollegen fanden das jedenfalls immer einfacher so.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 09:59 am
Korrekt, das mit dem blutigem Anfänger wird NICHT so bleiben. Würdet Ihr gar nicht zu lassen :-)

ich teste die Tage mal die MOBA Tools.

Port expander, das sagte mir mein Kollege schon. Ich möchte es am Anfang möglichst einfach halten. Zumindest die SW kann ich ja immer weiter verfeineren und verbessern. Gut bei den Port Expandern geht das nicht. Aber eventuell sehe ich im weiteren Verlauf ja, das ich den einen oder anderen Port doch nicht brauche, dann geht das auch ohne Port expander.

Selbiges, (einfach halten  zumindest noch) wollte ich auch für die SW. Der Delay Befehl ist da ein prima Beispiel. So wie es jetzt ist funktioniert der delay Befehl innerhalb der Weichenschaltung 1A. Packe ich die komplette SW auf ein Board wird es wahrscheinlich nicht mehr gehen. Deshalb hatte ich ja nach dem millis Befehl gefragt.

Aber wie Ihr seht beschäftige ich mich ja trotzdem damit eine bessere Lösung zu finden.
Und Ihr seit ne prima Unterstützung (mit leichtem Hang zum Anfänger verwirren :-)) !

Quote
Mir fällt auf, dass Die Züge beim Einfahren in ihr Gleis mehrfach stoppen/starten. Möglich, dass das an der Aufteilung auf 2 Prozessoren liegt, die nichts voneinander wissen. Aber das ist nicht sauber und sollte eigentlich nicht sein. Möglich dass da noch was drin ist, dass dir später auf die Füße fällt.
Nein daran liegt es nicht. Folgendes passiert:

Zug fährt auf Gleis 1 ein LSBG1 wird High - Ausgang GLAS1 (Gleis Abschaltung 1) wird High und Relais schaltet den Bahnstrom für 2 Sekunden (übrigens mittels millis) an. dann wird GLAS1 wieder LOW und das Relais fällt ab. somit wird der Fahrstrom (Relais) wieder abgeschaltet.
Dies wiederholt sich bis die Lok die vordere Endposition (LSBG1)erreicht hat.
mir wäre ein sanftes bremsen auch wesentlich lieber. Da Märklin aber AC hat, ist das nicht so einfach. Ich denke das geht nur über eine Phasenanschnittsteuerung um die Wechselspannung zu regeln.
Ist dann auch etwas für später. Auch könnte ich über einen Schrittmotor einfach den Regler vom Trafo bewegen......

GRuß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 25, 2020, 10:09 am
Du kannst die pro Weiche einen Timer definieren.
@kgbrus: Das bringt mich auf die Idee, die Weichen mit einem zeitlichen Versatz zu schalten. Daraus folgt dann eine Mischung aus millis und MobaTools (ungetestet):

Code: [Select]
const byte AnzahlGleise = 5;
const uint32_t STELLZEIT = 1000;   // in Millisekunden
const uint32_t UEBERLAPPUNGSZEIT = 600;   // in Millisekunden

#include <MobaTools.h>
MoToTimer WTimer[AnzahlGleise];

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlGleise] = {PA0, PA2, PA4, PA6, PB0};          // Weichen Abbiegen
const byte WG[AnzahlGleise] = {PA1, PA3, PA5, PA7, PB1};          // Weichen Geradeaus

// variable definieren
uint32_t RELAIS_timestore = 0; // Variable Speicher für Impulszeit Weichen

enum {EINFAHRT, STELLEN, AUS};
byte schritt = EINFAHRT;
byte gleis = 0; // Gleis 1 entspricht dem Zähler 0

void setup()
{
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
    pinMode(LSBG[g], INPUT_PULLUP);
  }
  pinMode(LSHaupt, INPUT_PULLUP);

  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Gleis an schalten
    pinMode(WA[g], OUTPUT);
    pinMode(WG[g], OUTPUT);
  }
}

void loop()
{
  switch (schritt)
  {
    case EINFAHRT:
      if (digitalRead(LSHaupt))     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
      {
        gleis = 0;
        schritt = STELLEN;
      }
      break;
    case STELLEN:
      if (millis() - RELAIS_timestore >= UEBERLAPPUNGSZEIT)
      {
        if (gleis < AnzahlGleise)
        {
          if (digitalRead(LSBG[gleis]))     // Abfrage ob SBH voll
          {
            digitalWrite (WG[gleis], HIGH);
          }
          else
          {
            digitalWrite (WA[gleis], HIGH);
          }
          WTimer[gleis].setTime(STELLZEIT);
          RELAIS_timestore = millis();
          gleis++;
        }
        else
        {
          schritt = AUS;
        }
      }
      break;
    case AUS:
      if (!digitalRead(LSHaupt))     // Abfrage ob Zug nicht mehr einfährt. Lichtschranke an der Zufahrt
      {
        schritt = EINFAHRT;
      }
      break;
  }
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    if ( WTimer[g].expired() )
    {
      digitalWrite (WG[g], LOW);
      digitalWrite (WA[g], LOW);
    }
  }
}
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 10:12 am
Der Delay Befehl ist da ein prima Beispiel. So wie es jetzt ist funktioniert der delay Befehl innerhalb der Weichenschaltung 1A. Packe ich die komplette SW auf ein Board wird es wahrscheinlich nicht mehr gehen.
Da Du den Fahrstrom ja besser erst einschalten solltest, wenn alle Weichen korrekt geschaltet sind, dürfte sogar das kein Problem sein.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 10:31 am
Das sehe ich auch so. Das sind absolute Basics - da musst Du durch. Funktionen finde ich auch wichtig - aber da bist Du ja schon dran.
Japp da gebe ich euch Recht, deshalb bin ich hier. Ich möchte das verstehen, wie das funktioniert. Deshalb versuche ich auch die von euch zur Verfügung gestellten codes zu verstehen. Damit muss ich mich dann beschäftigen
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 10:36 am
@kgbrus: Das bringt mich auf die Idee, die Weichen mit einem zeitlichen Versatz zu schalten. Daraus folgt dann eine Mischung aus millis und MobaTools (ungetestet):
Na, dann aber doch konsequent und ganz ohne (sichtbare) millis() (getestet ;) ) :
Code: [Select]
const byte AnzahlGleise = 5;
const uint32_t STELLZEIT = 1000;   // in Millisekunden
const uint32_t UEBERLAPPUNGSZEIT = 600;   // in Millisekunden

#include <MobaTools.h>
MoToTimer WTimer[AnzahlGleise];
MoToTimer Ueberlappzeit;

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlGleise] = {PA0, PA2, PA4, PA6, PB0};          // Weichen Abbiegen
const byte WG[AnzahlGleise] = {PA1, PA3, PA5, PA7, PB1};          // Weichen Geradeaus

// variable definieren
uint32_t RELAIS_timestore = 0; // Variable Speicher für Impulszeit Weichen

enum {EINFAHRT, STELLEN, AUS};
byte schritt = EINFAHRT;
byte gleis = 0; // Gleis 1 entspricht dem Zähler 0

void setup()
{
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
    pinMode(LSBG[g], INPUT_PULLUP);
  }
  pinMode(LSHaupt, INPUT_PULLUP);

  for (byte g = 0; g < AnzahlGleise; g++)
  {
    // Pin Mode für Gleis an schalten
    pinMode(WA[g], OUTPUT);
    pinMode(WG[g], OUTPUT);
  }
}

void loop()
{
  switch (schritt)
  {
    case EINFAHRT:
      if (digitalRead(LSHaupt))     // Abfrage ob Zug einfäht. Lichtschranke an der Zufahrt
      {
        gleis = 0;
        schritt = STELLEN;
      }
      break;
    case STELLEN:
      if ( not Ueberlappzeit.running() )
      {
        if (gleis < AnzahlGleise)
        {
          if (digitalRead(LSBG[gleis]))     // Abfrage ob SBH voll
          {
            digitalWrite (WG[gleis], HIGH);
          }
          else
          {
            digitalWrite (WA[gleis], HIGH);
          }
          WTimer[gleis].setTime(STELLZEIT);
          Ueberlappzeit.setTime( UEBERLAPPUNGSZEIT );
          gleis++;
        }
        else
        {
          schritt = AUS;
        }
      }
      break;
    case AUS:
      if (!digitalRead(LSHaupt))     // Abfrage ob Zug nicht mehr einfährt. Lichtschranke an der Zufahrt
      {
        schritt = EINFAHRT;
      }
      break;
  }

  // Abschalten der WeichenRelais, wenn Zeit abgelaufen.
  for (byte g = 0; g < AnzahlGleise; g++)
  {
    if ( WTimer[g].expired() )
    {
      digitalWrite (WG[g], LOW);
      digitalWrite (WA[g], LOW);
    }
  }
}


P.S. faszinierend, das die 'ungetesteten' Codes von agmue alle laufen 8)
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 25, 2020, 10:53 am
Na, dann aber doch konsequent ...
Kann weg:

Code: [Select]
// variable definieren
uint32_t RELAIS_timestore = 0; // Variable Speicher für Impulszeit Weichen

8)

P.S. faszinierend, das die 'ungetesteten' Codes von agmue alle laufen 8)
Ich habe die IOs auf den Mega2560 gemappt und dann zumindest die Grundfunktion probiert. Auf einem STM32 kann es aber dennoch anders sein, schon wegen der 32 Bit. Aber "ein wenig getestet" nützt ja auch nicht wirklich.

Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 11:02 am
@kgbrus: Das bringt mich auf die Idee, die Weichen mit einem zeitlichen Versatz zu schalten. Daraus folgt dann eine Mischung aus millis und MobaTools (ungetestet):


mit zeitlichem Versatz war doch schon dein vorheriger Sketch. Post 84.

Der übrigens prima funktioniert.... Dankeschön

Mhh was mache ich denn jetzt....... Übernehme ich den Einfach... ?? Dann muß ich den nur noch verstehen..
Da werden dann noch fragen zu kommen:-) selbst schuld :-)

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 25, 2020, 11:06 am
Übernehme ich den Einfach... ?? Dann muß ich den nur noch verstehen..
Ich lerne am Schnellsten durch das Verändern funktionierender Programme.

selbst schuld :-)
Ich bin, wie Du merkst, nicht alleine :D

Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 11:09 am
mit zeitlichem Versatz war doch schon dein vorheriger Sketch. Post 84.
Da wurden die Weichen konsequent nacheinander geschaltet, und die Einschaltzeit addiert sich komplett bis alle durch sind. In seinem 2. Sketch werden die Weichen überlappend geschaltet. Es sind also immer maximal 2 gleichzeitig aktiv - was ja noch problemlos sein sollte, Die Zeit bis alle durch sind ist aber kürzer, obwohl die Einzelschaltzeit weiterhin 1Sek ist.
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 11:13 am
Dann muß ich den nur noch verstehen..
Da werden dann noch fragen zu kommen:-) selbst schuld :-)
Immer her damit, wenn uns das stören würde, wären wir hier nicht aktv. Ist auch ein schönes Gefühl, wenn man jemandem erfolgreich aufs Pferd helfen konnte :D .
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 12:00 pm
Immer her damit, wenn uns das stören würde, wären wir hier nicht aktv. Ist auch ein schönes Gefühl, wenn man jemandem erfolgreich aufs Pferd helfen konnte :D .
Ihr habt mir ja nicht nur aufs Pferd geholfen.. ;-)

So ich werde mit der Version die die MobaTools mit einbindet weitermachen... Hab die Bibliothek auch schon implementiert und das Programm getestet. Es funktioniert, wen wundert´s????

Seit bitte nachsichtig, falls ich mich ein paar Tage nicht melde, ich muß ab und zu arbeiten.... dummerweise. :-)

Ich hab in den sketch ein paar zusätzliche Bemerkungen von mir geschrieben, zum besseren verständniss. Ist das richtig?:
Code: [Select]
/* Weichenschaltung von Agmue mit unterstützung von MicroBahner
                Funktionen:
                1. unter Verwendung von MoboTools werden:
                    A.5 Weichen nach und nach geschaltet
                    B. nur bei Einfahrt in den SBH (LSHaupt)
                    C. In Abhängigkeit ob Gleis besetzt (LSBG) wirrd die Weiche entweder auf abbiegen (WA) oder geradeaus (WG) geschaltet
                   
               
*/


const byte AnzahlGleise = 5;        // festlegen der Anzahl der zu schaltenden Weichen
const uint32_t STELLZEIT = 1000;   // Schaltzeit für die Relais die die Weichen schaltenin Millisekunden
const uint32_t UEBERLAPPUNGSZEIT = 600;   // Zeit zwischen den Schaltvorgängen der einzelnen Relais für die Weichen in Millisekunden--uint32_t bedeutet unsigned long

#include <MobaTools.h>            // einbeziehen der Bibliothek MobaTools von MicroBahner
MoToTimer WTimer[AnzahlGleise];   // Auswahl des zu nutzenden Programms.

// zuordnen der STM Pins

// Lichtschranke zur Gleisbesetzmeldung LSBG1-5 
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12}; 

// Lichtschranke SBH Haupt
const byte LSHaupt = PA9;  // Lichtschranke zur Einfahrt in den SBH

// Ausgänge für Relais  der Weichenstellung weiche 1-5
const byte WA[AnzahlGleise] = {PA0, PA2, PA4, PA6, PB0};          // Weichen Abbiegen "Anzahl Gleise" nimmt nach und nach den Wert aus Variable beginnend bei 0!
const byte WG[AnzahlGleise] = {PA1, PA3, PA5, PA7, PB1};          // Weichen Geradeaus

// variable definieren
uint32_t RELAIS_timestore = 0; // Variable Speicher für Impulszeit Weichen 

enum {EINFAHRT, STELLEN, AUS};  // --- Was bedeutet das????????
byte schritt = EINFAHRT;         
byte gleis = 0; // Gleis 1 entspricht dem Zähler 0


Was bedeutet der Teil ab Enum?? Da es blau ist müsste es ein Befehl sein, aber wohl ein geheimer den finde ich in der Arduino Referenz nicht....


Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 25, 2020, 12:18 pm
Was bedeutet der Teil ab Enum??
Automatische Nummerierung (http://www.willemer.de/informatik/cpp/enum.htm) ab 0.

EINFAHRT = 0
STELLEN = 1
AUS = 2

Vorteil ist die automatische Neunummerierung, wenn mal ein Schritt eingefügt werden soll. Ich bin halt faul!

Eigentlich müßte es so aussehen:

Code: [Select]
Schritt schritt;
enum class Schritt:byte {EINFAHRT, STELLEN, AUS};
schritt = Schritt::EINFAHRT;
...
case Schritt::EINFAHRT:

Dann findet auch eine Typüberprüfung statt.

Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 25, 2020, 12:22 pm
Quote
den finde ich in der Arduino Referenz nicht....
Für dich ist die C++ Referenz  (https://cppreference.com/w/)viel wichtiger, als die Arduino Referenz.
In der Arduino Referenz findest du in Hauptsache die Arduino spezifischen Dinge.
Das ist nicht ausreichend für größere/anspruchsvolle Projekte.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 12:52 pm
Für dich ist die C++ Referenz  (https://cppreference.com/w/)viel wichtiger, als die Arduino Referenz.
In der Arduino Referenz findest du in Hauptsache die Arduino spezifischen Dinge.
Das ist nicht ausreichend für größere/anspruchsvolle Projekte.
Das sollte aber kein größeres Anspruchsvolles Projekt werden.....;-)
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 01:04 pm
Automatische Nummerierung (http://www.willemer.de/informatik/cpp/enum.htm) ab 0.

EINFAHRT = 0
STELLEN = 1
AUS = 2

Vorteil ist die automatische Neunummerierung, wenn mal ein Schritt eingefügt werden soll. Ich bin halt faul!

Eigentlich müßte es so aussehen:

Code: [Select]
Schritt schritt;
enum class Schritt:byte {EINFAHRT, STELLEN, AUS};
schritt = Schritt::EINFAHRT;
...
case Schritt::EINFAHRT:

Dann findet auch eine Typüberprüfung statt.


Für den erfahrenen Programierer mag das alles vereinfachen, mich verwirrt es nur mehr und mehr.....

Vielen Dank, aber ich muß auch zu sehen, das ich noch mit komme und eine Chance besteht, das ich das nicht nur jetzt sondern auch in einem Jahr noch verstehe.
Wenn ich jetzt auch noch ausserhalb von Arduino schauen muß ist mir das im Moment eindeutig zu viel. Das ist echt nett von euch, ihr gebt euch auch echt Mühe. Aber das Blicke ich jetzt nun überhaupt nicht  mehr.
Ich denke einfach Ihr setzt bei mir zu viel wissen voraus. Das muß ich mir aber erst aneignen. Ich sehe jetzt erst mal zu, das ich den Moba Timer in meinen Sketch eingebaut bekomme um den millis Befehl zu umgehen, also ggf alles nochmal auf Anfang wenn es denn einfacher ist.

Title: Re: Mal wieder der Milis Befehl
Post by: combie on Sep 25, 2020, 01:07 pm
Quote
Das sollte aber kein größeres Anspruchsvolles Projekt werden.....
Ist es aber, auf jeden Fall in der Form, dass es jetzt die Grenze deines Wissensstands/Erfahrung erreicht und überschreitet
(was auch irgendwie der Grund ist, warum ich mich hier etwas zurückhalte)

Zudem ist es immer besser die Sprache wenigstens halbwegs zu beherrschen, welche man da verwendet.
1. sonst bleibt es ein "Stochern im Nebel"
2. es spart unnötige Umwege ein
3. weist du jetzt wo du nachschauen musst, wenn du Sprachelemente nicht kennst/verstehst.

enum ist eine grundlegende und vielfach anwendbare Spracheigenschaft.

Tipp:
Erfolgreiches lernen findet an der Grenze zur Überforderung statt
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 01:19 pm
Ist es aber, auf jeden Fall in der Form, dass es jetzt die Grenze deines Wissensstands/Erfahrung erreicht und überschreitet
(was auch irgendwie der Grund ist, warum ich mich hier etwas zurückhalte)

Zudem ist es immer besser die Sprache wenigstens halbwegs zu beherrschen, welche man da verwendet.
1. sonst bleibt es ein "Stochern im Nebel"
2. es spart unnötige Umwege ein
3. weist du jetzt wo du nachschauen musst, wenn du Sprachelemente nicht kennst/verstehst.

enum ist eine grundlegende und vielfach anwendbare Spracheigenschaft.

Tipp:
Erfolgreiches lernen findet an der Grenze zur Überforderung statt

Schon lange überschreitet :-)
Nein mal im Ernst, ich lerne das für mich und nur für mich und dann auch nur um meine Modellbahn zu steuern. Da muß mann sich fragen was ist dazu notwendig? Fundiertes wissen in C++ oder reichen rudimentäre Kenntnisse in der Arduino IDE aus? Der zweite Teil war der Grundgedanke bei mir bei gleichzeitiger Vereinfachung der Hardware und einfacher Änderbarkeit durch SW Anpassung.
Das wohin meine Frage nach dem Milis Befehl geführt hat ist für mich erstaunlich und, für mich persönlich einfach to much. Zumindest zum jetzigen Zeitpunkt.

Obendrauf kommt noch das ich mit den noch nicht mal rudimentären Kenntnissen etwas lauffähiges hin bekommen habe. Und alle Verbesserungen zwar sinnvoll sind, aber mich immer mehr und mehr verwirrt hat.

Ich möchte keinem vor den Kopf stoßen besonders da Agmue sich mehrfach die Mühe gemacht hat mir einen sketch zu schreiben. Finde ich toll. Aber der Sketch ist nicht von mir und der überfordert mich.  Auch MicroBahner gibt sich ne riesen Mühe.

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 01:38 pm
Eine kleine Ergänzung von mir, damit ihr vielleicht besser versteht was ich meine:

Agmues Code:

Code: [Select]
// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const byte LSBG[AnzahlGleise] = {PA8, PB15, PB14, PB13, PB12};




Mein Code:

Code: [Select]

const int LSBG1 = PA8;   // Lichtschranke Gleisbesetzt Gleis 1
const int LSBG2 = PB15;   // Lichtschranke Gleisbesetzt Gleis 2
const int LSBG3 = PB14;   // Lichtschranke Gleisbesetzt Gleis 3
const int LSBG4 = PB13;   // Lichtschranke Gleisbesetzt Gleis 4
const int LSBG5 = PB12;   // Lichtschranke Gleisbesetzt Gleis 5
int LSBG1State = 0;
int LSBG2State = 0;
int LSBG3State = 0;
int LSBG4State = 0;
int LSBG5State = 0;


Mein Code ist viel länger,  aber der funktioniert aber  auch . Klar wenn man komplexe Programme schreibt, ist mein Code tödlich, zu viele mögliche Fehlerquellen. Ich will nur ein paar Loks schalten oder ein paar LED´s vielleicht noch ein kleines Display 16x2 oder so ansteuern. Ich will nicht das Programm für den Flug zum Mars schreiben.
Mein Code zum Weichenschalten hat 220 Zeilen. Der zum Gleise ab und anschalten hat so um die 300 ohne Leerzeilen.

Also weder die Größe des Speichers, noch die länge des Programms oder die Geschwindigkeit des Prozessors wird in meinem Projekt jemals eine Rolle spielen. Einzig und allein der delay Befehl macht mir  Sorgen, obwohl es zZ ja sogar mit dem funktioniert.
Wenn ich, ich nenne es mal "zu Fuß" die kleinen Projekte für meine Moba umgesetzt habe, hab ich viel gelernt und kann mich dann immer noch daran geben ein Programm zu schreiben welches als Master alle verbauten Arduinos steuert und auf nem 7" TFT mit Cap TP die Bedienbefehle entgegen nimmt.

Gruß

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: noiasca on Sep 25, 2020, 02:11 pm
festige dein Wissen von deinem bisher Erlernten.
dann mach den nächsten Schritt.

Nur bei einem will ich gleich einhaken:

Quote
Also weder die Größe des Speichers, noch die länge (sic) des Programms oder die Geschwindigkeit des Prozessors wird in meinem Projekt jemals eine Rolle spielen.
deinem Prozessor oder deinem Speicher ist diese Verschwendung wirklich egal, aber auf die Länge kommts an. Nämlich für dich selber.
Heute verstehst du noch deine ganzen Zeilen und du weist auch ganz genau warum du etwas ähnliches 5 oder 6 mal hingeschrieben hast. Auch weist du morgen, wo du die überall die 7te Weiche einfügen musst. Aber in 12 Monaten wenn es was zum Ändern gibt, dann wirst du jede zusätzliche Zeile hassen lernen und beginnen deinen SourceCode - FÜR DICH - so effizent wie möglich hinzuschreiben.

 
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 02:25 pm
Hallo Kay,
Das wohin meine Frage nach dem Milis Befehl geführt hat ist für mich erstaunlich und, für mich persönlich einfach to much. Zumindest zum jetzigen Zeitpunkt
Es hängt auch damit zusammen, dass man einige Dinge - was den Programmfluß angeht - grundsätzlich anders machen muss wenn man delay() los werden will. Insbesondere die von agmue eingeführte Schrittkette ( = endlicher Automat ) ist hier wichtig. Das ist aber eine Sache der Programmlogik, und hat erstmal mit der Sprachsyntax nichts zu tun.

Und ja, man kann auch schon mit rel. rudimentärem C++ Wissen funktionierende Sketche schreiben. Eigentlich wendet sich die Arduino-Umgebung auch eher an so Hobby-Programmierer wie Du es bist. Das sieht man auch an den Beispielen, die fast alle in ziemlich einfacher Syntax geschrieben sind und nur einen Bruchteil der C++ Möglichkeiten nutzen. Zu Zeiten von C (ohne '++') gab es auch nur einen Bruchteil der Möglichkeiten, und trotzdem hat man auch da komplexe Programme geschrieben. Aufgrund der eingeschränkten Sprachmöglichkeiten war die Fehlerrate in komplexen Programmen sehr hoch, weshalb man ( u.a ) diese ganzen Erweiterungen von C++ eingeführt hat. Programme in dieser Komplexität wirst Du aber sicher nie schreiben (wollen).
Es gibt jedoch schon einige grundlegenden Dinge,  die agmue ja auch genutz hat ( im wesentlichen Funktionen und Felder ). Die gab es auch damals schon, weil das eben wichtige Basics sind ( die es auch in fast jeder Sprache gibt ).

Es gibt hier ein paar Kollegen, die so tief in C++ drinstecken, dass sie die Sorgen und Nöte der Einsteiger vielleicht nicht mehr wirklich verstehen. Natürlich würden die deine Aufgabe ganz anders angehen, und der Sketch sähe am Ende vollkommen anders aus. Auch Du wirst dich weiterentwickeln, und irgendwann vielleicht staunend vor deinem alten Sketch stehen :D . Ich denke aber, für das was Du vorhast, reicht das 'Arduino Sprach-Level' durchaus aus. Die eine oder andere Ergänzung kommt dann vielleicht später ganz von alleine dazu. Und wenn nicht, wird deine MoBa auch funktionieren ;) Aber die oben angesprochenen Basics solltest Du dir auf jeden Fall aneignen.

Edit: vielleicht noch ein paar Worte zu dem 'enum'. Letztendlich ist das auch nur eine der Möglichkeiten, einem von dir definierten Bezeichner einen konstanten Wert zuzuordnen. So wie z.B. das 'const byte ... ' auch. Der Vorteil ist zum einen, dass Dinge, die zusammengehören ( wie in dem Fall die möglichen Zustände der Schrittkette ) auch konsequent zusammen definiert werden und man sie sofort als zusammengehörig erkennt. Der 2. Vorteil ist, dass der Compiler die Werte selbst vergibt und Du dich nicht darum kümmern musst. Da kann es auch bei späteren Erweiterungen z.B. nicht passieren, dass man versehentlich einen Wert doppelt vergibt. Ich denke, für dich reicht das auch erstmal so, wie agmue das im Sketch genutzt hat. So Sachen wie 'enum class...' würde ich (erstmal ;) ) außen vor lassen. Alles auf einmal ist definitiv zu viel 8).
Title: Re: Mal wieder der Milis Befehl
Post by: agmue on Sep 25, 2020, 02:48 pm
Es gibt jedoch schon einige grundlegenden Dinge,  die agmue ja auch genutz hat ( im wesentlichen Funktionen und Felder ).
Ich habe eigentlich keine Funktionen genutzt, zumindest nicht absichtlich. Oder habe ich womöglich mein Programm nicht verstanden ;)

Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 02:52 pm
Ja stimmt  :-[ ( wobei setup und loop auch Funktionen sind :D ), das mit den Funktionen hatte er selbst schon gemacht...
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 03:26 pm
Schön das Ihr versteht was ich meine.
Das freut mich, ich möchte nämlich nicht das Ihr den Eindruck habt ich wäre nicht Dankbar das Ihr mir helft bzw geholfen habt.


@ Noiasca, du magst da recht haben, da gibt es aber zwei Möglichkeiten. Entweder ich bin in 12 Monaten noch auf dem Stand wie heute, dann muss ich mich halt 4 Tage einarbeiten um etwas zu verbessern. Vielleicht sollte ich es dann aber auch besser lassen.  Oder ich bin viel weiter wie heute, dann würde ich lachen und in 2 Std den sketch neu und besser schreiben.:-)

Ich will mir die Basics ja auch aneignen, durchaus. Aber Schritt für Schritt, Try and error. Wenn etwas funktioniert oder man etwas abschreibt, heisst das nur das man abschreiben kann, nicht das man es versteht.

Ich sag lieber, der sketch ist kompletter Blödsinn aber funktionier so wie ich das brauche und ist von mir anstatt der Sketch funktioniert auch auf einer Marsmission, aber den verstehe ich nicht.


Zumindest habt Ihr mich nicht vergrault.... ;-)
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 03:27 pm
ich lerne das für mich und nur für mich und dann auch nur um meine Modellbahn zu steuern. Da muß mann sich fragen was ist dazu notwendig? Fundiertes wissen in C++ oder reichen rudimentäre Kenntnisse in der Arduino IDE aus?
Als ich die Software für meinen Schattenbahnhof geschrieben habe ( vor meiner Arduino-Zeit ) habe ich das mit einem System gemacht, dass nur eine rudimentäre C-Syntax beherrschte ( kein Gedanke etwa an C++ ). Da gab's weder struct, noch enum oder Pointer ( Arrays und Funktionen aber schon ;) ). Trotzdem schnurrt der seit fast 10 Jahren wie am Schnürchen, und ich blicke auch heute noch durch und kann Änderungen vornehmen. Der Prozessor ( auch ein ATMega ) verwaltet 53 Blockabschnitte, kennt jeden Zug beim Namen und weis wo der gerade steht. Und er kümmert sich alleine um alle Belange in diesem Sbf. Also schon ein bisschen komplexer ;)

Letzendlich viel wichtiger als das Ausnutzen möglichst vieler C++ Features ist eine strukturierte und übersichtliche Programmlogik und eine aussagekräftige Kommentierung des Ganzen.

Zumindest habt Ihr mich nicht vergrault.... ;-)
Das freut mich. Arduino und Moba ist so ein tolles Gespann 8)
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 03:31 pm
Ich habe eigentlich keine Funktionen genutzt, zumindest nicht absichtlich. Oder habe ich womöglich mein Programm nicht verstanden ;)


Seihst DU, das was ich ein bisschen kann benutzt Du noch nicht mal :-)....
Mal ne Frage, wie lange hast Du für den sketch gebraucht? 10 Minuten?


Quote
Letzendlich viel wichtiger als das Ausnutzen möglichst vieler C++ Features ist eine strukturierte und übersichtliche Programmlogik und eine aussagekräftige Kommentierung des Ganzen.
genau und dazu gehört, machen, machen machen und Fehler machen ;-)
Erst nen Bandwurm programmieren bis der läuft. Soweit bin ich ja schon  :smiley-grin:  Dann das über Funktionen zusammendampfen, dann noch durch Arrays vereinfachen. Und dann versteht man das auch, zumindest ich... vielleicht :-)



GRuß

Kay

PS:
Quote
Das freut mich. Arduino und Moba ist so ein tolles Gespann 8)
das sehe ich auch so und so schnell geb ich nicht auf :-)
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 25, 2020, 03:58 pm
Mal was zum gucken:

(https://up.picr.de/39510499sm.jpg)

Meine Grundplatine.

12 Ein und 12 Ausgänge, für alle Ausgänge sind Relais vorgesehen, davor sitzen 2 ULN´s wenn ich nur LED´s schalten will kann ich die Relais auch weg lassen. Alle 12 Eingänge sind mit einem Pull up und einem Kondensator versehen. Bei Bedarf kann ich aus jedem Eingang auch einen Ausgang machen oder umgekehrt (vor der Bestückung).
Alle Freien Flächen sind auf Masse gelegt.

Hier die Unterseite:
(https://up.picr.de/39510519sx.jpg)

Ja ich hab auch mal schöner gelötet.... :-). die 4 Leiterbahnen sind alles Versorgungsleitungen alles andere ist Masse also Schirmung.


Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 04:10 pm
Hallo Kay,
das sieht doch schon richtig professionell aus 8). Da kann ich nicht mithalten.

Ich fädle meine Leiterplatten einfach  :-[
(https://abload.de/img/platine-vornl0ok8.jpg) (https://abload.de/image.php?img=platine-vornl0ok8.jpg)
(https://abload.de/img/platine-hintenn1pam.jpg) (https://abload.de/image.php?img=platine-hintenn1pam.jpg)
Title: Re: Mal wieder der Milis Befehl
Post by: MicroBahner on Sep 25, 2020, 05:59 pm
genau und dazu gehört, machen, machen machen und Fehler machen ;-)
ja , aber auch Neues lernen und machen und das eigene auch mal wieder zu hinterfragen. Immer nur machen hilft auch nichts, wenns dann immer wieder dasselbe wird :D.

Wenn etwas funktioniert oder man etwas abschreibt, heisst das nur das man abschreiben kann, nicht das man es versteht.
Man muss das Abgeschrieben dann natürlich auch verstehen wollen ( Da hab' ich bei Dir keine Bedenken ;) ). Um etwas zu lernen, wirst Du immer wieder eine neue 'Vorlage' hernehmen 'abschreiben' und dann auch verstehen lernen. Nur mit Try&Error kommst Du nicht voran. Das macht die Evolution, aber die hat auch viiiiiieeeeel Zeit.

Was aber definitiv richtig ist: Das was man 'abschreibt' bzw. als Vorlage hernimmt, darf dem eigenen Wissen nicht zu weit voraus sein. Denn dann hat man keine Chance es zu verstehen. Es muss immer gerade so viel sein, dass man es - vielleicht mit etwas Mühe - noch kapiert. Denn dann hat man mit jedem Schritt wieder etwas Neues gelernt.
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 27, 2020, 10:34 am
Hallo Kay,
das sieht doch schon richtig professionell aus 8). Da kann ich nicht mithalten.

Ich fädle meine Leiterplatten einfach  :-[
(https://abload.de/img/platine-vornl0ok8.jpg) (https://abload.de/image.php?img=platine-vornl0ok8.jpg)
(https://abload.de/img/platine-hintenn1pam.jpg) (https://abload.de/image.php?img=platine-hintenn1pam.jpg)
Gefädelt.. ja das hab ich sonst auch gemacht, aber bei einem Preis von 40 Euro mit Versand für 20 Platinen, erspare ich mir die Arbeit und mögliche Fehlerquellen.

Gruss

Kay
Title: Re: Mal wieder der Milis Befehl
Post by: kgbrus on Sep 27, 2020, 10:39 am
Ich werde jetzt erst mal  über euren Vorschlag des durchfahrtsgleises entscheiden und sehen was die Änderung auf euren Vorschlag bedeutet. Dementsprechend werde ich dann die SW aufbauen

Gruss

Kay
Title: Re: Mal wieder der Millis Befehl - Schattenbahnhof - Gleisharfe
Post by: agmue on Sep 27, 2020, 12:10 pm
Ich werde jetzt erst mal  über euren Vorschlag des durchfahrtsgleises entscheiden und sehen was die Änderung auf euren Vorschlag bedeutet. Dementsprechend werde ich dann die SW aufbauen
Nochmal drüber nachgedacht, kann man die Weiche WG5 als WHaupt verwenden, wenn man dieses Layout zugrundelegt:

(https://forum.arduino.cc/index.php?action=dlattach;topic=706058.0;attach=383335)

Das Programm von MicroBahner aus #91 benötigt dann nur eine kleine Ergänzung:

Code: [Select]
// Ausgänge für Relais  der Weichenstellung weiche 1-5, wobei die nicht vorhandene WG5 der Weiche WHaupt entspricht.

Schön einfach!

Allerdings wird WHaupt als letzte Weiche geschaltet, was durch die Verzögerungen beim Schalten der Weichen vor Erreichen des Zuges passieren muß.

Würde WHaupt mechanisch so eingebaut, daß Gerade und Abzweig vertauscht wären, käme man in Bezeichnungsschwierigkeiten. Wie bei Relais, die aktiv LOW geschaltet werden, bräuchte man eine von der Zungenstellung unabhängige Bezeichnung. Da wäre des Eisenbahners Kreativität gefragt.




Ich habe dieses Thema gerade nicht finden können, weil es "Millis" heißen müßte. Bitte in #0 im Subject verbessern. Danke!

Title: Re: Milis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Sep 27, 2020, 12:43 pm
Nochmal drüber nachgedacht, kann man die Weiche WG5 als WHaupt verwenden, wenn man dieses Layout zugrundelegt:

(https://forum.arduino.cc/index.php?action=dlattach;topic=706058.0;attach=383335)

Das Programm von MicroBahner aus #91 benötigt dann nur eine kleine Ergänzung:

Code: [Select]
// Ausgänge für Relais  der Weichenstellung weiche 1-5, wobei die nicht vorhandene WG5 der Weiche WHaupt entspricht.

Schön einfach!

Allerdings wird WHaupt als letzte Weiche geschaltet, was durch die Verzögerungen beim Schalten der Weichen vor Erreichen des Zuges passieren muß.

Würde WHaupt mechanisch so eingebaut, daß Gerade und Abzweig vertauscht wären, käme man in Bezeichnungsschwierigkeiten. Wie bei Relais, die aktiv LOW geschaltet werden, bräuchte man eine von der Zungenstellung unabhängige Bezeichnung. Da wäre des Eisenbahners Kreativität gefragt.




Ich habe dieses Thema gerade nicht finden können, weil es "Millis" heißen müßte. Bitte in #0 im Subject verbessern. Danke!


Ich hab im Betreff "Steuerung Schattenbahnhof" hinzu gefügt.
Das Layout was du gezeichnet hast ist das wie es jetzt ist. Mein Sketch beruht auch darauf. 5 Abstellgleise und ein Gleis führt außen Rum. Da der SbH auch als Wende für Züge genutzt werden soll, brauche ich auch eine unabhängige Umfahrung und einen Rückweg..
Bei meinem Aufgebauten Test SBH steht LSHaupt 5cm vor der Weiche Whaupt.
Das passt die Loks dürfen nur nicht mit Vollgas in den SBH einfahren. Dürfen die aber auch für die anderen weichen nicht und ist ja auch kein Problem,  das zu lösen.

Title: Re: Milis Befehl, Steuerung Schattenbahnof.
Post by: MicroBahner on Sep 27, 2020, 01:47 pm
Allerdings wird WHaupt als letzte Weiche geschaltet, was durch die Verzögerungen beim Schalten der Weichen vor Erreichen des Zuges passieren muß.
Das ist ein wesentlicher Grund, weshalb ich der Meinung bin, dass das Weichen schalten und Fahrstrom schalten 'in einer Hand' liegen muss.

Ich hab im Betreff "Steuerung Schattenbahnhof" hinzu gefügt.
Das passt die Loks dürfen nur nicht mit Vollgas in den SBH einfahren. Dürfen die aber auch für die anderen weichen nicht und ist ja auch kein Problem,  das zu lösen.
Im gesamten Schattenbahnhof sollte eher mit 'gemäßigtem' Tempo gefahren werden ;).
Title: Re: Milis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Sep 27, 2020, 05:10 pm
Ich hab im Betreff "Steuerung Schattenbahnhof" hinzu gefügt.
Das Wort "millis" wird mit zwei "l" geschrieben, wenn Du das bitte auch noch korrigieren würdest.

Das Layout was du gezeichnet hast ist das wie es jetzt ist.
Dann paßt es ja.

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 03, 2020, 02:06 pm
Hallo zusammen,

Mal ein kleines Update von mir:

https://youtu.be/V-OZ_5-pG38 (https://youtu.be/V-OZ_5-pG38)

Die Automatik läuft nun auch, aber nicht sauber programmiert. Läuft zur Zeit auch noch auf einem eigenen STM Board. Somit wird der SBH von 3 Boards gesteuert:-)
Aber ich hab jetzt etwas lauffähiges, was ich gut verbessern kann. Bzw werde ich mich dran setzen und die SW neu aufsetzen auch um da mehr Struktur rein zu bringen. Sonst schleppe ich nur Fehler durch.
Dazu muss ich aber erst den SBH bauen, damit ich das auch live testen kann bzw die Zeiten für die Abläufe festlegen kann.

Gruss

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 04, 2020, 10:40 am
Dazu muss ich aber erst den SBH bauen, ...
Da freue ich mich schon auf ein weiteres Video :)

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 07, 2020, 01:15 pm
Da freue ich mich schon auf ein weiteres Video :)


Wird dann promt geliefert :-)
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: MicroBahner on Oct 07, 2020, 01:43 pm
bzw die Zeiten für die Abläufe festlegen kann.
Ich bin ja nach wie vor der Meinung dass es eine ganz schechte Idee ist, solche Steuerungsabläufe zeitabhängig zu machen. Wenn dann mal eine Lok schneller oder langsamer unterwegs ist - warum auch immer -, bricht das Zeit-Kartenhaus zusammen. Aber jeder wie er will .... die große Bahn macht es glücklicherweise anders ;) . Aber auch bei der kleinen Bahn ist es lästig, wenn der Sbf nicht zverlässig auch unter 'Fehlerbedingungen' läuft.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 12, 2020, 12:00 pm
Hallo zusammen,

mir ist es zumindest jetzt gelungen, den Delay Befehl im Sketch zu eliminieren. Ich hab meinen Fehler mit dem Millis Befehl gefunden, es lag an zu vielen geschweiften Klammern.... :smiley-confuse:


Geändert habe ich auch die Abhängigkeiten, die Weichen schalten jetzt nicht mehr bei Einfahrt eines Zuges in den SBH (LS Haupt) sondern wenn ein Zug das Gleis verlässt, also Abhängig von LSBGx) somit habe ich hier schon mal keine Abhängigkeit mehr von der Geschwindigkeit einer Lok.
Damit die Weichen nicht ständig schalten hab ich die Variable "geschaltetWxx" eingepflegt
Gleichzeitig hab ich die Bezeichnung der Angeschlossenen "Sensoren" bzw Ausgängen geändert, damit bezeichnungen auf der kompletten Anlage nicht zweifach vorkommen können. somit wurde auf "LSBG1" "uLSBG1" das u steht für untere Ebene.



Code: [Select]

// --------------------------------------------------------------------------------------------------------
// Eingänge definieren
// Lichtschranke zur Gleisbesetzmeldung LSBG1-5
const int uLSBG1 = PA8;          // Lichtschranke Gleisbesetzt Gleis 1
const int uLSBG2 = PB15;         // Lichtschranke Gleisbesetzt Gleis 2
const int uLSBG3 = PB14;         // Lichtschranke Gleisbesetzt Gleis 3
const int uLSBG4 = PB13;         // Lichtschranke Gleisbesetzt Gleis 4
const int uLSBG5 = PB12;         // Lichtschranke Gleisbesetzt Gleis 5
int uLSBG1State = 0;
int uLSBG2State = 0;
int uLSBG3State = 0;
int uLSBG4State = 0;
int uLSBG5State = 0;

// Lichtschranke SBH Haupt
const int uLSHaupt1 = PA9;      // Lichtschranke zur Einfahrt in den SBH
int uLSHaupt1State = 0;

// Auto in
const int AutoIn = PB5;         // Auto in = High
int AutoInState = 0;



// --------------------------------------------------------------------------------------------------------
//Ausgänge definieren
// Ausgänge für Relais  der Weichenstellung weiche 1-5
const int uW1A = PA0;           // Weiche 1 Abbiegen
const int uW1G = PA1;           // Weiche 1 Geradeaus
const int uW2A = PA2;           // Weiche 2 Abbiegen
const int uW2G = PA3;           // Weiche 2 Geradeaus
const int uW3A = PA4;           // Weiche 3 Abbiegen
const int uW3G = PA5;           // Weiche 3 Geradeaus
const int uW4A = PA6;           // Weiche 4 Abbiegen
const int uW4G = PA7;           // Weiche 4 Geradeaus
const int uWHaupt1A = PB0;      // Hauptweiche SBH1 Abbiegen
const int uWHaupt1G = PB1;      // Hauptweiche SBH1 Geradeaus
const int uWAusg1A = PB10;      // Ausgangsweiche SBH1 Abbiegen
const int uWAusg1G = PB11;      // Ausgangsweiche SBH1 Geradeaus
int uW1AState = 0;
int uW1GState = 0;
int uW2AState = 0;
int uW2GState = 0;
int uW3AState = 0;
int uW3GState = 0;
int uW4AState = 0;
int uW4GState = 0;
int uW5AState = 0;
int uW5GState = 0;
int uWHaupt1AState = 0;
int uWHaupt1GState = 0;
int uWAusg1AState = 0;
int uWAusg1GState = 0;

// Ausgänge Ohne Relais und ULN
const int SBH1Voll = PA10;
int SBH1VollState = 0;


// --------------------------------------------------------------------------------------------------------

// Variablen Relais Ausgaänge für Weichen damit nur einmal geschaltet wird.
bool geschaltetW1A = false;         // Variable für Weiche1 Abbiegen
bool geschaltetW1G = false;         // Variable für Weiche1 Geradeaus
bool geschaltetW2A = false;         // Variable für Weiche2 Abbiegen
bool geschaltetW2G = false;         // Variable für Weiche2 Geradeaus
bool geschaltetW3A = false;         // Variable für Weiche3 Abbiegen
bool geschaltetW3G = false;         // Variable für Weiche3 Geradeaus
bool geschaltetW4A = false;         // Variable für Weiche4 Abbiegen
bool geschaltetW4G = false;         // Variable für Weiche4 Geradeaus
bool geschaltetW5A = false;         // Variable für Weiche5 Abbiegen
bool geschaltetW5G = false;         // Variable für Weiche5 Geradeaus
bool geschaltetWHaupt1A = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHaupt1G = false;    // Variable für Hauptweiche Geradeaus
bool geschaltetWHAusg1A = false;    // Variable für Ausgangsweiche Abbiegen
bool geschaltetWHAusg1G = false;    // Variable für Ausgangsweiche Geradeaus


// Variablen zur Zeitmessung

unsigned long schaltzeitA = 1000;          // Länge der Schaltzeit (1 Sekunde)

unsigned long W1A_timestore = 0;          // Speicherzeit der einzelnen Relais
unsigned long W1G_timestore = 0;
unsigned long W2A_timestore = 0;
unsigned long W2G_timestore = 0;
unsigned long W3A_timestore = 0;
unsigned long W3G_timestore = 0;
unsigned long W4A_timestore = 0;
unsigned long W4G_timestore = 0;
unsigned long W5A_timestore = 0;
unsigned long W5G_timestore = 0;
unsigned long WHaupt1A_timestore = 0;
unsigned long WHaupt1G_timestore = 0;
unsigned long WAusg1A_timestore = 0;
unsigned long WAusg1G_timestore = 0;

// sonstige Variabeln

bool SBHVoll = false;               // Variable für alle Gleise im SBH besetzt









ja, noch ist es ein Bandwurm.



Gruß


Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 12, 2020, 12:07 pm
Quote
, es lag an zu vielen geschweiften Klammern....
Ich finde, Klammern und gerade auch ihre Schachtelungstiefe, werden sowieso überbewertet.

Möglichst alle if und Schleifen weglassen, dann braucht es  deutlich weniger Klammern.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 12, 2020, 12:11 pm
Da ich noch keine Bandwürmer posten darf, hier der zweite Teil vom code:... 5 Minuten warten musste ich auch noch :-)
Code: [Select]
void setup()
{
  // put your setup code here, to run once:
  // Pin Mode für Lichtschranken Gleisbesetztmeldung Gleis 1 - 5
  pinMode(uLSBG1, INPUT);
  pinMode(uLSBG2, INPUT);
  pinMode(uLSBG3, INPUT);
  pinMode(uLSBG4, INPUT);
  pinMode(uLSBG5, INPUT);
  pinMode(uLSHaupt1, INPUT);




  // Pin Mode für Gleis an schalten
  pinMode(uW1A, OUTPUT);
  pinMode(uW1G, OUTPUT);
  pinMode(uW2A, OUTPUT);
  pinMode(uW2G, OUTPUT);
  pinMode(uW3A, OUTPUT);
  pinMode(uW3G, OUTPUT);
  pinMode(uW4A, OUTPUT);
  pinMode(uW4G, OUTPUT);
  pinMode(uWHaupt1A, OUTPUT);
  pinMode(uWHaupt1G, OUTPUT);
  pinMode(uWAusg1A, OUTPUT);
  pinMode(uWAusg1G, OUTPUT);

  // Pin Mode sonstige
  pinMode(AutoIn, INPUT);
  pinMode(SBH1Voll, OUTPUT);

  Serial.begin(9600);

}

void loop()
{


  Serial.println(geschaltetW1A);
  // put your main code here, to run repeatedly:

  uLSBG1State = digitalRead(uLSBG1);                                            // Abfrage welches Gleis besetzt
  uLSBG2State = digitalRead(uLSBG2);
  uLSBG3State = digitalRead(uLSBG3);
  uLSBG4State = digitalRead(uLSBG4);
  uLSBG5State = digitalRead(uLSBG5);

  if (uLSBG1State == HIGH && uLSBG2State == HIGH && uLSBG3State == HIGH && uLSBG4State == HIGH && uLSBG5State == HIGH)                      // Steuerung Weiche Haupt  {
  {
    SBHVoll = true;
    digitalWrite (SBH1Voll, LOW);
  }
  else
  {
    SBHVoll = false;
    digitalWrite (SBH1Voll, LOW);
  }
  if (SBHVoll == true && geschaltetWHaupt1A == false)
  {
    digitalWrite (uWHaupt1A, HIGH);       // Ausgang auf High
    WHaupt1A_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetWHaupt1A = true;
    geschaltetWHaupt1G = false;
  }
  if (millis() - WHaupt1A_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uWHaupt1A, LOW);                      // Ausgang auf LOW
  }
  if (SBHVoll == false && geschaltetWHaupt1G == false)
  {
    digitalWrite (uWHaupt1G, HIGH);       // Ausgang auf High
    WHaupt1G_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetWHaupt1G = true;
    geschaltetWHaupt1A = false;
  }
  if (millis() - WHaupt1G_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uWHaupt1G, LOW);                      // Ausgang auf LOW
  }

  //---------------------------------------------------------------------------------------------------------------------------------------------------
  uLSBG1State = digitalRead(uLSBG1);
  if (uLSBG1State == LOW && geschaltetW1A == false)                       // Steuerung Weiche Gleis 1
  {
    digitalWrite (uW1A, HIGH);       // Ausgang auf High
    W1A_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW1A = true;
    geschaltetW1G = false;
  }
  if (millis() - W1A_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW1A, LOW);                      // Ausgang auf LOW
  }

  if (uLSBG1State == HIGH && geschaltetW1G == false)
  {
    digitalWrite (uW1G, HIGH);       // Ausgang auf High
    W1G_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW1G = true;
    geschaltetW1A = false;
  }
  if (millis() - W1G_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW1G, LOW);                      // Ausgang auf LOW
  }
  //---------------------------------------------------------------------------------------------------------------------------------------------------
  uLSBG2State = digitalRead(uLSBG2);
  if (uLSBG2State == LOW && geschaltetW2A == false)                       // Steuerung Weiche Gleis 2
  {
    digitalWrite (uW2A, HIGH);       // Ausgang auf High
    W2A_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW2A = true;
    geschaltetW2G = false;
  }
  if (millis() - W2A_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW2A, LOW);                      // Ausgang auf LOW
  }

  if (uLSBG2State == HIGH && geschaltetW2G == false)
  {
    digitalWrite (uW2G, HIGH);       // Ausgang auf High
    W2G_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW2G = true;
    geschaltetW2A = false;
  }
  if (millis() - W2G_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW2G, LOW);                      // Ausgang auf LOW
  }

  //---------------------------------------------------------------------------------------------------------------------------------------------------
  uLSBG3State = digitalRead(uLSBG3);
  if (uLSBG3State == LOW && geschaltetW3A == false)                       // Steuerung Weiche Gleis 3
  {
    digitalWrite (uW3A, HIGH);       // Ausgang auf High
    W3A_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW3A = true;
    geschaltetW3G = false;
  }
  if (millis() - W3A_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW3A, LOW);                      // Ausgang auf LOW
  }

  if (uLSBG3State == HIGH && geschaltetW3G == false)
  {
    digitalWrite (uW3G, HIGH);       // Ausgang auf High
    W3G_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW3G = true;
    geschaltetW3A = false;
  }
  if (millis() - W3G_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW3G, LOW);                      // Ausgang auf LOW
  }
  //---------------------------------------------------------------------------------------------------------------------------------------------------
  uLSBG4State = digitalRead(uLSBG4);
  if (uLSBG4State == LOW && geschaltetW4A == false)                       // Steuerung Weiche Gleis 4
  {
    digitalWrite (uW4A, HIGH);       // Ausgang auf High
    W4A_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW4A = true;
    geschaltetW4G = false;
  }
  if (millis() - W4A_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW4A, LOW);                      // Ausgang auf LOW
  }

  if (uLSBG4State == HIGH && geschaltetW4G == false)
  {
    digitalWrite (uW4G, HIGH);       // Ausgang auf High
    W4G_timestore = millis();        // aktuelle zeit in timestore merken
    geschaltetW4G = true;
    geschaltetW4A = false;
  }
  if (millis() - W4G_timestore  > schaltzeitA ) // vergleich = ist aktuelle Zeit - gespeicherte Zeit größer als schaltzeit?
  {
    digitalWrite (uW4G, LOW);                      // Ausgang auf LOW
  }
}
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 12, 2020, 12:17 pm
Ich finde, Klammern und gerade auch ihre Schachtelungstiefe, werden sowieso überbewertet.

Möglichst alle if und Schleifen weglassen, dann braucht es  deutlich weniger Klammern.
Kann ich, noch, nicht.. ;-)
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 12, 2020, 01:10 pm
Quote
Bandwürmer
Sehe ich bei dir Codeduplikate?
Also identische Codestrecken, welche sich nur in den Variablenbezeichnern unterscheiden?
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 12, 2020, 01:34 pm
Sehe ich bei dir Codeduplikate?
Also identische Codestrecken, welche sich nur in den Variablenbezeichnern unterscheiden?
Japp siehst Du. Funktionen ist das nächste, was ich verstehen muß.

Dazu möchte ich aber zunächst alles im Programm fertig haben und dann setze ich mich an das zusammenfassen gleicher Codestrecken.
Gruß
Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: MicroBahner on Oct 12, 2020, 07:03 pm
Hallo Kay,
Dazu möchte ich aber zunächst alles im Programm fertig haben und dann setze ich mich an das zusammenfassen gleicher Codestrecken.
Das ist definitiv die falsche Reihenfolge und mach überhaupt keinen Sinn.

Wenn Du einen Rundbrief verschicken willst, schreibst Du dann erst jeden Brief händisch 20x ab, und danach kaufst Du dir einen Kopierer?
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 12, 2020, 08:21 pm
... womit wir nun wieder am 22.9. auf der ersten Seite angelangt sind.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 07:13 am
Hallo Kay,Das ist definitiv die falsche Reihenfolge und mach überhaupt keinen Sinn.

Wenn Du einen Rundbrief verschicken willst, schreibst Du dann erst jeden Brief händisch 20x ab, und danach kaufst Du dir einen Kopierer?
Da hast Du nicht ganz unrecht. Es ist in diesem Programmteil aber nur noch 2 Sachen, dann ist der fertig
Gruß
Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 07:32 am
... womit wir nun wieder am 22.9. auf der ersten Seite angelangt sind.
An was könnte das liegen?
Betrachten wir mal die Reihenfolge.
- Meine Ausgangsfrage bezog sich auf einen Fehler in meinem Code bgl des Millis Befehls,
Dann wurde mir erstmals in 10 Post erklärt, das der STM32 kein Arduino ist.... was mir auch klar war. Aber dummerweise hab ich eine kurze Vorstellung geschrieben, in der ich auch mitgeteilt habe was ich benutze.
Funktionen wurden in den Raum geworfen um meinen Code zu verkürzen
Dann wurden mir Klassen näher gebracht und Strukturen. danach wurde noch diskutiert was wichtiger ist klassen oder Strukturen bzw was zuerst in welchem Buch steht.
Dann sollte auf Array umgestellt werden. Zwischendurch ein kurzer hinweis, das mein Millis so nicht funktioniert. Den ich aber nicht wirklich verstanden habe. Mir aber in der gesamten Diskussion untergegangen ist.
Versteht das jetzt nicht falsch, aber irgendwie ist meine Ausgangsfrage nie beantwortet worden, stattdessen wurde alles mögliche angesprochen oder bemängelt, was mich nicht näher an meinen Fehler geführt hat. 
Aber den hab ich ja dann selbst gefunden.
Kurz und gut, Ihr habt mich erstmal total überfordert... 
Gruß
Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 13, 2020, 07:51 am
Dieses Forum ist kein Ponyhof: "Wer etwas will sucht Wege. Wer etwas nicht will der Sucht nach Gründen".

Wenn du jetzt nicht anfängst mit Funktionen und Arrays (und struct und OOP), dann wird das ein rießen Monolyth der wächst und wächst.

Du überschreitest deinen eigenen Point of No Return. Irgendwann wirst du dir selber einreden, nein das werfe ich jetzt nicht mehr Weg, den einen If bau ich noch dazu (10 mal). 2 Wochen später, OK, diesen einen auch noch (wieder 10 mal). Es gibt keinen besseren Zeitpunkt als JETZT zum Erlernen.


Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 09:02 am
Dieses Forum ist kein Ponyhof: "Wer etwas will sucht Wege. Wer etwas nicht will der Sucht nach Gründen".

Wenn du jetzt nicht anfängst mit Funktionen und Arrays (und struct und OOP), dann wird das ein rießen Monolyth der wächst und wächst.

Du überschreitest deinen eigenen Point of No Return. Irgendwann wirst du dir selber einreden, nein das werfe ich jetzt nicht mehr Weg, den einen If bau ich noch dazu (10 mal). 2 Wochen später, OK, diesen einen auch noch (wieder 10 mal). Es gibt keinen besseren Zeitpunkt als JETZT zum Erlernen.





vielleicht hab ich mich auch ein wenig blöd ausgedrückt mit ich will das Programm erst fertig haben. 
das was noch fehlt ist folgendes:
2 Eingänge definieren. und diese Eingänge für Taster definieren um 2 Ausgänge zu schalten und überflüssiges aus dem Sketch zu löschen. that's  it.  Mir zumindest hat meine Vorgehensweise bisher geholfen die Materie immer besser zu verstehen. Vor ein paar Monaten kannte ich noch nicht mal das Wort Sketch.
Gruß
Kay



Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 13, 2020, 09:56 am
Quote
Mir zumindest hat meine Vorgehensweise bisher geholfen die Materie immer besser zu verstehen.
Naja...
Der Mensch, mit wenig Ahnung, kann am leichtfertigsten Urteilen, denn diese Urteile werden nicht durch Fakten und Erfahrungen getrübt.

Ja, du hast Dinge gelernt.
z.B. Codeduplikate


Ich weiß auch schon das nächste Argument:
> Damit habe ich so viel Erfolg gehabt, das mache ich weiter so.


Es bilden sich Gewohnheiten und die wird man nur schwer wieder los.
Aus meiner Sicht ist es ineffektiv, erst das falsche zu lernen, dann ins Messer zu taumeln, bis an den Rand des Versagens, umzulernen, und dann wieder neu zu beginnen.

Klarer:
Alte/Schädliche Gewohnheiten wird man nicht wirklich los. Sie stehen immer präsent im Hintergrund und lauern nur auf eine Gelegenheit dir erneut ein Beinchen zu stellen.

Du siehst, auf mich, und auch sicherlich auf noch viele weitere Leute, macht dein Vorgehen einen gruseligen Eindruck. Das ist einerseits nur dein Problem, aber da man/ich, sich doch auch mal von gruseligen Dingen abwendet, wird die Unterstützung abnehmen.

Leitmotiv:
> Wer in die falsche Richtung läuft,
> braucht sich nicht zu beeilen.

Ansonsten gilt natürlich:
> Des Menschen Wille, ist sein Himmelreich!


Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 11:22 am
Ok aus meiner Sicht:

ich gebe euch ja Recht nur habe ich noch einen Zwischenschritt gemacht. Ich als Anfänger sehe das als Lernkurve, Ihr Profis als vertane Zeit :-)

Da wir aber ja nu fast am gleichen Punkt sind, ist doch alles gut.

Nächster Sketch von mir hier wird ohne Wiederholungen sein.

Gruß

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 13, 2020, 12:51 pm
Dann wurde mir erstmals in 10 Post erklärt, das der STM32 kein Arduino ist.... was mir auch klar war.
Wer in einem öffentlichen Forum eine Frage stellt, sollte keine professionelle Antwort oder eine präzise Anleitung erwarten. Jeder der Helfenden schreibt halt, was ihm dazu einfällt, ohne Dich persönlich zu kennen. Versuche das mal selbst und Du wirst die Problematik erkennen. Ich mache das jetzt schon ein paar Jahre und bekomme häufig überhaupt keine Reaktion, manchmal aber auch "genau das war's!" als Antwort, ohne dies vorher einschätzen zu können.

Wenn unser Moderator Uwe nicht gerade Rotwein trinkt, Äpfel erntet oder die Sonne Italiens genießt, wird er Dich auf "STM32 ist kein Arduino" aufwerksam machen. Dabei könnte er auch auf die Idee kommen, Dein Thema zu sperren. Ein "ist ja ein Programmierproblem unabhängig vom Prozessor" soll ihn milde stimmen und Dich im Rennen behalten. Außerdem soll es Dir sagen, manch Helfender könnte sich wegen Unkenntnis hinsichtlich STM32 mal verhauen. Ich zähle mich dazu.

So wie es Dir mit Schleifen und Funktionen ergeht, ist es bei mir mit objektorientierter Programmierung (OOP). Vor ein paar Jahren habe ich das als für mir unsinnig eingestuft und dann konsequent ignoriert. Das gilt auch für C und besonders C++. Dank einiger netter Menschen hier im Forum habe ich mich dann doch mal an Strukturen, Klassen und Objekte herangewagt. Ich bin da zwar ganz am Anfang und falle, so wie von combie beschrieben, auch gerne in alte Muster zurück, verspüre aber auch den Reiz gewisser damit verbundener Vorteile. Du bist also nicht alleine!

Möglicherweise wirst Du irgendwann feststellen, der eine oder andere Rat, den Du blöd fandest, war doch nicht so schlecht ;D

Viel Spaß mit Deinem Hobby!

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 01:24 pm
@agmue:

danke, den werd ich haben und berichten. 

Gruß

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 04:09 pm
Soderle, ich bins wieder.

da mir das keine Ruhe gelassen hat und ich heute ein wenig Zeit hatte, hab ich versucht den ersten Teil des Sketches in Arrays umzuwandeln. ich hab mich an dem Sketch von agmue entlang gehangelt. 

Code: [Select]
/* Programm Weichenstellen auf Arrays und schleifen umstellen
 * 
 */


// Eingänge definieren
// Lichtschranken Gleis Besetzt
const byte AnzahlGleise = 5;
const int uLSBG[AnzahlGleise] = {PA8, PB 15, PB14, PB13, PB12};

// Sontige Eingänge
const int AutoIn = PB5

// --------------------------------------------------------------------------------------------------------

// Ausgänge  definieren
// Weichen der Gleise
const byte AnzahlAbbiegen = 4;                        // Weichen Fahrtrichtung abbiegen (in Gleis einfahren)
const int WA[AnzahlAbbiegen] = {PA0, PA2, PA4, PA6};
const byte AnzahlGeradeaus = 4;                       // Anzahl Weichen geradeaus (an Gleis vorbei)
const int WG[AnzahlGeradeaus] = {PA1, PA3, PA5, PA7};

// Weitere Weichen
const int uWHaupt1A = PB0;                            // Hauptweiche SBH1 Abbiegen
const int uWHaupt1G = PB1;                            // Hauptweiche SBH1 Geradeaus
const int uWAusg1A = PB9;                             // Ausgangsweiche SBH1 Abbiegen
const int uWAusg1G = PB8;                             // Ausgangsweiche SBH1 Geradeaus

// --------------------------------------------------------------------------------------------------------

// variablen definieren das Weiche geschaltet hat:
bool geschaltet WA[AnzahlAbbiegen] = {false, false, false, false}; // geschaltet Variable auf "false" setzten
bool geschaltet WG[AnzahlGeradeaus] = {false, false, false, false}; // geschaltet Variable auf "false" setzten
bool geschaltetWHaupt1A = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHaupt1G = false;    // Variable für Hauptweiche Geradeaus
bool geschaltetWHAusg1A = false;    // Variable für Ausgangsweiche Abbiegen
bool geschaltetWHAusg1G = false;    // Variable für Ausgangsweiche Geradeaus


// Variablen zur Zeitmessung

unsigned long Schaltzeit = 1000;        // länge der Schaltzeit für die RelaisL
unsigned long RelaisTimestore = 0;       // Zeit speichern für den millis Befehl

// sonstige Variablen

bool SBHVoll = false;


Das ist natürlich erstmal nur der Teil vor setup. 
Ist das so richtig?bzw kann man das noch mehr kürzen?
 Kann man das mit der Variable "geschaltet" so machen? (die soll ein mehrmaliges schalten der Weiche verhindern).

Ich hab in den Sketchen bisher die State (also zb uLSBG1State) benutzt, geht das bei Arrays auch oder nicht?

Für die speicherung der aktuellen Zeit im millis Befehl in den einzelnen Gleisen brauche ich jetzt auch nur noch eine? 

Gruß

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: wno158 on Oct 13, 2020, 05:05 pm
Es geht voran ;)

Die Anzahl-Konstanten sind - zumindest für die Array-Definitionen - entbehrlich:
Code: [Select]
const byte AnzahlGleise = 5;
const int uLSBG[AnzahlGleise] = {PA8, PB 15, PB14, PB13, PB12};

geht einfacher als
Code: [Select]
const int uLSBG[] = {PA8, PB 15, PB14, PB13, PB12};
const byte AnzahlGleise = sizeof uLSBG / sizeof uLSBG[0];

Der Compiler kann die Länge des Arrays aus der Anzahl der Initialisierungswerte selbst ermitteln. Und wenn Du die Anzahl später noch brauchst, kann auch das vom Compiler erledigt werden.
Vorteil: Wenn ein Gleis dazukommt oder wegfällt, änderst Du einfach die Initialisierungsliste. Alles andere geht automatotisch.

Ein Problem hast Du allerdings im Code: C/C++ ist zwar weitgehend formatfrei, aber (Variablen)Namen dürfen keine Leerzeichen enthalten. Das gilt schon für den Port ('PB 15' --> 'PB15') und weiter unten auch:
Code: [Select]
bool geschaltet WA[AnzahlAbbiegen]...
Manche behelfen sich mit Unterstrichen (was mir persönlich gar nicht gefällt).
Code: [Select]
bool geschaltet_WA[]...  // Walter meint: igitt
bool geschaltetWA[]...


Das war jetzt nur formaler Kram, die Kollegen werden sicher noch weiteres zur Funktion sagen wollen/können.
Gruß Walter


Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 13, 2020, 05:17 pm
Der Ansatz geht schon in die richtige Richtung. Allerlei Syntaxfehler aber wird schon werden.

Willst vielleicht noch etwas Einleitung lesen:
https://werner.rothschopf.net/202003_arduino_retriggerbares_nachlaufrelais.htm (https://werner.rothschopf.net/202003_arduino_retriggerbares_nachlaufrelais.htm)

Part 1 ist nur Delay -> Millis -> Array -> Struct

die erste Hälfte hast also die letzten 20 Tage gemacht. Ich glaube aber es könnte dir jetzt für den Schritt "Array" helfen.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 13, 2020, 05:19 pm
Upala, die Leerzeichen sind Fehler  das sollte nicht so sein und hab ich übersehen....


Die Einleitung schaue ich mir an. Danke soweit schon mal

Gruss

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 13, 2020, 07:50 pm
Code: [Select]
const int AutoIn = PB5

Die Pinnummer ist eine Konstante, das ist gut.

Der Typ int hat einen Nachteil, denn auf einem UNO besteht er aus 16 Bits, auf einem 32-Bit µC wie dem STM32 sogar aus 32 Bits, wovon eins ein Vorzeichen ist. Wenn man so wie ich zwischen 8-Bittern und 32-Bittern wechselt, ist int also ungünstig. Außerdem gibt es keine Bitnummern jenseits der 255, was vermutlich auch für einen STM32 gilt, weshalb 32 Bits zu viel Bits sind.

Die Schreibweise uint8_t ist plattformübergreifend eindeutig und beschränkt die Bitzahl auf ein vernüftiges Maß.

Der STM32 hat mehr als genug Speicher? Stimmt! Der optimierende Kompiler bügelt manche Typfehler aus? Stimmt! Wer nach Schleifen schielt, nimmt gleich den richtigen Typ? Stimmt auch!

Anstelle uint8_t geht auch byte.

unsigned long → uint32_t für millis() bitte für den STM32 überprüfen!

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 13, 2020, 08:16 pm
Quote
Die Schreibweise uint8_t ist plattformübergreifend eindeutig und beschränkt die Bitzahl auf ein vernüftiges Maß.
Es mag eindeutig sein....
Steht aber nicht auf jeder Plattform zur Verfügung.
Darum wurde u.A.  uint_least8_t (https://en.cppreference.com/w/cpp/types/integer) erfunden.
Den gibts min seit C++11.

Wobei man/ich sich auch fragen darf, was "vernünftig" ist.
z.B. kann ein 32 Bit System am effektivsten mit 32 Bit arbeiten.

Gerade wenn man das 4Byte Alignment  (https://de.wikipedia.org/wiki/Speicherausrichtung)übergeht ist das schon ein erheblicher Rechenaufwand. Eher nicht tun ....
Es werden also normalerweise sowieso 4 Byte für uint8_t typisierte Variablen im Speicher reserviert.

Zugegeben, auf dem STM32 ist die Byte Verarbeitung recht effektiv. Der Zusatzaufwand hält sich in Grenzen.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 14, 2020, 07:28 am
Hallo Ihr zwei,
ich kapiere gerade was nicht 
erst sagt agmue byte und unit8_t ist gleich, weiter  unten aber soll unsigned long mit unit32_t ersetzt werden. Laut Arduino Referenz sind die aber beide jeweils gleich zu setzten.
Gruß

Kay


Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 14, 2020, 07:39 am
Noch ne Frage:
Code: [Select]
const byte AnzahlGleise = sizeof uLSBG / sizeof uLSBG[0];


den Teil bis zum / verstehe ich, aber warum wird geteilt und uLSBG auf 0 gesetzt? 
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 14, 2020, 07:42 am
Arbeistet du mit einem Arduino UNO oder mit einem STM? Insofern ist vieleicht die Arduino Referenz für dich nicht immer 1:1 anwendbar.

Übrigens digitalWrite ist eigentlich so:

void digitalWrite(uint8_t, uint8_t)

falls das zur Entscheidungshilfe beiträgt: nimm ein const uint_8 für deine Pin Definitionen. Ansonsten mach dir über die Spezialsachen jetzt keinen Kopf.

sizeof:
die Größe von uLSBG  wird durch die Größe des ersten Elements dividiert um auf die Anzahl der Elemente zu kommen.

Zur sizeof Frage findet sich auf der von mir verlinkten Seite folgende Info:

Die Anzahl an Gruppen lassen wir wieder automatisch ermitteln. Dazu benötigt es einen kleinen Trick. sizeof(group) liefert uns nicht 3 zurück, sondern 18. Warum? Zunächst besteht die Struktur aus 3 Variablen der Größen 1byte + 1byte + uint32_t = 6. Dann haben wir aktuell 3 Elemente angelegt, daher 3 * 6 = 18. So wie wir mit sizeof(group) die Gesamtgröße ermitteln können, können wir auch mit sizeof(group[0]) die Größe des ersten Elements ermitteln. Ein Element hat 6 Byte. Mit einer einfachen Division 18 / 6 kommen wir auf unsere 3 Button-LED Kombinationen...
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 14, 2020, 08:09 am
@ noiasca
in deinem Link unter
Viele Buttons - viele LEDs: Der einfache Umgang mit Arrays

ist das so gelöst:
Code: [Select]
const byte groups = sizeof(buttonPin);  // "count" how many pin groups are used

unter
Variablen zu Strukturen (struct) verbinden

dann so:

Code: [Select]
const byte noOfgroups = sizeof(group) / sizeof(group[0]); // "count" how many pin groups are used




also bei verwendung von strut und nicht bei Arrays.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 14, 2020, 10:38 am
ja, je nachdem was man braucht. Ein Versuch einer Erklärung:

hat man ein byte/uint8_t array reicht das

const byte groups = sizeof(buttonPin);  // "count" how many pin groups are used

hat man ein int Array mit 3 Elementen würde sizeof 6 zurückgeben. Daher dividiert man durch die Größe des ersten Elements (2) und erhählt daher 6/2 = 3 Elemente

das gleiche geht mit mit einem Struct. Außerdem ist das angewandte Struct auch ein Array.

So retour zum Byte

Wenn du das bei einem Byte Array mit 3 Elementen machst

const byte groups = sizeof(buttonPin)/sizeof(buttonPin[0]);

hast du halt 3/ 1 = 3.

daher schreibe ich das bei byte Arrays nicht hin.
Dem Compiler wirds auch egal sein - der optimiert beide Varianten.

Verständlicher?

P.S.: Range based for ist sowieso viel bequemer ;-)


Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 14, 2020, 10:43 am
So ich hab die Anregungen umgesetzt, Syntaxfehler entfernt und Void setup hinzu gefügt

Code: [Select]
/* Programm Weichenstellen auf Arrays und schleifen umstellen
    1.0
    1. const int durch const uint8_t ersetzt, Festlegung der Ein und ausgänge auf 8bit
    2. Setup hinzu gefügt


*/


// Eingänge definieren
// Lichtschranken Gleis Besetzt

const uint8_t uLSBG[] = {PA8, PB15, PB14, PB13, PB12};
const uint8_t AnzahlGleise = sizeof (uLSBG) / sizeof (uLSBG[0]) ;  // um zu ermitteln

// Sontige Eingänge
const uint8_t AutoIn = PB5;
const uint8_t WAusg1AIn = PB9;
const uint8_t WAusg1GIn = PB8;

// --------------------------------------------------------------------------------------------------------

// Ausgänge  definieren
// Weichen der Gleise
const uint8_t WA[] = {PA0, PA2, PA4, PA6};            // Weichen Fahrtrichtung abbiegen (in Gleis einfahren)
const uint8_t AnzahlAbbiegen =  sizeof WA / sizeof (WA[0]);         // Auslesen wie viele Weichen es sind am Ende Teilen um auf die richtige Menge zu kommen
const uint8_t WG[] = {PA1, PA3, PA5, PA7};           // Weichen Fahrtrichtung geradeaus
const uint8_t AnzahlGeradeaus = sizeof WG / sizeof (WG[0]);         // Auslesen wie viele Weichen es sind am Ende Teilen um auf die richtige Menge zu kommen

// Weitere Weichen
const uint8_t uWHaupt1A = PB0;                                      // Hauptweiche SBH1 Abbiegen
const uint8_t uWHaupt1G = PB1;                                      // Hauptweiche SBH1 Geradeaus
const uint8_t uWAusg1A = PB9;                                       // Ausgangsweiche SBH1 Abbiegen
const uint8_t uWAusg1G = PB8;                                       // Ausgangsweiche SBH1 Geradeaus

// Ausgänge Ohne Relais und ULN
const uint8_t SBH1Voll = PA10;                                      // Ausgang für Anzeige das SBH voll ist


// --------------------------------------------------------------------------------------------------------

// variablen definieren das Weiche geschaltet hat:

bool geschaltetWA[AnzahlAbbiegen] = {false, false, false, false}; // geschaltet Variable auf "false" setzten
bool geschaltetWG[AnzahlGeradeaus] = {false, false, false, false}; // geschaltet Variable auf "false" setzten
bool geschaltetWHaupt1A = false;    // Variable Hauptweiche Abbiegen
bool geschaltetWHaupt1G = false;    // Variable für Hauptweiche Geradeaus
bool geschaltetWHAusg1A = false;    // Variable für Ausgangsweiche Abbiegen
bool geschaltetWHAusg1G = false;    // Variable für Ausgangsweiche Geradeaus


// Variablen zur Zeitmessung

uint32_t Schaltzeit = 1000;        // länge der Schaltzeit für die RelaisL
uint32_t RelaisTimestore = 0;       // Zeit speichern für den millis Befehl

// sonstige Variablen

bool SBHVoll = false;             //  Varriable um nicht immer alles LSB´s abzufragen.

// --------------------------------------------------------------------------------------------------------
void setup()
{
  // put your setup code here, to run once:
  for (uint8_t g = 0; g < AnzahlGleise; g++)      // schleife für Variable g wird zum Platzhalter für die nummern der uLSBG
  {
    // PinMode der Lichtschranken 1 -5
    pinMode (uLSBG[g], INPUT);
  }
  for (uint8_t w = 0; w < AnzahlAbbiegen; w++)    // schleife für Variable W wird zum Platzhalter für die nummern der WA & WG
  {
    // PinMode abbiegen
    pinMode (WA[w], OUTPUT);
    pinMode (WG[w], OUTPUT);
  }

  // weitere Ein / Ausgänge
  pinMode (AutoIn, INPUT);
  pinMode (WAusg1AIn, INPUT);
  pinMode (WAusg1GIn, INPUT);

  pinMode (uWHaupt1A, OUTPUT);
  pinMode (uWHaupt1G, OUTPUT);
  pinMode (uWAusg1A, OUTPUT);
  pinMode (uWAusg1G, OUTPUT);
}

void loop()
{
  // put your main code here, to run repeatedly:

}



laut Compiler keine Fehler..
Was sagt Ihr dazu?

Gruß

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 14, 2020, 11:07 am
wenns ohne Warning compiliert ist doch schon mal fein.

Tendenziell hätte ich Hauptweiche und Ausgangsweiche auch ins Array gegeben, aber wir sind hier schon mal froh, dass die 4 Abstellgleise ein Array sind ^^.

Was gehst als nächstes an, Funktionen?
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 14, 2020, 11:45 am
Bei der Hauptweiche hatte ich das auch überlegt, habe mich dagegen entschieden, da die nicht nur in diesem Array zum Einsatz kommt sondern auch durch andere Bedingung von aussen geschaltet werden kann. 
Ups, da fällt mir ein, da brauche ich noch Eingänge ....
Die Ausgangsweiche wird nur extern geschaltet. Zumindest hat das so den Vorteil das ich die anhand des Namens alleine schon identifizieren kann.

Als nächstes ist dann der void loop teil dran. Da wirds wohl um Funktionen gehen...



Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 14, 2020, 12:10 pm
Quote
sizeof(buttonPin)/sizeof(buttonPin[0]);
Mir schmeckt diese sizeof Kombination auch nicht.
Alleine, weil buttonPin da doppelt auftauchen muss.
Doppelungen sind immer eine Sammelstelle für Unachtsamkeiten.

Das lässt sich mildern, wenn der Ausdruck in ein define gestopft wird
Code: [Select]
#define array_count(array) (sizeof(array) / sizeof(array[0]))
Defines gilt es aber auch zu meiden, wo immer das möglich ist.


Da ist mir dieses lieber:
Code: [Select]
template<typename ArrayType, size_t count>
constexpr size_t arrayCount(const ArrayType (&)[count])
{
  return count;
}

template<typename ArrayType>
constexpr size_t arrayCount()
{
  constexpr ArrayType temp {0};
  return arrayCount(temp);
}




Welches man so für real existierende Arrays nutzt:
Code: [Select]
constexpr size_t anzahlGleise = arrayCount(uLSBG);

Oder so für Datentypen
Code: [Select]
using MeinArrayType = int[42];
constexpr size_t anzahlArrayZellen = arrayCount<MeinArrayType>();


so...

Quote
const uint8_t AnzahlGleise = sizeof (uLSBG) / sizeof (uLSBG[0]) ;  // um zu ermitteln
A: sizeof schmeckt mir nicht.
B: der richtige Datentype ist size_t und nicht uint8_t
C: AnzahlGleise ist kein Typebezeichner, hat also so anzahlGleise geschrieben zu werden.
D: Das Ergebnis ist nicht nur eine ReadOnly Variable, sondern es ist insgesamt ein konstanter Ausdruck.


Schlussendlich sind das alles Vorlieben und Konventionen, hier in diesem Programm macht es keinen funktionalen Unterschied, tut mir aber trotzdem beim betrachten weh.



Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 14, 2020, 12:26 pm
Hallo zusammen,

vieles hat anscheinend beim programieren etwas mit Vorlieben und Gewohnheiten zu tun...
Ich möchte zB mein Wissen und die von mir verwendeten Befehle zunächst einmal möglichst klein halten und dann nach und nach um das Notwendige  erweitern. 

Und bisher mache ich mich, glaube ich, ganz gut :-)

Gruß

Kay

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 14, 2020, 12:32 pm
erst sagt agmue byte und unit8_t ist gleich, weiter  unten aber soll unsigned long mit unit32_t ersetzt werden. Laut Arduino Referenz sind die aber beide jeweils gleich zu setzten.
Da möchte ich nochmal drauf eingehen:

Die Arduino Referenz ist keinesfalls erschöpfend, sondern kratzt an der Oberfläche und bezieht sich überwiedend auf Arduinos mit Schwerpunkt entry level. Ahnst Du was?

Beim UNO/Nano/ProMini sind alle Datentypen auf den 8-Bit Prozessor bezogen. Daher sind beispielsweise int und unsigned int festgelegt auf 16 Bits.

Beim Arduino Due mit 32-Bit Prozessor ist int aber mit 32 Bits festgelegt.

Abhängig vom Prozessor ändert sich also der mögliche Zahlenumfang, was Du beim Prozessorwechsel berücksichtigen mußt. Zusätzlich sagt der Name int nichts aus hinsichtlich der Bitzahl. Wer also zwischen Prozessorentypen wechselt, macht es sich selbst einfacher, wenn er sprechende und eindeutige Typenbezeichnungen verwendet. Das ist mein Tipp an Dich!

Mein Wort "Plattform" war wohl etwas zu umfänglich gewählt, daher: In der Arduino-IDE verwende ich die Bezeichnungen intNN_t und uintNN_t mit NN = 8, 16 oder 32 (64 bei AVR nun ja ...). Da habe ich bei UNO/Nano/ProMini, Mega2560, ESO32 und Teensy 3.2 gute Erfahrungen gemacht.

Ein Byte hat immer acht Bits, hoffe ich zumindest ;D

Wenn Du intNN_t und uintNN_t verwendest, machst es Du Dir und auch uns einfacher, sollten wir mal den von Dir verwendeten Prozessor etwas aus den Augen verlieren. Selbstverständlich kannst Du auch die Bezeichnungen in #148 verwenden. Wichtig ist, Du verstehst Dein Programm auch später noch, wenn Du mal was ändern möchtest.

Hinsichtlich STM32 ausdrücklich ohne Gewähr!

... tut mir aber trotzdem beim betrachten weh.
Da hast Du selbstverständlich mein Mitgefühl und ich finde Deine Ausführungen auch durchaus spannend, aber ob es dem Modelleisenbahner nützt?

Und bisher mache ich mich, glaube ich, ganz gut :-)
Nur deswegen bekommst Du nach so vielen Beiträgen noch Aufmerksamkeit ;D

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 14, 2020, 12:54 pm
Quote
Ein Byte hat immer acht Bits, hoffe ich zumindest ;D
Leider nicht.
Du meinst Oktett.

Byte (https://de.wikipedia.org/wiki/Byte) scheint in unserer kleinen Arduino Welt durchgängig 8 Bit breit zu sein. Das kann sich aber morgen schon ändern.

C und C++ kennen die Konstante CHAR_BIT, welche dir sagt, wie viele Bit ein "Byte" nun wirklich hat.

---------

Quote
vieles hat anscheinend beim programieren etwas mit Vorlieben und Gewohnheiten zu tun...
Ja!
Das fertige Programm ist ein Abbild der Denkstrukturen des Erstellers!

> Unser Leben ist das Produkt unserer Gedanken.
Quelle: Mark Aurel

---------

Quote
Ich möchte zB mein Wissen und die von mir verwendeten Befehle zunächst einmal möglichst klein halten und dann nach und nach um das Notwendige  erweitern.
Eine interessante Ansicht.... (auf sowas würde ich nie kommen)
Aber auf der anderen Seite auch etwas absurd.

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 14, 2020, 01:02 pm
Quote
A: [doppeltes] sizeof schmeckt mir nicht.
B: der richtige Datentype ist size_t und nicht uint8_t
C: AnzahlGleise ist kein Typebezeichner, hat also so anzahlGleise geschrieben zu werden.
D: Das Ergebnis ist nicht nur eine ReadOnly Variable, sondern es ist insgesamt ein konstanter Ausdruck.
Einverstanden.

B mea culpa, da war ich in der Vergangenheit auch schlampig. Wird künftig so in den Erklärungen stehen.
mit C/D hast natürlich recht,
A werde ich keinem Anfänger zeigen, bevor er nicht seine erste Funktion geschrieben hat (und vieles andere mehr)
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 14, 2020, 02:41 pm
Leider nicht.
Du meinst Oktett.
Das jetzt auch noch :-*

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 14, 2020, 02:53 pm
Das jetzt auch noch :-*
Ja, das Leben ist grausam.
Und das Vorgenannte ist der Grund, warum uint8_t (https://en.cppreference.com/w/cpp/types/integer) und seine Brüder, eben nicht in jeden Fall existieren.
Im C++ Standard wird es als "optional" geführt, mit dem Zusatz "(provided only if the implementation directly supports the type)"

Ich hoffe, dass ich damit alle Klarheiten erfolgreich beseitigen konnte.
 :smiley-twist:  :smiley-twist:  :smiley-twist:
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 14, 2020, 03:39 pm
Ich hoffe, dass ich damit alle Klarheiten erfolgreich beseitigen konnte.
 :smiley-twist:  :smiley-twist:  :smiley-twist:
Darin bist Du unschlagbar ...

@kgbrus: Ich hoffe, Du hast Spaß an Deinen Loks ::)

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 15, 2020, 09:52 am
Hallo zusammen,

Leute leute Ihr macht mich fertig.... Immer kommt jemand mit etwas neuem.....
Am Anfang war die Frage nach millis.....

den Weg Arrays und Funktionen war ich ja noch gewillt mitzugehen. Nun aber auch noch darauf zu achten, das das Programm (nebenbei bemerkt für mich persönlich unsinnigerweise) auf allen möglichen 8 bis 32 bit Prozessoren lauffähig sein muß ist mir gelinde gesagt ein Rätsel.

Sorry aber so tief wollte ich da gar nicht rein. Das was ich bisher gelernt habe (auch hier) reicht mir zZ aus. Wenn es nicht ,mehr reicht, kann ich immer noch mein Wissen vertiefen.  Aber das hab ich ja schon ein paar mal versucht zu erklären. Das scheint aber immer irgendwie überlesen zu werden.

Gruß

Kay
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 15, 2020, 10:24 am
Das scheint aber immer irgendwie überlesen zu werden.
Keineswegs, kann ich zumindest von mir behaupten.

Nun aber auch noch darauf zu achten, das das Programm (nebenbei bemerkt für mich persönlich unsinnigerweise) auf allen möglichen 8 bis 32 bit Prozessoren lauffähig sein muß ist mir gelinde gesagt ein Rätsel.
Das hast Du mißverstanden.

Der Standard-Arduino ist der UNO, der mit acht Bits arbeitet. Daher beziehen sich viele Aussagen auf einen µC mit acht Bits. Der springende Punkt ist aber, Du hast keinen UNO. Daher passen manche Aussagen, die für den UNO richtig sind, nicht für Deinen µC, weil der eben mit 32 Bits werkelt.

Ich nutze einen Teensy 3.2 und einen ESP32, ebenfalls beide mit einem 32-Bit µC, und falle immer mal wieder auf diese Problematik herein. Diese Erfahrung und meine Abwehrstrategie versuche ich an Dich weiterzugeben.

Oder ganz kurz: Die Arduino-Referenz trifft in manchen Teilen auf den von Dir verwendeten µC nicht zu.

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 15, 2020, 11:07 am
Keineswegs, kann ich zumindest von mir behaupten.
Das hast Du mißverstanden.

Der Standard-Arduino ist der UNO, der mit acht Bits arbeitet. Daher beziehen sich viele Aussagen auf einen µC mit acht Bits. Der springende Punkt ist aber, Du hast keinen UNO. Daher passen manche Aussagen, die für den UNO richtig sind, nicht für Deinen µC, weil der eben mit 32 Bits werkelt.

Ich nutze einen Teensy 3.2 und einen ESP32, ebenfalls beide mit einem 32-Bit µC, und falle immer mal wieder auf diese Problematik herein. Diese Erfahrung und meine Abwehrstrategie versuche ich an Dich weiterzugeben.

Oder ganz kurz: Die Arduino-Referenz trifft in manchen Teilen auf den von Dir verwendeten µC nicht zu.


Das verstehe ich auch, aber ist das wirklich Wissen, was ich jetzt für mein aktuelles Projekt brauche? der Int Befehl funktioniert auf dem STM32 anscheinend einwandfrei. DEin Hinweis das er nicht auf allen MCU bzw Plattformen funktioniert und aus welchem Grund ist eine gute Info. 
int - uint8_t - uint_least8t-Oktett... Sorry brauche ich alle nicht nicht da wo ich mich gerade bewege. int reicht mir.
Für euch Profis mag das selbstverständlich sein für mich nicht.
Anderes Beispiel ich kämpfe mich mit eurer Hilfe durch arrays. Ich will Combie nicht zu nahe treten. aber dann kommt "schmeckt mir nicht" und ein Code der zu 50% aus Bahnhof und koffer klauen für mich besteht.
Wie gesagt ihr meint es sicher gut und prinzipiell bin ich dankbar aber ich bin da gerade überfordert. 
Ihr habt mit Sicherheit auch recht wenn, man programmiert um immer wieder mal Projekte zu machen. Wo man auch verschiedenste MCU´s braucht, je nach anwendung. 
Hab ich aber alles nicht. Nur die Moba steuern und sonst erstmal nix.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: combie on Oct 15, 2020, 12:21 pm
Quote
Ich will Combie nicht zu nahe treten.
Du trittst mit nicht zu nahe, sondern du entfernst dich von mir.

Vergleich:
Ein Zimmermanns Meister geht mit seinem neuen Stift auf die Baustelle.
Dieser Auszubildende erklärt dem Meister, an seinem ersten Tag, was und in welcher Reihenfolge er lernen will und wie man Dachstühle baut.

Du siehst...

Der Meister wird dem Lehrling den Kopf waschen!

Und jetzt zu dir:
Du bist herzerfrischend Kenntnis frei.
Das ist nicht schlimm.
Das waren wir alle mal.

Du möchtest aber bestimmen/entscheiden, was zu lernen ist, hast aber keine Ahnung, was es alles zu lernen gibt. Diese Entscheidungen sind völlig von Fakten befreit. Triffst Urteile über mich und andere. Urteile ohne Fundament. Das können nur Vor- oder Fehlurteile werden.

Du magst bisher mit dieser Strategie gut durchs Leben kommen sein.
Bei mir kommst du da nicht mit durch.
Und bei der Sprache, C++, die du ja verwendest, auch nicht.
Denn die kennt da keine Gnade und wird dir Beinchen um Beinchen stellen.

Ich kann gehen, und mich distanzieren, von deinem Getue...
Was ich hier mit dann auch einleite.

Wie du siehst, kannst du mir nicht zu nahe treten, sondern du blockierst dich selber.


Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: agmue on Oct 15, 2020, 12:28 pm
der Int Befehl funktioniert auf dem STM32 anscheinend einwandfrei.
Das bezweifle ich, denn einen "Int Befehl" gibt es nicht. Es handelt sich um einen Datentyp, der angibt, welchen Zahlenumfang Du als ganze Zahl speichern kannst.

Das verstehe ich auch, aber ist das wirklich Wissen, was ich jetzt für mein aktuelles Projekt brauche?
Meine Einschätzung:

... aber ich bin da gerade überfordert.
Ob Du genügend Grips hast, Deinen Schattenbahnhof zu programmieren, kann ich natürlich nicht beurteilen. Man kann immer nur das realisieren, was im Rahmen der eigenen Möglichkeiten ist. Aber man kann seine Möglichkeiten erweitern, Du hast ja schon verschiedene Hürden überwunden, also nur zu!

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 15, 2020, 12:50 pm
Du trittst mit nicht zu nahe, sondern du entfernst dich von mir.

Vergleich:
Ein Zimmermanns Meister geht mit seinem neuen Stift auf die Baustelle.
Dieser Auszubildende erklärt dem Meister, an seinem ersten Tag, was und in welcher Reihenfolge er lernen will und wie man Dachstühle baut.

Du siehst...

Der Meister wird dem Lehrling den Kopf waschen!

Und jetzt zu dir:
Du bist herzerfrischend Kenntnis frei.
Das ist nicht schlimm.
Das waren wir alle mal.

Du möchtest aber bestimmen/entscheiden, was zu lernen ist, hast aber keine Ahnung, was es alles zu lernen gibt. Diese Entscheidungen sind völlig von Fakten befreit. Triffst Urteile über mich und andere. Urteile ohne Fundament. Das können nur Vor- oder Fehlurteile werden.

Du magst bisher mit dieser Strategie gut durchs Leben kommen sein.
Bei mir kommst du da nicht mit durch.
Und bei der Sprache, C++, die du ja verwendest, auch nicht.
Denn die kennt da keine Gnade und wird dir Beinchen um Beinchen stellen.

Ich kann gehen, und mich distanzieren, von deinem Getue...
Was ich hier mit dann auch einleite.

Wie du siehst, kannst du mir nicht zu nahe treten, sondern du blockierst dich selber.



Dazu nur eines, ich habe weder über dich noch sonstwen hoier ein Urteil gefällt.  Aber gut. Dann wäre zwischen uns alles gesagt.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: michael_x on Oct 15, 2020, 12:57 pm
Quote
Es handelt sich um einen Datentyp, der angibt, welchen Zahlenumfang Du als ganze Zahl speichern kannst.
Und hier noch schlimmer, int ist der Standard-Datentyp für Ganzzahlen des jeweiligen Controllers/Prozessors. sizeof(int) kann der Compiler festlegen, darf nur nicht kleiner als sizeof(short) sein oder größer als sizeof(long) sein, aber gerne auch gleich.

Wenn es auf die genaue Größe ankommt, solltest du besser gar nicht erst int verwenden, weil man zu schnell irgendwelche Annahmen statt sizeof verwendet.

Wenn es nicht auf Wertebereich/Größe ankommt, ist es gut, aber das müsstest du selber wissen. Und hoffen, dass die von dir bevorzugten Libraries es richtig machen.

Dass combie gerne mal mehr (oder anderes) erzählt als du hören willst, hat auch sein Gutes. Dadurch werden solche Threads für mehr Leute interessant. Du hast ihn zwar angefangen, aber gehören tut er dir nach der ersten Antwort nicht mehr allein. :)

Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 15, 2020, 01:01 pm
Quote
Das bezweifle ich, denn einen "Int Befehl" gibt es nicht. Es handelt sich um einen Datentyp, der angibt, welchen Zahlenumfang Du als ganze Zahl speichern kannst.
Sorry hab ich mich falsch ausgedrückt.
Quote
Meine Einschätzung:
Da gebe ich dir durchaus Recht. Im Moment aber nur die Ding, die ich auch brauche. Das mit dem Init Befehl war auch nur ein Beispiel.
Quote
Ob Du genügend Grips hast, Deinen Schattenbahnhof zu programmieren, kann ich natürlich nicht beurteilen. Man kann immer nur das realisieren, was im Rahmen der eigenen Möglichkeiten ist. Aber man kann seine Möglichkeiten erweitern, Du hast ja schon verschiedene Hürden überwunden, also nur zu!
Wie Ihr an dem Video gesehen habt, habe ich das hinbekommen. Die Programierung ist nicht die Beste, vieles hätte man sauberer oder aber auch kürzer lösen können. Aber es läuft und 300 Zeilen Code sind nicht so unübersichtlich. Auch in 6 Monaten nicht.
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: kgbrus on Oct 15, 2020, 01:17 pm
Und hier noch schlimmer, int ist der Standard-Datentyp für Ganzzahlen des jeweiligen Controllers/Prozessors. sizeof(int) kann der Compiler festlegen, darf nur nicht kleiner als sizeof(short) sein oder größer als sizeof(long) sein, aber gerne auch gleich.

Wenn es auf die genaue Größe ankommt, solltest du besser gar nicht erst int verwenden, weil man zu schnell irgendwelche Annahmen statt sizeof verwendet.

Wenn es nicht auf Wertebereich/Größe ankommt, ist es gut, aber das müsstest du selber wissen. Und hoffen, dass die von dir bevorzugten Libraries es richtig machen.

Dass combie gerne mal mehr (oder anderes) erzählt als du hören willst, hat auch sein Gutes. Dadurch werden solche Threads für mehr Leute interessant. Du hast ihn zwar angefangen, aber gehören tut er dir nach der ersten Antwort nicht mehr allein. :)


Beim int ging es ursprünglich um:
Code: [Select]
const int AutoIn = PB5;
 Ein Eingang beim STM32 der genau 2 Zustände haben kann... Und was ist draus geworden?
Ganz ursprünglich hatte ich nach dem Fehler in meinem code um den Millis Befehl gefragt. Das ich Klammern zu viel hatte hab ich dann irgendwann selbst raus gefunden.
Ich hatte zwischendurch noch eine Frage zu State gestellt, hat keiner was zu gesagt ist dann unter dem ganzen "ich lass mal einen raushängen" wohl unter gegangen. nicht zum ersten mal...schade eigentlich
 
Title: Re: Millis Befehl, Steuerung Schattenbahnof.
Post by: noiasca on Oct 15, 2020, 01:28 pm
Quote
Beim int ging es ursprünglich um:

const int AutoIn = PB5;


Ein Eingang beim STM32 der genau 2 Zustände haben kann... Und was ist draus geworden?
nein das ist falsch gedacht. Es geht nicht um die zwei Zustände sondern um eine Nummer von 0..255 die den Pin identifiziert. Also  musst du in der (konstanten) Variable nicht 2 Zustände speichern, sondern einen Pin. Und der geht nun mal von 0..255 (Sonderfälle außen vor).

zum Rest: Bleib einfach in der Sache. Wenn du Fragen hast, stelle sie.
Werden sie nicht beantwortet - stelle sie nochmal bis du deine Antwort bekommst. Angriffe auf deine Person sind entweder nicht gewollt oder werden nur von dir so empfunden. Komplett egal. Ignore derartiges. Bleibe bei deine Sachthema und gut ist.

Das derartige Themen zu Abschweifungen führen ist ganz normal. Für dich vielleicht verwirrend, aber es liegt an dir das Thema in die Richtung zu steuern die du willst.