Realisierung einer Ampelsteuerung für eine X-Kreuzung mit Linksabbiegerspur und Fußgängerampeln

International Deutsch
1

image
image852×822 92.8 KB

Hallo zusammen,
ich muss für ein Schulprojekt eine Ampelsteuerung für eine größere Kreuzung realisieren.
Folgende Punkte sollen enthalten sein:

  • Es handelt sich um eine X-Kreuzung
  • Auf jeder Seite gibt es eine Spur für Autos die geradeaus und nach rechts fahren können
  • Auf jeder Seite eine Spur für Autos die nach links abbiegen möchten
  • Die Fußgänger sollen in alle Richtungen die Fahrbahn überqueren können mithilfe von
    Fußgängerampeln
  • An jeder Ecke soll es eine gelbe LED geben die die Autofahrer auf Fußgänger hinweißt
  • Eine Nachtschaltung die nachts für die Hauptstraße dauerhaft grün gibt solange kein Auto auf
    der Nebenstraße von einem Sensor erkannt wird oder eine Fußgängerampel betätigt wird

Das Problem an der ganzen Geschichte ist, das ich bisher nur eine einfache Ampelsteuerung einer einzelnen Ampel programmiert habe. Und sonst noch keine weiteren Erfahrungen mit der Arduino Programmierung habe.
Deshalb wäre es top wenn es die ein oder andere Hilfestellung zur möglichen Realisierung des Projekts hier finden könnte.

2

@firefighter112
dann mach mal eine einfache Ampelsteuerung.
Poste den Schaltplan und den Code.
Dann schauen wir uns das mal an.

Danach kannst du mal vorbereiten:
eine Lange Liste an Pins welcher Pin welche Ampel/Leuchte, Button, Sensor betätigen soll.
Und einen weiteren Lageplan wie oben, aber dann mit eingezeichneten LEDs gem. deiner Liste und Buttons und Sensoren.

1 Like
3

Im englischen Teil des Forum müssen die Beiträge und Diskussionen in englischer Sprache verfasst werden. Deswegen wurde diese Diskussion in den deutschen Teil des Forums verschoben.

mfg ein Moderator.

4

Weil sich Haupt- und Nebenstraße nicht unterscheiden, ist das für mich eine typische Fünfphasenschaltung:

  1. Hauptstraße unten hat Grün
  2. Nebenstraße rechts hat Grün
  3. Hauptstraße oben hat Grün
  4. Nebenstraße links hat Grün
  5. Fußgänger haben Grün

Soll es denn prozedural oder OOP werden?

5

Hallo firefighter112

Nimm eine Suchmaschine deiner Wahl und befrage das WWW nach 'led sequencer +arduino'.

6

image
image850×820 178 KB

Hier schonmal die neue Skizze mit weiteren Infos.
Das ganze soll über den Arduino Mega 2560 laufen.
Weitere Infos folgen

7

ich bin da sehr picky weil es eine HAUSAUFGABE ist.
Du brauchst eine Liste MIT ALLEN PINs - ganz genau.

Und da du in der C++ Welt bist, ... C++ beginnt mit dem Zählen mit 0 (nicht 1).
Also benenne wenigstens jeweils deinen letzte Nummer auf 0 um.
Wenn man mit A, B, C ... durchbenennt erspart man sich genau diese Diskussion :wink:

1 Like
9

Geplante Pinbelegung:

Ampel 1:
Rot 2
Gelb 3
Grün 4

Ampel 2:
Rot 5
Gelb 6
Grün 7

Ampel 3:
Rot 8
Gelb 9
Grün 10

Ampel 4:
Rot 11
Gelb 12
Grün 13

Ampel 5:
Rot 14
Gelb 15
Grün 16

Ampel 6:
Rot 17
Gelb 18
Grün 19

Ampel 7:
Rot 20
Gelb 21
Grün 22

Ampel 8:
Rot 23
Gelb 24
Grün 25

Fußgängerampel 1:
Rot 26
Grün 27
Button 28

Fußgängerampel 2:
Rot 29
Grün 30
Button 31

Fußgängerampel 3:
Rot 32
Grün 33
Button 34

Fußgängerampel 4:
Rot 35
Grün 36
Button 37

Sensor 1:
38

Sensor 2:
39

Sensor 3:
40

Sensor 4:
41

Sensor 5:
42

Sensor 6:
43

Sensor 7:
44

Sensor 8:
45

Gelbe LED links oben:
46

Gelbe LED rechts oben:
47

Gelbe LED links unten:
48

Gelbe LED rechts unten:
49

Ich hoffe das würde soweit passen von der Belegung her. Das Problem an dem ganzen ist das wir obwohl wir mit der Arduino Programmierung eigentlich keine Erfahrung haben gleich eine so in meinen Augen komplexe Schaltung machen sollen. Auf der Arbeit habe ich nur Mal ein Arduino Starterset ausprobiert. Dort hat man allerdings nur anhand der Anleitung und einem fertigen Code etwas aufgebaut.

10

Schöne Aufgabe.
Mach Dir einen grossen Zettel.
Schreibe darauf Deine Bedingungen.
z.B.
Wenn
Ampel 1 = rot
Ampel 2 = rot
Ampel 4 = rot
Ampel 5 = rot
Ampel 7 = rot
Dann darf Fußgängerampel 1 grün werden.

Dann musst Du klären, wie weit Du an die Realität ran möchtest.
Denn Fußgängerampel 1 und Ampel 4 gehen auch gleichzeitig grün, wobei dann hzuerst die Fußgänger losgehen und die auch wieder früher rot bekommen...

Vom Prinzip her sind das für jede FA die selben Funktionen. Somit muss der Code dafür nur einmal geschrieben werden und von jeder Position aus wird er aufgerufen, in dem die Funktion wiederverwendet wird...

Wenn der Ablaufplan für einen Umlauf klar ist, dann ist das Codeschreiben umso schneller.

2 Likes
11

Schnapp dir ein Tabellenprogramm und definiere die Ampelphasen und die daraus zu erfolgenden Schaltzustände der Led´s.

12

Bedingungen:

Wenn:
Ampel 3= rot
Ampel 4= rot
Ampel 5= rot
Ampel 6= rot
Ampel 7= rot
Ampel 8= rot
Fußgängerampel 1= rot
Fußgängerampel 2= rot
Fußgängerampel 3= rot
Fußgängerampel 4= rot
Gelbe LED 1= Low
Gelbe LED 2= Low
Gelbe LED 3= Low
Gelbe LED 4= Low
Dann darf Ampel 1 und Ampel 2 grün werden.

Wenn:
Ampel 1= rot
Ampel 2= rot
Ampel 5= rot
Ampel 6= rot
Ampel 7= rot
Ampel 8= rot
Fußgängerampel 1= rot
Fußgängerampel 2= rot
Fußgängerampel 3= rot
Fußgängerampel 4= rot
Gelbe LED 1= Low
Gelbe LED 2= Low
Gelbe LED 3= Low
Gelbe LED 4= Low
Dann darf Ampel 3 und Ampel 4 grün werden.

Wenn
Ampel 1= rot
Ampel 2= rot
Ampel 3= rot
Ampel 4= rot
Ampel 7= rot
Ampel 8= rot
Fußgängerampel 1= rot
Fußgängerampel 3= rot
Gelbe LED 2= Low
Gelbe LED 4= Low
Dann darf Ampel 5, Ampel 6, Fußgängerampel 2 und Fußgängerampel 4 grün werden. Und die gelbe LED 1 und die gelbe LED 3 dürfen blinken.

Wenn:
Ampel 1= rot
Ampel 2= rot
Ampel 3= rot
Ampel 4= rot
Ampel 5= rot
Ampel 6= rot
Fußgängerampel 2= rot
Fußgängerampel 4= rot
Gelbe LED 1= Low
Gelbe LED 3= Low
Dann darf Ampel 7, Ampel 8, Fußgängerampel 1 und Fußgängerampel 3 grün werden. Und die gelbe LED 2 und die gelbe LED 4 dürfen blinken.

13

Also ich hab mal drüber geschaut.
Bau das ganze mal in Code zusammen.
Eine(!) Ampel. Eine Fussgängerampel und ein Blinklicht.
Der Sensor im Boden kommt später.

Und dann steht im Raume, auf welchem Level das von Euch umgesetzt werden soll.

Klassisch wäre z.B.:

const byte rotPin = 3;
const byte gelbPin = 4;
const byte gruenPin = 5;


void setup()
{
  Serial.begin(115200);
  pinMode(rotPin, OUTPUT);
  pinMode(gelbPin, OUTPUT);
  pinMode(gruenPin, OUTPUT);
  digitalWrite(rotPin, HIGH);
  digitalWrite(gelbPin, LOW);
  digitalWrite(gruenPin, LOW);
}

Oder:

const byte rotPin = 3;
const byte gelbPin = 4;
const byte gruenPin = 5;
const byte ampelPin[] = {rotPin, gelbPin, gruenPin};


void setup()
{
  Serial.begin(115200);
  for (byte b=0; b<sizeof(ampelPin); b++)
  {
  pinMode(ampelPin[b], OUTPUT);
  digitalWrite(ampelPin, LOW);
  }
}

Oder gar sowas in der Art:


class Ampel {
 private:
  byte m_rotPin;
  byte m_gelbPin ;
  byte m_gruenPin;
 public:
  void init(const byte pinRot, const byte pinGelb, const byte pinGruen) {
    m_rotPin = pinRot;
    m_gelbPin = pinGelb;
    m_gruenPin = pinGruen;
    pinMode(m_rotPin, OUTPUT);
    pinMode(m_gelbPin, OUTPUT);
    pinMode(m_gruenPin, OUTPUT);
  }
  void setrot() {
    digitalWrite(m_gelbPin, LOW);
    digitalWrite(m_gruenPin, LOW);
    digitalWrite(m_rotPin, HIGH);
  }
};

Ampel ampel1;


void setup()
{
  Serial.begin(115200);
  ampel1.init(3, 4, 5);
  ampel1.setrot();
}

void  loop()
{}
14

Du schreibst das jetzt das zweite mal.
Ich kann da nur entgegen: Hör' auf zu jammern.
Wenns einfach wäre könnte es ja jeder.
Zerteile es in so kleine Schritte dass es eben nicht mehr komplex ist.

Übrigens warte immer noch auf deinen ersten Sketch mit einer Ampel.

15

Hier mein verwendeter Code
Hatte damit dann ausprobiert wie es ist wenn ich einfach eine zweite Ampel parallel schalte, da ja in meiner Schaltung die ich aktuell geplant habe immer die jeweils gegenüberliegenden Seite parallel fahren dürfen.

int ROT=5;
int GELB=6;
int GRUN=7;

void setup()

{
pinMode(ROT, OUTPUT);
pinMode(GELB, OUTPUT);
pinMode(GRUN,OUTPUT);
}
void loop()
{
digitalWrite(ROT, HIGH);
delay(2000);
digitalWrite(GELB, HIGH);
delay(1000);
digitalWrite(ROT, LOW);
digitalWrite(GELB, LOW);
digitalWrite(GRUN, HIGH);
delay(2000);
digitalWrite(GRUN, LOW);
digitalWrite(GELB, HIGH);
delay(1000);
digitalWrite(GELB, LOW);
}
16

und jetzt liest noch mal im Forum how to nach wie man code in code tags postet und korrigierst entsprechen deinen Post in #15 ... bitte.

fein.

so was ist dein nächster Schritt?

Wie würdest du nun eine Ampel quer zur Richtung integrieren?

1 Like
18

Nachts tun sie das schon.

Aber die beiden Richtungen der jeweiligen Straßen sollten symmetrisch sein.
Die beiden Linksabbiegerspuren einer Straße können gleichzeitg Grün haben?

19

Hallo firefighter112

Welche Schule besuchst du und welches Lernziel soll erreicht werden?

p.s. du mußt nicht, du darfst

20

Das Lernziel ist das Erlernen wie man ein Projekt Realisiert und der Hauptpunkt der dann auch benotet wird ist die Projektdokumentation.

21

oha , ein Monsterprojekt.

Wieviel Zeit hast du dafür?

Ist das ein Gruppenaufgabe mit einen Team?

22

Der Projektstart war Mitte Januar. Dort wurden die Gruppen und die Themen festgelegt. Danach wurde mit dem entsprechenden Lehrer der die Gruppe betreut der Umfang des Projekts besprochen also in unserem Fall was die Kreuzung alles beinhalten soll. Und anhand dessen haben wir dann in der Gruppe angefangen eine Materialliste zu erstellen, eine Skizze der Kreuzung zu erstellen, eine Schaltungslogik zu erstellen, anhand dessen was wir bereits gemacht haben haben wir auch schon die Dokumentation angefangen und jetzt zuletzt nachdem die ersten Teile angekommen sind haben wir erste Versuche in der Programmierung gemacht.
Zeit haben wir theoretisch bis zum 19.06.2023 allerdings gibt es auch Vorzieher (wir sind in der Ausbildung) die bereits am 25.04.2023 abgegeben müssen. Und eigentlich ist das ganze ein Schulprojekt das dem entsprechend auch in der Schule gemacht werden soll. Wir haben allerdings nur alle 6 Wochen Schule. Das heißt jetzt muss man halt nach der Arbeit schauen das man das Projekt fertig bekommt, da die Firmen berechtigterweise nicht wollen das ein Schulprojekt auf der Arbeit gemacht wird.