Zeitschaltuhr Pulse

Zuviel Werbung?
-> Hier kostenlos registrieren
@Onkel: Perfekt! Genau die Prüfungen gemacht die ich auch erwähnt hatte! Bleibt nur noch die Frage ob der TE den Code auch versteht. Ich hätte mir die Adresse mithilfe des Schleifenindex berechnet, aber das ist dann wohl Geschmackssache. Weißt du vielleicht wieso es beim ANY-Pointer diese ID gibt? Oder ist das für die Steuerung nur eine Unterscheidung zwischen ANY-Pointer und Pointer??

EDIT: Eventuell könnte man bei den Überprüfungen einen Fehlercode zurückgeben--- etwa so : Fehler = 1 wenn Datentyp nicht korrekt, Fehler = 2 wenn Speicherbereich nicht korrekt, Fehler = 3 wenn UDT Länge nicht passend , usw.
 
..Bleibt nur noch die Frage ob der TE den Code auch versteht..
Ich denke, es kann jeder verstehen. Man muß sich halt ein bisschen mit der Materie befassen.

.. Ich hätte mir die Adresse mithilfe des Schleifenindex berechnet, aber das ist dann wohl Geschmackssache..
Verstehe ich nicht ganz. Zeig doch mal!

.. Weißt du vielleicht wieso es beim ANY-Pointer diese ID gibt?..
Die ID sagt etwas über den Ursprung aus. Ich weiß auch nur daß die 16#10 für Siemens steht.

..EDIT: Eventuell könnte man bei den Überprüfungen einen Fehlercode zurückgeben..
Ja natürlich. Wenn du Lust hast, kannst du es gerne übernehmen. Ich lehne mich jetzt zurück :sm24: .
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo super gemacht.
Ich hätte noch mal eine frage dazu. Da ich nur Hobbymässig SPS Programmiere bin ich nicht so der Freund von Berechnungen der Adresse. Es gibt doch auch die Möglichkeit mit Namen zu adressieren ?

z.b Berechnest du die Adresse der Start und Endzeit. Dies müsste dich auch per Nahmen und einer For schleife funktionieren ?
 
Verstehe ich nicht ganz. Zeig doch mal!

Nun ja mihilfe der Startadresse ... der Einfachkeit halber ist die Startadresse jetzt bei 0.0! Dann beginnt (um bei deinen Beispiel aus Post #16 zu bleiben) myarray[1].Wochentag_Start ebenfalls im DB bei Adresse 0.0 alle weiteren Komponenten ergeben sich anhand deren Datentypen bzw. sind halt dann der Offset zu Wochentag_Start.

Jetzt kann ich mithilfe des Array Index meinen Adressenbezug herstellen:
Code:
myAdresse := ((n-1)*UDT_Groesse) + Startadresse => das wäre die Adresse von myarray[n].Wochentag_Start
oder auch:
Code:
myAdresse := ((n* UDT_Groesse) - UDT_Groesse) + Startadresse
wobei dein Code sicher weniger Verarbeitungszeit benötigt.

Alternativ könnte man statt dem ANY-Pointer auch das Array in den IN_OUT Bereich verlegen ... damit gibt man aber die dynamische Berechnung auf (würde nur was bringen wenn das Array immer gleich groß ist)

EDIT:
Hallo super gemacht.
Ich hätte noch mal eine frage dazu. Da ich nur Hobbymässig SPS Programmiere bin ich nicht so der Freund von Berechnungen der Adresse. Es gibt doch auch die Möglichkeit mit Namen zu adressieren ?

z.b Berechnest du die Adresse der Start und Endzeit. Dies müsste dich auch per Nahmen und einer For schleife funktionieren ?

Hallo emilio!

Das wäre dann ein Fall für die Anwendung im IN/OUT Bereich! Oder du legst dir im temp. Bereich nochmals eine UDT an und kopierst dir am Beginn der Schleife deine Adressen dort hinein! Danach kannst du symbolisch darauf zugreifen! Würde die Leserlichkeit erheblich verbessern sobald man davon ausgehen kann, dass die Adressberechnung stimmt.
 
Zuletzt bearbeitet:
Hallo super gemacht...
Danke.

.. bin ich nicht so der Freund von Berechnungen der Adresse...
Nun ja, wer das Eine will muß das Andere mögen :) .

.. Es gibt doch auch die Möglichkeit mit Namen zu adressieren ?...
Man könnte eine Variable vom Typ UDT1 tempörär anlegen, die die man die Daten der jeweiligen Schaltzeit hinein kopiert. Dann könnte man mit dieser UDT-Variable symbolisch hantieren. Allerdings ist zum Kopieren ebenfalls eine Adressberechnung notwendig. Man gewinnt dabei nichts.



Gruß, Onkel
 
Zuletzt bearbeitet:
Hallo

Kannst du mir diesen Teil mal genauer erklären ?

Code:
// Überprüfung Datenbereich

  
IF SHR(IN:=SZP.ZEIGER, N:=24) <> 2#10000100 OR         // kein DB ????
   SZP.TYP <> 16#02 OR                                 // Typ nicht Byte       ?????
   SZP.ANZAHL_TYP MOD 10 <> 0                          // Länge Datenbereich nicht plausibel  ?????
   THEN RETURN;
END_IF;
 
Zuletzt bearbeitet:
Hallo

Kannst du mir diesen Teil mal genauer erklären ?

Code:
// Überprüfung Datenbereich

  
IF SHR(IN:=SZP.ZEIGER, N:=24) <> 2#10000100 OR         // kein DB ????
   SZP.TYP <> 16#02 OR                                 // Typ nicht Byte       ?????
   SZP.ANZAHL_TYP MOD 10 <> 0                          // Länge Datenbereich nicht plausibel  ?????
   THEN RETURN;
END_IF;

Das sind im Prinzip nur Sicherheitschecks, damit du nicht jeden beliebigen Datenbereich von außen anlegen kannst (denn das könntest du bei einen ANY-Pointer ohne weiteres tun). Mithilfe dieser Abfrage ist der Bereich zumindest eingegrenzt.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Emilio,

generell kannst du auf diesen Programmteil verzichten. Er dient eigentlich nur dazu, nach Möglichkeit zu überprüfen ob an dem Bausteinparameter tatsächlich der richtige ANY angetragen ist.

Mit dem Aufbau von Pointern und ANY-Pointern hast du dich schon angefreundet?

In der Variable "SZP.ZEIGER" steht ein bereichsübergreifender Zeiger, so wie er in dem ANY-Pointer enthalten ist. Dieser besteht aus vier Byte.

Code:
00000000_00000yyy_yyyyyyyy_yyyyyxxx - bereichsinterner Zeiger (der Vollständigkeit halber)
10000zzz_00000yyy_yyyyyyyy_yyyyyxxx - bereichsübergreifender Zeiger
Die "1" ganz links unterscheidet die beiden.
"zzz" kennzeichnet den Operandenbereich, "100" steht für Globaldaten (DBX).
Die y.. bilden die Byte-Adresse und x.. bilden die Bit-Adresse.
Die Nullen haben keine Bedeutung.

Durch "SHR" wird das Bitmuster um 24 Stellen (N:=24) nach rechts verschoben, frei werdende Stellen werden mit Nullen aufgefüllt. Das linke Byte steht jetzt rechtsbündig im Akku. Wenn dieses Byte nicht "10000100" beinhaltet, wird die Bearbeitung des Bausteins abgebrochen. Das dient u.a. auch dazu, die Dummheit zu verhindern, Parameter wie Schaltzeiten in den Lokaldaten ab zu legen. Manche Leute machen so etwas.

Mit "SZP.TYP <> 16#02"wird überprüft, ob der Datentyp als "Byte" angegeben ist. Symbolisch angelegte ANY-Pointer werden vom Compiler mit dem Datentyp "Byte" generiert. Die Erkennung des Datentyps ist wichtig, da er zur Ermittlung der Anzahl der Datensätze von Bedeutung ist. Greift man auf einen Datenbereich zu, der nicht in ein ARRAY oder STRUCT verpackt ist, dann kann man den Parameter auch absolut angeben und auch mit anderen Datentypen (z.Bsp. "P#DB1.DBX0.0 WORD 100"). Der Baustein würde jeden ANY-Pointer annehmen. Daher macht eine Überprüfung generell schon Sinn.

Mit "SZP.ANZAHL_TYP MOD 10" wird ganz einfach noch mal überprüft, ob der Datenbereich genau durch 10 teilbar ist. Bei verschachtelten STRUCTs können leicht mal Schreibfehler am ANY passieren, die u.U. hierdurch erkannt werden.

Man kann diese Überprüfung weglassen. Man könnte aber auch, wie es nutellahase schon genannt hat, Fehlercodes erzeugen und an RET_VAL als INT ausgeben. Für den Schaltuhr-Ausgang dann einen normalen OUT verwenden.

"RETURN" beendet die Bearbeitung des Bausteins. Bei einer FC ist wichtig dass vorher, bzw. generell in jedem Zyklus, alle Ausgänge beschrieben werden, "SCHALTZEITUHR := false" steht deswegen ganz weit oben!


Gruß, Onkel
 
OK vielen dank erst mal .
habe mich mit Zeigern bisher noch nicht beschäftigt da ich in SCL eine Symbolische Addresierung verwendet habe.

Also verschiebst du hier den Zeiger um 3 nach rechts
BYTE_INDEX := WORD_TO_INT(DWORD_TO_WORD(SHR(IN:=SZP.ZEIGER, N:=3)) AND 16#00FF);

somt erhäst du
Code:
10000zzz_00000yyy_yyyyyyyy_yyyyy

Und was bedeute jetzt "AND 16#00FF" ?

wie erhälst du hier die Startadresse ?

Ein Zeiger sie doch so aus P#DB1.DBX0.0 WORD 100"
Das kenne ich ja
Jetzt mochte ich doch diesen Teil erhalten
0.0
 
Zuletzt bearbeitet:
Jetzt hast du genau die Zeile erwischt, in der ich einen Fehler hatte!
Und nicht korrigiert.

Nach dem Rechtsschieben steht die Byte-Adresse rechtsbündig im Akku.

Code:
00010000_10000000_yyyyyyyy_yyyyyyyy

"16#00FF" war der Fehler, es muß dort "16#FFFF" stehen.
"16#FFFF" ist nichts anderes als

Code:
00000000_00000000_11111111_11111111

Durch das "Verunden" mit "AND" werden die ersten beiden Bytes auf Null gesetzt. Übrig bleibt dann nur noch die Byte-Adresse.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo

kannst du mir sagen wie ich eine TOD in diese Adresse schreiben?
ZEIT ist eine TOD VAR.

ZEIT : TOD;


WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX] :=DWORD_TO_WORD(DINT_TO_DWORD(TOD_TO_DINT ZEIT));

Da kommt immer ein fehler ?
 
Hallo

kannst du mir sagen wie ich eine TOD in diese Adresse schreiben?
ZEIT ist eine TOD VAR.

ZEIT : TOD;


WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX] :=DWORD_TO_WORD(DINT_TO_DWORD(TOD_TO_DINT ZEIT));

Da kommt immer ein fehler ?

Code:
// Aktuelle Systemzeit
TEMP_INT := READ_CLK(CDT := AKT_DT);

// Aktuelle Tageszeit
AKT_T := DT_TOD(IN := AKT_DT);

Mit diesen Anweisungen wird die Systemzeit ausgelesen und umgewandelt!

Gruß
 
Ja das weiß ich
ich wollte eine Mux erstellen mit dem ich mich am Panel durch den Array blättern kann. Wenn ich einen Wert in den Array speichern möchte muss ich die Variable ZEIT in die entsprechende Adresse schreiben.

Der Code sied bis jetzt so aus
Code:
(***********************UDT***********************************************************************************************)

TYPE SCHALTZEITEN
    STRUCT
    ZEIT: TOD:=TOD#0:0:0.000;
    //BYTE  x.1=SO x.2=MO x.3=DI x.4=MI x.5=DO x.6=FR x.7=SA 
                frei      :BOOL;
                Sonntag   :BOOL;
                Montag    :BOOL;
                Dienstag  :BOOL;
                Mittwoch  :BOOL;
                Donnerstag:BOOL;
                Freitag   :BOOL;
                Samstag   :BOOL;
                
    EREIGNIS : BOOL; //0=AUS 1=EIN   
    END_STRUCT
END_TYPE

(*************************ENDE UTD***************************************************************************************)



(************************************************************************************************************************)
FUNCTION "SCHALTZEITUHR": BOOL
(************************************************************************************************************************)
VAR_INPUT
  SCHALTZEITPAARE                   : ANY;                          // ANY-Pointer auf x Schaltzeitpaare
END_VAR

VAR_OUTPUT
    
    PULS_EIN                         :BOOL;
    PULS_AUS                         :BOOL;
    
END_VAR


VAR_TEMP
  ANY_SZP                           : ANY;
  SZP AT ANY_SZP:
    STRUCT
      ID                            : BYTE;
      TYP                           : BYTE;
      ANZAHL_TYP                    : INT;
      DB_NR                         : WORD;
      ZEIGER                        : DWORD;
    END_STRUCT;
  WD                                : INT;                           // Wochentag
  ANZAHL_SZP                        : INT;
  BYTE_INDEX                        : INT;
  n                                 : INT;
  TEMP_INT                          : INT;
  AKT_T                             : TOD;
  AKT_DT                            : DT;
  ADT AT AKT_DT:
    STRUCT
      JAHR                          : BYTE;
      MONAT                         : BYTE;
      TAG                           : BYTE;
      STUNDE                        : BYTE;
      MINUTE                        : BYTE;
      SEKUNDE                       : BYTE;
      MS_MSD                        : BYTE;                          // MSD (most significant decade) von ms 
      MS_LSD                        : BYTE;                          // LSD (least significant decade) von ms & Wochentag
    END_STRUCT;
  SPS_TIME_I                        :DINT;    
END_VAR


BEGIN

// Initialisierung
SCHALTZEITUHR := false;

// Überprüfung Datenbereich
ANY_SZP := SCHALTZEITPAARE;
IF SHR(IN:=SZP.ZEIGER, N:=24) <> 2#10000100 OR         // kein DB
   SZP.TYP <> 16#02 OR                                 // Typ nicht Byte
   SZP.ANZAHL_TYP MOD 6 <> 0                          // Länge Datenbereich nicht plausibel
   THEN RETURN;
END_IF;

// Ermittlung der Anzahl der Schaltzeitpaare 
ANZAHL_SZP := SZP.ANZAHL_TYP / 6;
// Startadresse ermitteln
//Nach dem Rechtsschieben steht die BYTE-Adresse rechtsbündig im Akku.
//Durch das "Verunden" mit "AND" werden die ersten beiden Bytes auf Null gesetzt. Übrig bleibt dann nur noch die BYTE-Adresse. 
BYTE_INDEX := WORD_TO_INT(DWORD_TO_WORD(SHR(IN:=SZP.ZEIGER, N:=3)) AND 16#FFFF);

// Aktuelle Systemzeit
TEMP_INT := READ_CLK(CDT := AKT_DT);

// Aktuelle Tageszeit
AKT_T := DT_TOD(IN := AKT_DT); 

// ZEIT ind DINT umwandeln und durch 1000 Teile um sec zu erhalten     
SPS_TIME_I:=TOD_TO_DINT (AKT_T)/1000 ;


// aktueller Wochentag
WD:= DT_DAY(IN :=AKT_DT);

// Schaltzeiten abfragen
FOR n:= 1 TO ANZAHL_SZP DO
// Überprüfen ob Bit für Wochentag true ist
  IF WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,WD] = TRUE THEN
// Abfrage ob Schaltuhr Zeit mit Zeit aktuell übereinstimmt    
     IF SPS_TIME_I = DWORD_TO_DINT(WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX])/1000 AND
        DWORD_TO_DINT(WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX])/1000>0 THEN
// Abfrage ob EREIGNIS EIN oder AUS ist          
        IF WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+5,0]= TRUE THEN
           PULS_EIN:=TRUE;
            EXIT;
        END_IF;
        
        IF WORD_TO_BLOCK_DB (SZP.DB_NR).DX[BYTE_INDEX+5,0]= FALSE THEN
           PULS_AUS:=TRUE;
            EXIT;
        END_IF;
     ELSE
       PULS_EIN:=FALSE;
       PULS_AUS:=FALSE;  
            
     END_IF;
  END_IF;
byte_index:=byte_index+6;
 
END_FOR;

END_FUNCTION;

Das Problem ist hier
Code:
FUNCTION_BLOCK "MUX_SCHALTZEITUHR" 
(*********************************************************************************************************************************************)
VAR_IN_OUT
  SCHALTZEITPAARE                   : ANY;                          // ANY-Pointer auf x Schaltzeitpaare
END_VAR


VAR_TEMP
  ANY_SZP                           : ANY;
  SZP AT ANY_SZP:
    STRUCT
      ID                            : BYTE;
      TYP                           : BYTE;
      ANZAHL_TYP                    : INT;
      DB_NR                         : WORD;
      ZEIGER                        : DWORD;
    END_STRUCT;
  WD                                : INT;                           // Wochentag
  ANZAHL_SZP                        : INT;
  BYTE_INDEX                        : INT;
  n                                 : INT;
  TEMP_INT                          : INT;
  AKT_T                             : TOD;
  AKT_DT                            : DT;
  ADT AT AKT_DT:
    STRUCT
      JAHR                          : BYTE;
      MONAT                         : BYTE;
      TAG                           : BYTE;
      STUNDE                        : BYTE;
      MINUTE                        : BYTE;
      SEKUNDE                       : BYTE;
      MS_MSD                        : BYTE;                          // MSD (most significant decade) von ms 
      MS_LSD                        : BYTE;                          // LSD (least significant decade) von ms & Wochentag
    END_STRUCT;
  SPS_TIME_I                        :DINT;    
END_VAR

VAR
   ZEIT                             :TOD;
   
   frei                             :BOOL;
   Sonntag                          :BOOL;
   Montag                           :BOOL;
   Dienstag                         :BOOL;
   Mittwoch                         :BOOL;
   Donnerstag                       :BOOL;
   Freitag                          :BOOL;
   Samstag                          :BOOL;
                
  EREIGNIS                          :BOOL; //0=AUS 1=EIN  
  SPEICHERN                          :BOOL;
  RESET                             :BOOL;
  ANZEIGE_NR                        :INT;
    
END_VAR    

BEGIN


// Ermittlung der Anzahl der Schaltzeitpaare 
ANZAHL_SZP := SZP.ANZAHL_TYP / 6;
// Startadresse ermitteln
//Nach dem Rechtsschieben steht die BYTE-Adresse rechtsbündig im Akku.
//Durch das "Verunden" mit "AND" werden die ersten beiden Bytes auf Null gesetzt. Übrig bleibt dann nur noch die BYTE-Adresse. 
BYTE_INDEX := WORD_TO_INT(DWORD_TO_WORD(SHR(IN:=SZP.ZEIGER, N:=3)) AND 16#FFFF);

//Anzeige NR bei Max Große SpeicherArray auf Max setzen 
IF ANZEIGE_NR>=ANZAHL_SZP THEN
   ANZEIGE_NR:= ANZAHL_SZP;
END_IF;
//Anzeige NR bei Min Große SpeicherArray auf 1 setzen
IF ANZEIGE_NR <=1 THEN
   ANZEIGE_NR:= 1;
END_IF;



// Werte einlesen
byte_index:=byte_index+(6*(ANZEIGE_NR-1));


ZEIT := DINT_TO_TOD ((DWORD_TO_DINT(WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX]))); 
Sonntag   := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,1];
Montag    := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,2];
Dienstag  := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,3];
Mittwoch  := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,4];
Donnerstag:= WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,5];
Freitag   := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,6];
Samstag   := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,7];
EREIGNIS  := WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+5,0];


// Werte SPEICHERN
IF SPEICHERN = TRUE THEN
  WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX]    :=DWORD_TO_WORD(DINT_TO_DWORD(TOD_TO_DINT ZEIT));????????????????????????????????????????????????????????????
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,1]:=Sonntag;
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,2]:=Montag;
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,3]:=Dienstag; 
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,4]:=Mittwoch ;
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,5]:=Donnerstag;
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,6]:=Freitag;
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+4,7]:=Samstag;
  WORD_TO_BLOCK_DB(SZP.DB_NR).DX[BYTE_INDEX+5,0]:=EREIGNIS;
END_IF;

      
END_FUNCTION_BLOCK;
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Achso okay!
Du willst also die Zeit Variable in ein Doppel des Datenbausteins schreiben!
Mir kommt die Umwandlung in deiner Anweisung etwas komisch vor!
Wieso wandelst du es auf ein Word?!
Quasi schreibst du ein Word in ein Doppel.

Code:
WORD_TO_BLOCK_DB(SZP.DB_NR).DD[BYTE_INDEX]    [COLOR=#FF0000]:=DINT_TO_DWORD(TOD_TO_DINT(ZEIT));[/COLOR]

So müsste es doch gehen!

Gruß
 
..ich wollte eine Mux erstellen..

Das ging aber schnell ;) .

Wenn ich dir noch einen Tipp zum HMI-Multiplexen geben darf, dann lege im DB einen weiteren Datensatz vom Typ UDTx mit dem Namen "HMI_DATEN" an. Diesen verwendest du als einzigen Datensatz am Panel. Bei Anwahl änderst du deine "ANZEIGE_NR". Mit der Änderung der "ANZEIGE_NR" kopierst du einmalig den jeweiligen Datensatz in deine "HMI_DATEN", nur um die Daten bei Anwahl erst einmal am Panel an zu zeigen. Jetzt hast du verschiedene Möglichkeiten, deine Eingaben zu speichern. Die einfachste Möglichkeit ist ein zusätzliches Bit zur Übernahme. Eine zweite Möglichkeit ist die Überwachung der "HMI_DATEN" auf Änderungen. Wenn du sicher gehen möchtest dass dabei nichts schief geht, speicherst du in jeden Datensatz noch dessen "ANZEIGE_NR" zur Verifizierung mit ab. Daten dürfen nur dann in den Datensatz geschrieben werden, wenn die "ANZEIGE_NR" der "HMI_DATEN" mit der "ANZEIGE_NR" des Datensatzes überein stimmt.

Dann klappt das auch mit dem "BIER_HOLEN" :ROFLMAO:

Code:
BIER_HOLEN : ARRAY  [1 .. 1000 ] OF UDT 1;   // EINTAUSEND Schaltzeiten


Gruß, Onkel
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Onkel
Habe deinen Beitrag erst jetzt gelesen. Ich habe mir jetzt einen FB erstellt der MUX kann,
Ich stell mal das Projekt ein ,du kannst es ja mal anschauen und sagen was nicht ganz ok ist.

Zu der Funktion

Ich Pulse nur die Ausgänge für ca 1sec.

Ich muss mich mal mit den Bytes in einer Adresse beschäftige damit ich weis wo was steht. Aber dank deiner hilfe dat dies super Funktionier.
 

Anhänge

  • SCHALTUHR.zip
    6,1 MB · Aufrufe: 18
Morgen!

Also ein paar kleinigkeiten sind mir da aufgefallen!

Beim FC Schaltzeituhr verwendest du den RET_VAL Ausgang ja nicht mehr!
Also kannst folgende Zeile ändern:
Code:
FUNCTION "SCHALTZEITUHR": BOOL
[COLOR=#ff0000]FUNCTION "SCHALTZEITUHR": VOID[/COLOR]

Somit fällt auch diese hier weg:
Code:
[COLOR=#ff0000]// Initialisierung
SCHALTZEITUHR := false;[/COLOR]

Das anbinden an die Visu passt schon so!
Das einzige was mir aufgefallen ist das dort bei der Auswahl der Schaltzeitpaare "AK_ANZEIGE" statt "ANZEIGE_NR" verwendet ist!Passt das schon soooo???
Nur der Zugriff auf den Instanz DB ist halt Geschmacksache!Ich würde das nicht machen!
Wenn du jetzt mal was an dem Baustein änderst!Verschieben sich ja auch die Adressen!
Somit müsstest die Visu auch wieder neu Synchronisieren!

Gruß
 
Zuletzt bearbeitet:
Code:
Das einzige was mir aufgefallen ist das dort bei der Auswahl der  Schaltzeitpaare "AK_ANZEIGE" statt "ANZEIGE_NR" verwendet ist!Passt das  schon soooo???

Ja das Passt habe ich so gamacht damit wirklich nur das angezeigt wird was grade geladen ist.

Code:
Nur der Zugriff auf den Instanz DB ist halt Geschmacksache!Ich würde das nicht machen!

Ich verwende doch den Instanz DB damit ich nicht all 10 bzw 3 Schaltzeitpaare einseln am Panel Adrssieren muss. Was wäre eine bessere Lösung hierzu ?
 
Zurück
Oben