Go Down

Topic: Millis Befehl, Steuerung Schattenbahnof.  (Read 2313 times) previous topic - next topic

Tommy56

Da würde sich ein Blick ins Tutorial Von delay bis zur Methode von Rentner lohnen.

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

kgbrus

#16
Sep 22, 2020, 01:35 pm Last Edit: Sep 22, 2020, 01:43 pm by kgbrus
@ 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




kgbrus

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);

  }


}



noiasca

#18
Sep 22, 2020, 01:50 pm Last Edit: Sep 22, 2020, 01:55 pm by noiasca
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.






how to react on postings:
- post helped: provide your final sketch, say thank you & give karma.
- post not understood: Ask as long as you understand the post
- post is off topic (or you think it is): Stay to your topic. Ask again.
- else: Ask again.

kgbrus

@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?

Tommy56

Das alles wird in dem Tutorial, was ich in #15 verlinkt habe, erklärt. Nur lesen muss man es.

Gruß Tommy
"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

kgbrus

#21
Sep 22, 2020, 02:12 pm Last Edit: Sep 22, 2020, 02:14 pm by kgbrus
@Tommy56, das hab ich mir schon gedacht, nur noch nicht in Gänze getan.



Gruß

Kay

noiasca

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...
how to react on postings:
- post helped: provide your final sketch, say thank you & give karma.
- post not understood: Ask as long as you understand the post
- post is off topic (or you think it is): Stay to your topic. Ask again.
- else: Ask again.

MicroBahner

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 ). Deshalb auch die Frage, welche IDE-Erweiterung Du einsetzt.

Eine Einführung in die Programmierung ohne delay() aus Modellbahnersicht findest Du auch hier. 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 :)
Gruß, Franz-Peter

kgbrus

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


kgbrus

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

MicroBahner

#26
Sep 22, 2020, 04:59 pm Last Edit: Sep 22, 2020, 05:00 pm by MicroBahner
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 im Nachbarforum.
-Oder hier ein Online-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.
Gruß, Franz-Peter

Doc_Arduino

#27
Sep 22, 2020, 05:00 pm Last Edit: Sep 22, 2020, 05:31 pm by Doc_Arduino
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.
Tschau
Doc Arduino '\0'

Messschieber auslesen: http://forum.arduino.cc/index.php?topic=273445
EA-DOGM Display - Demos: http://forum.arduino.cc/index.php?topic=378279

kgbrus

@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

noiasca

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.



how to react on postings:
- post helped: provide your final sketch, say thank you & give karma.
- post not understood: Ask as long as you understand the post
- post is off topic (or you think it is): Stay to your topic. Ask again.
- else: Ask again.

Go Up