Lauflicht programmieren

Paul0721

Level-1
Beiträge
4
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo, ich habe eine Aufgabe in der Berufsschule bekommen die wir zuhause auf Note machen sollen. Ich habe aber absolut keinen Plan und bin eine Niete im programmieren. Es wäre nett wenn mir jemand hilft beim programmieren der Aufgabe, ich hänge sie unten dran.
LG
 

Anhänge

Zuviel Werbung?
-> Hier kostenlos registrieren
Habe eine S700C-2-DP und sollen es auf FUP programmieren. Habe noch kaum Ansätze, hab mir nur überlegt das man es mit einem Zähler machen könnte bsp einen CTUD und dann mit mehren INT Bausteinen aber danach hört es auch auf
 

Anhänge

  • IMG_3793.jpeg
    IMG_3793.jpeg
    911,6 KB · Aufrufe: 63
hab mir nur überlegt das man es mit einem Zähler machen
So könnte man das im Prinzip machen. Einen Zähler im Takt hochzählen und dann pro Ausgang einen Vergleicher nehmen ( also wenn Zähler = 1 dann LED1 an, wenn Zähler = 2 dann LED 2 ). Ansonsten kannst du hier auch mal die Suchfunktion nutzen. Lauflicht gibt es hier x mal.
 
Man könnte auch eine Variable verwenden, die einfach angibt, welche Lampe leuchtet.

0 == Alle Lampen aus
n == Hn ist an, Rest ist aus

Eine Variable gibt die Laufrichtung an (-1 rückwärts, 1 vorwärts, 0 undefiniert).
Eine Konstante gibt die Anzahl der Lampen vor.

Wenn die Variable des Status kleiner als 1 ist, dann auf die Anzahl der Lampen setzen.
Beim Überlauf (Variable größer, als die Anzahl der Lampen) die Variable auf 1 setzen.



SHL und SHR sollte man trotzdem mal eingesetzt haben. Diese Funktionen sind sehr wichtig.
 
Danke für die Tipps, falls jemand Lust, Laune oder Langeweile hat. Würde ich mich natürlich über das fertige Programmierte freuen mit den andren Funktionen :)
 
Hallo, ich habe eine Aufgabe in der Berufsschule bekommen die wir zuhause auf Note machen sollen. Ich habe aber absolut keinen Plan und bin eine Niete im programmieren. Es wäre nett wenn mir jemand hilft beim programmieren der Aufgabe, ich hänge sie unten dran.
LG
Danke für die Tipps, falls jemand Lust, Laune oder Langeweile hat. Würde ich mich natürlich über das fertige Programmierte freuen mit den andren Funktionen :)
Hast du zugriff auf einen Laptop/Programmiergerät mit TIA und PLCSIM zum simulieren? Da lässt sich wirklich gut mit rumspielen und mit eigens gemachter Erfahrung lernt es sich in meinen Augen am Besten. Hier hat jeder mal bei Null angefangen und Erfahrung gesammelt.
 
Würde ich mich natürlich über das fertige Programmierte freuen mit den andren Funktionen
Mit diesem ansinnen bist Du hier richtig.
Wir freuen uns über neue Berufskollegen, die das delegieren beherrschen.
Merke:
Die beste Arbeit ist die, die man delegieren kann.

Buchtipp
 
Zuletzt bearbeitet:
Würde ich mich natürlich über das fertige Programmierte freuen mit den andren Funktionen :)
1768854084461.png
Kein Problem. Hab mal eben Claude gefragt:
Python:
import tkinter as tk
from tkinter import ttk

class LampenSteuerung:
    def __init__(self, root):
        self.root = root
        self.root.title("Lampensteuerung")
        self.root.geometry("600x250")
        
        # Zustandsvariablen
        self.anzahl_lampen = 8
        self.aktive_lampe = None  # None = keine Lampe an
        self.richtung = None  # None, 'vor', 'zurück'
        self.automatik_aktiv = False
        self.timer_id = None
        self.bedienung_aktiv = False
        
        # GUI erstellen
        self.erstelle_gui()
        
        # Initial deaktiviert (wie S0)
        self.s0_aktion()
    
    def erstelle_gui(self):
        # Lampen-Frame
        lampen_frame = tk.Frame(self.root)
        lampen_frame.pack(pady=20)
        
        self.lampen_labels = []
        for i in range(self.anzahl_lampen):
            label = tk.Label(lampen_frame, text="O", font=("Arial", 40),
                           fg="red", width=2)
            label.pack(side=tk.LEFT, padx=5)
            self.lampen_labels.append(label)
        
        # Button-Frame
        button_frame = tk.Frame(self.root)
        button_frame.pack(pady=20)
        
        # Buttons erstellen
        self.btn_s0 = tk.Button(button_frame, text="S0", width=10,
                                command=self.s0_aktion)
        self.btn_s0.grid(row=0, column=0, padx=5, pady=5)
        
        self.btn_s1 = tk.Button(button_frame, text="S1", width=10,
                                command=self.s1_aktion)
        self.btn_s1.grid(row=0, column=1, padx=5, pady=5)
        
        self.btn_s2 = tk.Button(button_frame, text="S2 (zurück)", width=10,
                                command=self.s2_aktion)
        self.btn_s2.grid(row=0, column=2, padx=5, pady=5)
        
        self.btn_s3 = tk.Button(button_frame, text="S3 (vor)", width=10,
                                command=self.s3_aktion)
        self.btn_s3.grid(row=0, column=3, padx=5, pady=5)
        
        self.btn_s4 = tk.Button(button_frame, text="S4 (Takt)", width=10,
                                command=self.s4_aktion)
        self.btn_s4.grid(row=1, column=0, padx=5, pady=5)
        
        self.btn_s5 = tk.Button(button_frame, text="S5 (Auto)", width=10,
                                command=self.s5_aktion)
        self.btn_s5.grid(row=1, column=1, padx=5, pady=5)
        
        self.btn_exit = tk.Button(button_frame, text="Exit", width=10,
                                  command=self.root.quit, bg="lightcoral")
        self.btn_exit.grid(row=1, column=3, padx=5, pady=5)
    
    def aktualisiere_lampen(self):
        """Aktualisiert die Anzeige aller Lampen"""
        for i in range(self.anzahl_lampen):
            if i == self.aktive_lampe:
                self.lampen_labels[i].config(fg="green")
            else:
                self.lampen_labels[i].config(fg="red")
    
    def aktualisiere_buttons(self):
        """Aktiviert/Deaktiviert Buttons basierend auf Zustand"""
        if not self.bedienung_aktiv:
            self.btn_s2.config(state=tk.DISABLED)
            self.btn_s3.config(state=tk.DISABLED)
            self.btn_s4.config(state=tk.DISABLED)
            self.btn_s5.config(state=tk.DISABLED)
        else:
            self.btn_s2.config(state=tk.NORMAL)
            self.btn_s3.config(state=tk.NORMAL)
            self.btn_s5.config(state=tk.NORMAL)
            
            # S4 nur aktivieren, wenn Richtung festgelegt ist
            if self.richtung is not None:
                self.btn_s4.config(state=tk.NORMAL)
            else:
                self.btn_s4.config(state=tk.DISABLED)
    
    def s0_aktion(self):
        """Bedienung deaktivieren, Lampen aus, Status zurücksetzen"""
        self.bedienung_aktiv = False
        self.aktive_lampe = None
        self.richtung = None
        
        # Automatik stoppen falls aktiv
        if self.automatik_aktiv:
            self.automatik_aktiv = False
            if self.timer_id:
                self.root.after_cancel(self.timer_id)
                self.timer_id = None
        
        self.aktualisiere_lampen()
        self.aktualisiere_buttons()
    
    def s1_aktion(self):
        """Bedienung aktivieren"""
        war_bereits_aktiv = self.bedienung_aktiv
        self.bedienung_aktiv = True
        
        # Nur zurücksetzen wenn nicht bereits aktiv
        if not war_bereits_aktiv:
            self.aktive_lampe = None
            self.richtung = None
            self.aktualisiere_lampen()
        
        self.aktualisiere_buttons()
    
    def s2_aktion(self):
        """Zurück - aktiviert Lampen von rechts nach links"""
        if not self.bedienung_aktiv:
            return
        
        self.richtung = 'zurück'
        
        if self.aktive_lampe is None:
            # Keine Lampe an -> letzte Lampe an
            self.aktive_lampe = self.anzahl_lampen - 1
        else:
            # Eine Lampe weiter zurück
            self.aktive_lampe -= 1
            if self.aktive_lampe < 0:
                self.aktive_lampe = self.anzahl_lampen - 1
        
        self.aktualisiere_lampen()
        self.aktualisiere_buttons()
    
    def s3_aktion(self):
        """Vorwärts - aktiviert Lampen von links nach rechts"""
        if not self.bedienung_aktiv:
            return
        
        self.richtung = 'vor'
        
        if self.aktive_lampe is None:
            # Keine Lampe an -> erste Lampe an
            self.aktive_lampe = 0
        else:
            # Eine Lampe weiter vor
            self.aktive_lampe += 1
            if self.aktive_lampe >= self.anzahl_lampen:
                self.aktive_lampe = 0
        
        self.aktualisiere_lampen()
        self.aktualisiere_buttons()
    
    def s4_aktion(self):
        """Takt - schaltet abhängig von Richtung weiter"""
        if not self.bedienung_aktiv or self.richtung is None:
            return
        
        if self.richtung == 'vor':
            self.s3_aktion()
        elif self.richtung == 'zurück':
            self.s2_aktion()
    
    def s5_aktion(self):
        """Automatik - Takt jede Sekunde"""
        if not self.bedienung_aktiv:
            return
        
        if self.automatik_aktiv:
            # Automatik deaktivieren
            self.automatik_aktiv = False
            if self.timer_id:
                self.root.after_cancel(self.timer_id)
                self.timer_id = None
        else:
            # Automatik aktivieren
            self.automatik_aktiv = True
            self.automatik_takt()
    
    def automatik_takt(self):
        """Führt automatischen Takt aus"""
        if self.automatik_aktiv and self.bedienung_aktiv:
            self.s4_aktion()
            self.timer_id = self.root.after(1000, self.automatik_takt)

if __name__ == "__main__":
    root = tk.Tk()
    app = LampenSteuerung(root)
    root.mainloop()

Es bringt dir nichts, wenn andere deine Aufgaben lösen. Deswegen ist der Code in Python, damit du ihn nich einfach kopieren kannst.
 
Am Ende der Aufgabenstellung steht ein Hinweis das Schieberegister zu verwenden sind, ich würde nicht viel Zeit in die Umsetzung mit dem Zähler investieren.
Sehr gut, dann hilft der Beispiel-Code noch weniger weiter. Jetzt erst gelesen.

Was man noch beachten sollte, dass wenn man z.B. ein Byte 8-mal nach links oder rechts schiebt, bekommt man eine 0, egal welchen Wert die Zahl zuvor hatte. Probleme mit impliziter Typenkonvertierung gibt es hier soweit ich weiß nicht, wenn die Variable/Tag als Byte definiert ist.

Wenn z.B. H8 erreicht worden ist, kommt beim nächsten Takt H1, wenn die Richtung vorwärts ist.
D.h. bei Erreichen der 0, muss dann abhängig von der Richtung die Zahl 1 oder 128 zugewiesen werden.

So sähe es aus, wenn man nach rechts schiebt.
Fängt mit LSB an.

Code:
Bit   | 0 1 2 3 4 5 6 7
1     | 1 0 0 0 0 0 0 0
2     | 0 1 0 0 0 0 0 0
4     | 0 0 1 0 0 0 0 0
8     | 0 0 0 1 0 0 0 0
16    | 0 0 0 0 1 0 0 0
32    | 0 0 0 0 0 1 0 0
64    | 0 0 0 0 0 0 1 0
128   | 0 0 0 0 0 0 0 1
 
Zurück
Oben