TIA Nokia Snake / Fifo mit Bool

H

holgi2

Level-2
Beiträge
14
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,

ich verzweifle gerade ein wenig an einem Projekt.

Aufgabenstellung:

1 bis 32 Geräte (Bool) sollen nacheinander eingeschaltet werden. Abhängig davon wieviel Leistung benötigt wird. (0-100% Real)
Anzahl der Geräte wird vorgegeben (INT)
Bei steigender Leistungsanforderung soll das nächste freie Gerät eingeschaltet werden. Umlaufend - 1 bis max und dann wieder bei 1 anfangen.
Bei fallender Leistungsanforderung soll das zuerst eingeschaltete Gerät abgeschaltet werden - ebenfalls umlaufens 1-max und wieder bei 1 anfangen.

Quasi 2 Zeiger die hintereinander herlaufen und sich nicht überholen dürfen.

Das ganze in SCL - da bin ich kein Experte.

Bisher hab ich nur das:

#Flansche_aktiv := #"Anzahl Flansche gesamt"*REAL_TO_INT(#"Leistung_%")/100 ;
#Flansche_verfügbar := #"Anzahl Flansche gesamt" - #Flansche_aktiv;
#Leistung_erhöhen := #Flansche_aktiv < #Flansche_SOLL AND #"Anzahl Flansche gesamt" > #Flansche_aktiv;
#Leistung_verringern := #Flansche_aktiv > #Flansche_SOLL AND #Flansche_aktiv > 0;


// Leistung erhöhen
IF #Leistung_erhöhen THEN
#Flansche_SOLL := #Flansche_SOLL + 1;

END_IF;

IF #Leistung_verringern THEN
#Flansche_SOLL := #Flansche_SOLL - 1;

END_IF;



Vielleicht hat ja jemand Erbarmen und gilft mir weiter?!

grüßle
holgi
 
holgi2 schrieb:
Vielleicht hat ja jemand Erbarmen und gilft mir weiter?!
Zum Vergrößern anklicken....
Bestimmt - ich zumindestens würde aber viel mehr Info's benötigen - mit deinen Flanschen kann ich nichts anfangen.
Vielleicht mal so :
- weißt du wieviel Leistung jedes der Geräte hat UND wieviel maximal aktiv sein darf ?
- wie werden die Geräte aktiviert ?
- was ist das überhaupt, was nach diesem Ring-Freigeben arbeitet ?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Als erstes mal würde ich mit einem Array arbeiten: Jeder "Flansch" ein Array-Element.
Und dann eben zwei Zeiger. Sobald Zeiger 2 (Ausschalten) = Zeiger 1 (Einschalten) sind alle aus und Du darfst Zeiger 2 nicht mehr weiterbewegen.

Das mal als grobes Konzept.
Entweder hast Du die Flansche schon als Array vorliegen und kannst sie direkt ansteuerun oder das o.g. Array ist z.B. ein Array aus Bool (oder falls Du mehr Zustände brauchst als INT) und am Ende schreibst Du die Bool-Zustände einfach auf die einzelnen Flansche.
 
Ok.

Also Flansch = Bool egal was da dran hängt
Leistung ist auch egal - die wird einfach in % Vorgegeben.
Also 0.0 bis 100.0 (Real)
Anzahl der Flansche ist ein INT
Was es genau ist darf ich leider nicht sagen.... Sagen wir einfach es sind eine variable Anzahl Lampen (1-32) die (wie in Snake/Nokia) nacheinander aufleuchten sollen und so eine Schlange darstellen sollen, deren Länge während der Anzeige variabel ist (0-100%)


"Als erstes mal würde ich mit einem Array arbeiten: Jeder "Flansch" ein Array-Element.
Und dann eben zwei Zeiger. Sobald Zeiger 2 (Ausschalten) = Zeiger 1 (Einschalten) sind alle aus und Du darfst Zeiger 2 nicht mehr weiterbewegen."

Genau das ist es!

Die Flansche liegen als Array (Bool) vor.
Der Zähler der aktivierten Flansche fenktioniert ja auch. Nur wie geht das mit den beiden Zeigern?

grüßle
holgi
 
Naja, Leistungsanforderung: Zeiger 1 weiterschieben, schauen ob man übers Ende des Arrays läuft, dann nach vorne setzen.
Leistungsreduktion Zeiger 2 genauso... Und den eben gegen Zeiger 1 verriegeln, damit Du nicht vorbeiläufst.
Wo liegt das Problem?
 
Mein Problem ist wie schreibe ich das?
Zeiger in AWL hab ich vor Jahren mal gemacht. In SCL noch nie.
Könntet ihr mir das mal zeigen?

grüßle
holgi
 
Code: 
meinZeiger : INT;
meinArray: Array[0..Max] OF BOOL;
meinArrayElement: BOOL;

meinZeiger := 5;
meinArrayElement := meinArray[meinZeiger];
meinArray[meinZeiger] := FALSE;
 
Vielleicht beschreibst du mal wie das mit der Leistungs-Geschichte zustande kommt - dann kann man ggf. einen Vorschlag machen.
Also : wie weiß ich, wieviel Leistung ich aktuell habe und wie weiß ich wieviele Flansche ich zuschalten muss um dem neuen Wunsch gerecht zu werden ?
Weiß ich wieviel jeder Flansch leistet ?
Was machst du wenn der neue Leistungswunsch kleiner ist als der aktuelle Flansch (wenn nur einer aktiv ist) zu leisten imstande ist ?

Du siehst - du bist mit deinen Info's zu sparsam ...
 
Also im Moment läuft das so das die angeforderte Leistung simuliert wird.
Es kommt ein Wert von 0-100 als REAL Wert an der immer auf und ab schwingt. So im 2 Sekunden Takt...

Damit:
#Flansche_aktiv := #"Anzahl Flansche gesamt"*REAL_TO_INT(#"Leistung_%")/100 ;

Wird der Wert auf die erforderliche Menge an Flanschen (Bool) umgerechnet.


Ich habe also bereits die angeforderte Anzahl der Flansche.

Nur mit den Zeigern das blick ich ned.....
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Leider beantwortest du meine Fragen nicht :
Woher weißt du wieviele Flansche du jeweils brauchst ?
Haben alle Flansche dieselbe Leistung ?

Flansche_Aktiv muss ein INT sein - du kannst ja keine halben Zeiger setzen ...
Deine Formel müßte also eher so aussehen :
Code: 
#Flansche_aktiv := REAL_TO_INT(INT_TO_REAL(#Anzahl_Flansche_gesamt)*(#"Leistung_%")/100.0) ;
 
Häng Dich nicht am Wort "Zeiger" auf... wir sprechen hier nicht von Pointern!
Es ist eine Index-Variable, mit der Du einfach ein Array-Element bestimmst...
 
mein Vorschlag könnte in etwa so aussehen (komplett ungestest) :
Code: 
Flansche_aktiv := REAL_TO_INT(INT_TO_REAL(Anzahl_Flansche_gesamt)*(#"Leistung_%")/100.0) ;

if (Start_Zeiger < 1) or (Start_Zeiger > Anzahl_Flansche_gesamt) then
   Start_Zeiger := 1 ;
end_if ;

End_Zeiger := Start_Zeiger - 1 + Flansche_aktiv ;
if (End_Zeiger > Anzahl_Flansche_gesamt) then
   End_Zeiger := End_Zeiger - Anzahl_Flansche_gesamt ;
end_if ;

for i := 1 to Anzahl_Flansche_gesamt
   Flansch[i] := false ;
end_for ;

if End_Zeiger > Start_Zeiger then
   for i := Start_Zeiger to End_Zeiger
      Flansch[i] := true ;
   end_for ;
end if ;

if End_Zeiger < Start_Zeiger then
  for i := 1 to End_Zeiger
      Flansch[i] := true ;
   end_for ;
   for i := Start_Zeiger to Anzahl_Flansche_gesamt
      Flansch[i] := true ;
   end_for ;
end if ;

if End_Zeiger = Start_Zeiger then
   // nichts tun - Array ist ja schon gelöscht ...
end if ;

Das ist aber erst der erste Teil und beachtet nur die Leistungserhöhung - die Reduktion überlegst du dir vielleicht mal selbst ?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich versuch mal das Bildlich darzustellen:
angenommen ich habe 16 Flansche.
0000000000000000 +1 ab hier Leistung steigern
1000000000000000 +1
1100000000000000 +1
1110000000000000 +1
1111000000000000 +1
1111100000000000 +1
1111110000000000 +1
0111110000000000 -1 ab hier Leistung verringern
0011110000000000 -1
0001110000000000 -1
0000110000000000 -1
0000111000000000 +1 ab hier wieder steigern
0000111100000000 +1
0000111110000000 +1
0000111111000000 -1 ab hier wieder veringern
0000011111000000 -1
0000001111000000 -1
0000000111000000 -1
0000000011000000 -1
0000000001000000 -1
0000000001100000 +1 ab hier wieder steigern
0000000001110000 +1
0000000001111000 +1
0000000001111100 +1
0000000001111110 +1
0000000001111111 +1
1000000001111111 +1
1100000001111111 +1
1110000001111111 +1
1111000001111111 +1
1111100001111111 +1
1111110001111111 +1
1111111001111111 +1
1111111101111111 +1
1111111111111111
1111111110111111 -1 ab hier wieder veringern
1111111110011111 -1
1111111110000111 -1
1111111110000011 -1
1111111110000001 -1
1111111110000000 -1
0111111110000000 -1
0011111110000000 -1
0001111110000000 -1
0001111110000000 -1


grüßle
holgi
 
Larry Laffer schrieb:
mein Vorschlag könnte in etwa so aussehen (komplett ungestest) :
Code: 
Flansche_aktiv := REAL_TO_INT(INT_TO_REAL(Anzahl_Flansche_gesamt)*(#"Leistung_%")/100.0) ;

if (Start_Zeiger < 1) or (Start_Zeiger > Anzahl_Flansche_gesamt) then
   Start_Zeiger := 1 ;
end_if ;

End_Zeiger := Start_Zeiger - 1 + Flansche_aktiv ;
if (End_Zeiger > Anzahl_Flansche_gesamt) then
   End_Zeiger := End_Zeiger - Anzahl_Flansche_gesamt ;
end_if ;

for i := 1 to Anzahl_Flansche_gesamt
   Flansch[i] := false ;
end_for ;

if End_Zeiger > Start_Zeiger then
   for i := Start_Zeiger to End_Zeiger
      Flansch[i] := true ;
   end_for ;
end if ;

if End_Zeiger < Start_Zeiger then
  for i := 1 to End_Zeiger
      Flansch[i] := true ;
   end_for ;
   for i := Start_Zeiger to Anzahl_Flansche_gesamt
      Flansch[i] := true ;
   end_for ;
end if ;

if End_Zeiger = Start_Zeiger then
   // nichts tun - Array ist ja schon gelöscht ...
end if ;

Das ist aber erst der erste Teil und beachtet nur die Leistungserhöhung - die Reduktion überlegst du dir vielleicht mal selbst ?
Zum Vergrößern anklicken....
Damit kann ich was anfangen! Danke!
grüßle
holgi
 
für die Fortsetzung mußt du jetzt nur den Start-Zeiger hochsetzen wenn die Leistung weniger werden soll (also Leistung_neu < Leistung_letzter_Zyklus). Vielleicht hilft dir der Tip ...
 

Similar threads

S
TIA Rundtisch Schieben mit Bedingung
2 3
Antworten
46
Aufrufe
2K
Larry Laffer
Larry Laffer
Korniman
Gleitender Mittelwert für Batteriemessung mit ESP32 über OpenPLC realisieren
Antworten
6
Aufrufe
4K
Cassandra
Cassandra
ZottelMD
Mal wieder ein Prüfstand - drehzahlabhängiges Gegenmoment
Antworten
2
Aufrufe
12K
ZottelMD
ZottelMD
röhrengertl
TIA TIA V14 SCL Problem mit Migration von S7/300 S_ODT Parameterversorgung
Antworten
2
Aufrufe
3K
röhrengertl
röhrengertl
Manfred Stangl
TIA SCL Schleife steigt nicht aus
Antworten
4
Aufrufe
3K
Manfred Stangl
Manfred Stangl
Zurück
Oben