Probleme mit SFC 14 / SFC 15 in FB

smartie

Level-1
Beiträge
298
Reaktionspunkte
22
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen, ich bastle mir im Moment mehrere FB´s zur Steuerung mehrerer Servos über Profibus.

Zum Lesen und Schreiben der Daten benutze ich die SFC14 / SFC15.

Code:
  [B]Netzwerk 1[/B]

      L     #IO_ADRESSE               // IN : INT
      T     #Adresse                  // TEMP : WORD

[B]Netzwerk 2[/B]
 
 CALL  SFC   14                       // Daten von DP-Slave lesen
       LADDR  :=#Adresse              // TEMP : WORD
       RET_VAL:=#RET_VAL_SFC14        // TEMP : WORD
       RECORD :=#PI                   // STAT : STRUCT
 
[B]Netzwerk 3 [/B]   

 CALL  SFC   15                       // Daten auf DP-Slave schreiben
       LADDR  :=#Adresse              // TEMP : WORD
       RECORD :=#PO                   // STAT : STRUCT
       RET_VAL:=#RET_VAL_SFC15        // TEMP : WORD
Rufe ich den FB nun einmal in meinem Programm auf, so empfange ich alle Daten aus meinem Servo im STRUCT PI und kann damit arbeiten.

Probleme gibts aber beim Schreiben:
Setze ich ein Bit vom STRUCT PO so sehe ich zwar das das Bit in meinem FB gesetzt ist, am DP-Slave aber toggelt das Bit.

Probleme habe ich also scheinbar nur beim Schreiben der Daten.

Aber ich erkenne keinen Unterschied zwischen SFC 14 und SFC 15.

Kann mir jemand von euch auf die Sprünge helfen?

Gruß smartie
 
Hallo Smartie,
die Adressen von der Ein.-und Ausgang Peripherie stimmen im
DP-Teilnehmer überein. Der Struct ist nicht länger wie die Ausgang-
Peripherie. Was gibt den der Ret_Val vom SFC_15 zurück?

gruß Helmut
 
Zuviel Werbung?
-> Hier kostenlos registrieren
So, gerade eben als ich den PC runter fahren und Feierabend machen wollte ist mir eingefallen wo mein Problem liegt:

Ich habe für verschiedene Funktionen der Servos verschiedene FB´s erstellt.
Also für Tippen, Referenzieren, etc.

Diese FB´s enthalten alle die SFC 14 und SFC 15.


Da alle FB´s permanent bearbeitet werden schreibe und lese ich also immer wieder mit den beiden SFC´s von der gleichen Adresse.

Und das scheint wohl nicht so einfach zu gehen.

Wenn ich nämlich nur einen der ingesamt 8 FB´s aufrufe dann toggelt mein Bit nicht mehr.

Da einige der FB´s sehr viele Anschlüsse haben möchte ich nicht gerne nur einen großen FB machen, sondern schon wie geplant je Funktion einen FB.

Auch den Umweg über einen FB in den ich die Daten vom DP-Slave einlese und reinschreibe möchte ich nicht unbedingt gehen.

Am liebsten würde ich schon für jede Funktion einfach die EA - Adresse des DP-Slave angeben und fertig...

Hatte schon mal jemand mit der Problematik zu tun?

Gruß smartie

@ Helmut : Die Adressen stimmen natürlich und RETVAL beider SFC´s ist 0. Trotzdem Danke :)
 
also das was du da vorhast ist nicht so günstig, einen mehrmaligen
aufruf des sfc14-15 für den selben Teilnehmer, das kann nicht
funktionieren.
Du solltest vlt. deine FB's für deine Betriebsarten beibehalten und
koordninieren und dann zum schluß die SFC für den Teilnehmer nur
einmal aufrufen.
 
Guten Morgen,

ja das hatte ich schon befürchtet.

@ Helmut : Was meinst du mit

Du solltest vlt. deine FB's für deine Betriebsarten beibehalten und
koordninieren und dann zum schluß die SFC für den Teilnehmer nur
einmal aufrufen.

Gruß smartie
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Du hast doch für jede Betriebsart einen FB, aus diesen FB's sammelst du
die Information die für dich wichtig sind und verschaltest die dann
auf einen FB der für die Komunikation mit deinen Umrichter verantwortlich
ist.

Für mich hört sich das ein wenig nach SEW an was du da hast.
Ich mache das so das ich einen FC habe wo ich alles mit mache,
dann habe ich ein dazu gehörigen UDT für die Daten. Diese Daten
kann ich dann Global oder als Instanz ablegen und füttere diese.
An den FC lege ich nur noch den Zeiger wo die Daten liegen.

Code:
FUNCTION "SEW_SBP" : VOID
TITLE =SEW-Servo: Buspositonierung
AUTHOR : HO
FAMILY : SEW
NAME : BUS_POSI
VERSION : 0.1
 
VAR_INPUT
  Daten_Zeiger : ANY ; //Zeiger Ablage Daten für die Achse
END_VAR
VAR_TEMP
  PI : STRUCT  //Prozeßeingangsdaten
   Status : BYTE ; //PE: Status Umrichter
   Motor_turning : BOOL ; //PE: Motor läuft
   Inverter_ready : BOOL ; //PE: Umrichter bereit
   referenced : BOOL ; //PE: Achse Referenziert
   Target_position_reached : BOOL ; //PE: Ziel Position erreicht
   Brake_released : BOOL ; //PE: Bremse gelöst
   Error : BOOL ; //PE: Fehler
   Limit_Switch_CW : BOOL ; //PE: Endschalter Rechts
   Limit_switch_CCW : BOOL ; //PE: Endschalter Links
   Actual_position : DINT ; //PE: Aktuelle Position
   Actual_speed : INT ; //PE: Aktuelle Geschwindigkeit
   Active_current : INT ; //PE: Aktueller Motor-Strom
   Device_utilisation : INT ; //PE: Aktuelle Geräteauslastung
  END_STRUCT ; 
  PO : STRUCT  //Prozeßausgangsdaten
   start : BOOL ; //PA: Start
   Jog_plus : BOOL ; //PA: Tippen +
   Jog_minus : BOOL ; //PA: Tippen -
   mode_low : BOOL ; //PA: Mode Bit Low
   mode_high : BOOL ; //PA: Mode Bit High
   CTW_Bit_13 : BOOL ; //PA: Bit 13
   CTW_Bit_14 : BOOL ; //PA: Bit 14
   SWES : BOOL ; //PA: /Softwareendschalter
   Contr_inhibit : BOOL ; //PA: Reglersperre - /Freigabe
   Rapid_stop : BOOL ; //PA: Freigabe - /Schnellstop
   Stop : BOOL ; //PA: Freigabe - /Halt
   hold : BOOL ; //PA: /Halteregelung
   Ramp : BOOL ; //PA: Rampen
   Para : BOOL ; //PA: Parameter
   Reset_fault : BOOL ; //PA: Reset
   CTW_Bit_7 : BOOL ; //PA: Bit 7
   Setpoint_position : DINT ; //PA: Soll Position
   Setpoint_speed : INT ; //PA: Soll Geschwindigkeit
   Start_ramp : INT ; //PA: Hochlauf Rampe
   Stop_ramp : INT ; //PA: Tieflauf Rampe
  END_STRUCT ; 
  Daten : STRUCT  //Zeiger für DB und Adresse der Anzeige
   DB_Nr : INT ; //Anzeige-DB Nr
   Adresse : DWORD ; //Anzeige Start-Adresse im DB
  END_STRUCT ; 
  Ref : BOOL ; //Referenz
  Pos : BOOL ; //Positonierung angewählt
  Peripherie : WORD ; //Peripherie-Zeiger Umrichter
  RET_VAL_SFC14 : INT ; //Rückgabe vom DP lesen
  RET_VAL_SFC15 : INT ; //Rückgabe zum DP schreiben
  Merker : BOOL ; //Temponärer Merker
END_VAR
BEGIN
NETWORK
TITLE =Daten-Zeiger umladen
//ANY-Zeiger umladen
      L     P##Daten_Zeiger; 
      LAR1  ; 
//DB-Nr Temp. zwischenspeichern
      L     W [AR1,P#4.0]; 
      T     #Daten.DB_Nr; 
//Adresse Temp. zwischenspeichern
      L     D [AR1,P#6.0]; 
      T     #Daten.Adresse; 
NETWORK
TITLE =Datenbaustein aufschlagen und Adressregister stellen
      AUF   DB [#Daten.DB_Nr]; 
      LAR1  #Daten.Adresse; 
NETWORK
TITLE =Daten aus den Umrichter lesen
//Zeiger Peripherie stellen
      L     DBW [AR1,P#0.0]; //SEW_SBP_Daten.DRIVE_IO_ADDRESS
      T     #Peripherie; 
//Eingangsdaten vom FU lesen
      CALL "DPRD_DAT" (
           LADDR                    := #Peripherie,
           RET_VAL                  := #RET_VAL_SFC14,
           RECORD                   := #PI);
//Adressregister wieder herstellen
      LAR1  #Daten.Adresse; 
//Fehlerauswertung "vom FU-lesen"
      L     #RET_VAL_SFC14; 
      L     0; 
      <>I   ; 
      SPB   ERR; 
NETWORK
TITLE =Prozeßeingangsdaten aufbereiten und Rangieren
//Aktuelle Position
      L     #PI.Actual_position; 
      T     DBD [AR1,P#18.0]; //SEW_SBP_Daten.ACTUAL_POSITION
//Aktuelle Geschwindigkeit
      L     #PI.Actual_speed; 
      T     DBW [AR1,P#22.0]; //SEW_SBP_Daten.ACTUAL_SPEED
//Aktueller Strom
      L     #PI.Active_current; 
      T     DBW [AR1,P#24.0]; //SEW_SBP_Daten.ACTUAL_CURRENT
//Aktuelle Geräteauslastung
      L     #PI.Device_utilisation; 
      T     DBW [AR1,P#26.0]; //SEW_SBP_Daten.DEVICE_UTILISTION
//FU-Bereit
      U     #PI.Inverter_ready; 
      =     DBX [AR1,P#14.3]; //SEW_SBP_Daten.INVERTER_READY
//Zielpostion erreicht
      U     #PI.Target_position_reached; 
      =     DBX [AR1,P#14.7]; //SEW_SBP_Daten.TARGET_POS_REACHED
//Referenziert
      U     #PI.referenced; 
      =     DBX [AR1,P#14.6]; //SEW_SBP_Daten.REFERNCED
//Endschalter Rechts
      U     #PI.Limit_Switch_CW; 
      =     DBX [AR1,P#15.0]; //SEW_SBP_Daten.SWITCH_max
//Endschalter Links
      U     #PI.Limit_switch_CCW; 
      =     DBX [AR1,P#15.1]; //SEW_SBP_Daten.SWITCH_min
//Warnung
      U     #PI.Inverter_ready; 
      U     #PI.Error; 
      =     DBX [AR1,P#14.2]; //SEW_SBP_Daten.WARNING_OF_AXIS
//Fehler
      UN    #PI.Inverter_ready; 
      U     #PI.Error; 
      =     DBX [AR1,P#14.1]; //SEW_SBP_Daten.FAULT_OF_AXIS
//Fehler vorhanden???
      U     #PI.Error; 
      SPB   EL; 
//Kein Fehler "0" laden
      L     0; 
      SPA   ENR; 
//Fehler vorhanden und Rangieren
EL:   L     #PI.Status; 
ENR:  T     DBW [AR1,P#16.0]; //SEW_SBP_Daten.FAULT_NO
NETWORK
TITLE =Prozeßausgangsdaten aufbereiten und rangieren
//Freigabe - /Schnellstopp rangieren
      U     DBX [AR1,P#2.0]; //SEW_SBP_Daten.ENABLE_RAPID_STOP
      =     #PO.Rapid_stop; 
//Tippen plus angewählt
      U     DBX [AR1,P#2.2]; //SEW_SBP_Daten.JOG_PLUS_MODE
      UN    DBX [AR1,P#2.3]; //SEW_SBP_Daten.JOG_MINUS_MODE
      UN    DBX [AR1,P#2.4]; //SEW_SBP_Daten.REF_TRAVEL_MODE
      UN    DBX [AR1,P#2.5]; //SEW_SBP_Daten.POSITIONING_MODE
      =     #PO.Jog_plus; 
//Tippen minus angewählt
      UN    DBX [AR1,P#2.2]; //SEW_SBP_Daten.JOG_PLUS_MODE
      U     DBX [AR1,P#2.3]; //SEW_SBP_Daten.JOG_MINUS_MODE
      UN    DBX [AR1,P#2.4]; //SEW_SBP_Daten.REF_TRAVEL_MODE
      UN    DBX [AR1,P#2.5]; //SEW_SBP_Daten.POSITIONING_MODE
      =     #PO.Jog_minus; 
//Referenzieren angewählt
      UN    DBX [AR1,P#2.2]; //SEW_SBP_Daten.JOG_PLUS_MODE
      UN    DBX [AR1,P#2.3]; //SEW_SBP_Daten.JOG_MINUS_MODE
      U     DBX [AR1,P#2.4]; //SEW_SBP_Daten.REF_TRAVEL_MODE
      UN    DBX [AR1,P#2.5]; //SEW_SBP_Daten.POSITIONING_MODE
      =     #Ref; 
//Positionieren angewählt
      UN    DBX [AR1,P#2.2]; //SEW_SBP_Daten.JOG_PLUS_MODE
      UN    DBX [AR1,P#2.3]; //SEW_SBP_Daten.JOG_MINUS_MODE
      UN    DBX [AR1,P#2.4]; //SEW_SBP_Daten.REF_TRAVEL_MODE
      U     DBX [AR1,P#2.5]; //SEW_SBP_Daten.POSITIONING_MODE
      =     #Merker; 
      U     #Merker; 
      U     #PI.referenced; 
      =     #Pos; 
      U     #Merker; 
      UN    #PI.referenced; 
      =     DBX [AR1,P#14.5]; //SEW_SBP_Daten.NOT_REFERENCED 
//Software Endschalter freifahren
      U     #PI.Motor_turning; 
      SPB   SWES; 
      SET   ; 
      U     DBX [AR1,P#2.5]; //SEW_SBP_Daten.SOFT_SWITCH_RELEASE
      =     #PO.SWES; 
SWES: NOP   0; 
//Anwahl "mode_low"
      O     #PO.Jog_plus; 
      O     #PO.Jog_minus; 
      O     #Pos; 
      =     #PO.mode_low; 
//Halteregelung
      UN    #PO.mode_low; 
      UN    #Ref; 
      =     #PO.hold; 
//Anwahl "Mode high"
      O     #Ref; 
      O     #Pos; 
      =     #PO.mode_high; 
//Freigabe - /Halt via Feldbus
      U     #PO.Rapid_stop; 
      =     #PO.Stop; 
      UN    #Merker; 
      =     DBX [AR1,P#14.4]; //SEW_SBP_Daten.AXIS_INTERLOCKED
//Fault_Reset
      U     DBX [AR1,P#2.1]; //SEW_SBP_Daten.RESET
      =     #PO.Reset_fault; 
//Start Freigabe
      U     #PI.Brake_released; 
      =     #PO.start; 
//Rücksetzen aller nicht verwendeten Steuerwort-Bits
      SET   ; 
      R     #PO.Contr_inhibit; 
      R     #PO.Ramp; 
      R     #PO.Para; 
      R     #PO.CTW_Bit_13; 
      R     #PO.CTW_Bit_14; 
      R     #PO.SWES; 
//Sollwerte übertragen
      L     DBD [AR1,P#4.0]; //SEW_SBP_Daten.Job.SETPOINT_POS
      T     #PO.Setpoint_position; 
      L     DBW [AR1,P#8.0]; //SEW_SBP_Daten.SETPOINT_SPEED
      T     #PO.Setpoint_speed; 
      L     DBW [AR1,P#10.0]; //SEW_SBP_Daten.START_RAMP
      T     #PO.Start_ramp; 
      L     DBW [AR1,P#12.0]; //SEW_SBP_Daten.STOP_RAMP
      T     #PO.Stop_ramp; 
NETWORK
TITLE =Daten zum Umrichter schreiben
//Ausgangsdaten an FU schreiben
      CALL "DPWR_DAT" (
           LADDR                    := #Peripherie,
           RECORD                   := #PO,
           RET_VAL                  := #RET_VAL_SFC15);
//Adressregister wieder herstellen
      LAR1  #Daten.Adresse; 
//Fehlerauswertung "an FU schreiben"
      L     #RET_VAL_SFC15; 
      L     0; 
      <>I   ; 
      SPB   ERR; 
      SET   ; 
      =     DBX [AR1,P#14.0]; //SEW_SBP_Daten.COMMUNICATION_OK
//Baustein Beenden "Kein Fehler"
      BEA   ; 
NETWORK
TITLE =Kommunikationsfehler auswerten
ERR:  L     0; 
      T     DBW [AR1,P#16.0]; //SEW_SBP_Daten.FAULT_NO
      T     DBD [AR1,P#18.0]; //SEW_SBP_Daten.ACTUAL_POSITION
      T     DBW [AR1,P#22.0]; //SEW_SBP_Daten.ACTUAL_SPEED
      T     DBW [AR1,P#24.0]; //SEW_SBP_Daten.ACTUAL_CURRENT
      T     DBW [AR1,P#26.0]; //SEW_SBP_Daten.ACTUAL_DEVICE_UTILISTION
      SET   ; 
      R     DBX [AR1,P#14.0]; //SEW_SBP_Daten.COMMUNICATION_OK
      R     DBX [AR1,P#14.1]; //SEW_SBP_Daten.FAULT_OF_AXIS
      R     DBX [AR1,P#14.2]; //SEW_SBP_Daten.WARNING_OF_AXIS
      R     DBX [AR1,P#14.3]; //SEW_SBP_Daten.INVERTER_READY
      R     DBX [AR1,P#14.4]; //SEW_SBP_Daten.AXIS_INTERLOCKED
      R     DBX [AR1,P#14.5]; //SEW_SBP_Daten.NOT_REFERENCED
      R     DBX [AR1,P#14.6]; //SEW_SBP_Daten.REFERNCED
      R     DBX [AR1,P#14.7]; //SEW_SBP_Daten.TARGET_POS_REACHED  
END_FUNCTION
 
hier der UDT
Code:
TYPE "SEW_SBP_Daten"
TITLE =Daten SEW-Servo:  Erweiterte Buspositonierung
VERSION : 0.1
 
  STRUCT  
   DRIVE_IO_ADDRESS : INT ; //Umrichter Adresse
   ENABLE_RAPID_STOP : BOOL ; //Freigabe - /Schnellstop
   RESET : BOOL ; //Reset
   JOG_PLUS_MODE : BOOL ; //Tippen Plus
   JOG_MINUS_MODE : BOOL ; //Tippen Minus
   REF_TRAVEL_MODE : BOOL ; //Referenzfahrt
   POSITIONING_MODE : BOOL ; //Positonierung
   SOFT_SWITCH_RELEASE : BOOL ; //Software Endschalter freifahren
   Job : STRUCT  //Auftrag
    SETPOINT_POS : DINT ; //Soll-Position
    SETPOINT_SPEED : INT ; //Soll-Geschwindigkeit
    START_RAMP : INT ; //Hochlaufzeit
    STOP_RAMP : INT ; //Tieflaufzeit
   END_STRUCT ; 
   COMMUNICATION_OK : BOOL ; //SFC14/SFC15: Return Value = 0
   FAULT_OF_AXIS : BOOL ; //Fehler
   WARNING_OF_AXIS : BOOL ; //Warnung
   INVERTER_READY : BOOL ; //Umrichter Bereit
   AXIS_INTERLOCKED : BOOL ; //die Modeanwahl ist unplausibel (kein Mode oder mehrere Modi angewählt)
   NOT_REFERENCED : BOOL ; //Mode Positioning angewählt, obwohl die Achse nicht referenziert ist
   REFERNCED : BOOL ; //Achse ist Referenziert
   TARGET_POS_REACHED : BOOL ; //Ziel Position erreicht
   SWITCH_max : BOOL ; //Endlage max angefahren
   SWITCH_min : BOOL ; //Endlage min angefahren
   FAULT_NO : INT ; //Fehler Nr
   ACTUAL_POSITION : DINT ; //Aktuelle Position
   ACTUAL_SPEED : INT ; //Aktuelle Geschwindigkeit
   ACTUAL_CURRENT : INT ; //Aktueller Motorstrom
   DEVICE_UTILISATION : INT ; //Aktuelle Geräteauslastung
  END_STRUCT ; 
END_TYPE
 
Hallo Helmut,

fast richtig getippt, ist zwar von SEW aber Moviaxis. :p

Vielen Dank für dein Beispiel.

Im Prinzip ist mir das schon klar, aber wenn ich es richtig verstehe entspricht dein FC jeweils einem meiner FB´s.
Du steuers doch mit dem einen FC einen Servo und verwendest dann nur einmal die SFC14 / SFC15 für diesen einen Servo.

Aber letzten endes machst du doch auch nichts anderes als die Daten vom
Servo in einen DB zu transferieren und liest sie dann da wieder aus.

Oder verstehe ich da was falsch?

Für mein Projekt benötige ich 8 FB´s für einen Servo die insgesamt etwa 50 Ausgänge haben.
Wenn ich das nun in einem FB oder auch FC machen würde wäre der ja riesig?

Insgesamt habe ich übrigens 4 Servoachsen.

Gruß smartie
 
Im Moment habe ich je Achse 15 Wörter einzeln.

Ich könnte aber auch 60 Wörte zusämmenhängend zusammenhängend lesen bzw. schreiben.

Ich finde halt je Achse einen Peripheriebereich einfach übersichtlicher.
 
ja ist doch gut so, jetzt kannst du doch für jede achse ein FB
oder einen FC machen. Und dann da nur für diese Achse die
Daten übertragen.

Wenn du jetzt z.b. mein Beispiel nimmst, legst du einen FB an
in diesen FB Deklariest du für jede Achse einmal den UDT dann
fütterst im FB die Achsen mit Daten und rufst dann für jede
Achse den FC auf.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ok, ich habe mir jetzt die "Mühe" ;) gemacht deinen Code mal als Quelle zu importieren und sehe das ich den Code wohl doch eher falsch verstanden habe.

Ich habe jetzt FC2 in meinem Programm, dass ist dein FC.

Der benötigt nun einen Datenzeiger.
Hier muss nun wohl die Adresse des DB mit dem UDT angegeben werden.

Soweit verstehe ich es noch. Problematisch wirds nun mit dem UDT.
UDT habe ich bisher noch nicht verwendet.

Ich habe einen DB angelegt in dem ich eine Variable vom Typ UDT1 angelegt habe.
Ich hoffe das ist richtig so?

Aber nun komm ich nicht weiter. Wie beschreibe ich denn nun meinen Datenbaustein?
Vor allem weiß ich nicht wie ich denn nun die IO Adresse angebe.

Und meine FB´s müssen ja auch noch die Daten vom Servo bekommen,
ich will ja in jedem FB alle Informationen vom Servo haben.
 

Anhänge

  • FC2.PNG
    FC2.PNG
    5,8 KB · Aufrufe: 12
  • DB2.PNG
    DB2.PNG
    4,7 KB · Aufrufe: 8
hier ein Beispiel wie ich es mit Instanzen in einen FB gemacht habe,
eigentlich brauchst du das nur erweitern und anpassen.
Unter VAR steht der UDT jeweils für jede Achse, die Daten stehen
später in den zugehörigen Instanzdatenbaustein.


Code:
FUNCTION_BLOCK "Movieaxis"
TITLE =Movieaxies
VERSION : 0.1
 
VAR
  Achse_1 : "SEW_SBP_Daten"; 
  Achse_2 : "SEW_SBP_Daten"; 
  Achse_3 : "SEW_SBP_Daten"; 
  Achse_4 : "SEW_SBP_Daten"; 
END_VAR
BEGIN
NETWORK
TITLE =Achse 1
//I_O Adresse stellen
      L     256; 
      T     #Achse_1.DRIVE_IO_ADDRESS; 
//Achse Vorwärts tippen
      U     M     10.0; 
      =     #Achse_1.JOG_PLUS_MODE; 
//Bausteinaufruf
      CALL "SEW_SBP" (
           Daten_Zeiger             := #Achse_1);
NETWORK
TITLE =Achse 2
//I_O Adresse stellen
      L     272; 
      T     #Achse_2.DRIVE_IO_ADDRESS; 
//Achse Vorwärts tippen
      U     M     11.0; 
      =     #Achse_2.JOG_PLUS_MODE; 
//Bausteinaufruf
      CALL "SEW_SBP" (
           Daten_Zeiger             := #Achse_2);
END_FUNCTION_BLOCK
 
Zuletzt bearbeitet:
Smartie,
in den Beispiel sind alle Achsen in einen FB und einen Instanz DB.
Du kannst natürlich jetzt für jede Achse auch einen eigenen FB
mit Aufruf erzeugen. Oder einen Global DB machen wo die Daten von
den Achsen drinstehen.

Die Beispiele sind nur eine Hilfe und ein wenig zum Nachdenken anregen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ok, jetzt wirds langsam deutlicher.

Der FC2 der die Kommunikation mit der Achse steuert wird in jedem FB aufgerufen.

Was du ja vorhin schon geschrieben hast (ich aber leider nicht so ganz verstanden habe):
Wenn du jetzt z.b. mein Beispiel nimmst, legst du einen FB an in diesen FB Deklariest du für jede Achse einmal den UDT dann
fütterst im FB die Achsen mit Daten und rufst dann für jede Achse den FC auf.

Ich glaube aber ich hab jetzt so langsam mal kapiert wie es gehen könnte.

Gruß smartie
 
Zuletzt bearbeitet:
Aber bitte beachte das du den FC nur einmal für jede Achse aufrufst.
Sonst ist in etwas wie eine Doppel zuweisung von einen Ausgang, hier
ein Beispiel wie ich das meinen.

Code:
U E 0.0
= A 1.0
 
U E 0.1
= A 1.0

in diesen Beispiel kann der Ausgang nur über E 0.1 gesetzt werden
der Eingang E 0.0 hat keine auswirkung.
 
Schon klar.

Ich würde dann jetzt einen FB schreiben der die Kommunikation mit den Achsen handelt (und die Daten in die 4 DB´s mit dem UDT schreibt).

In meinen FB´s die die Funktionen der Achsen steuern greife ich dann auf die Daten aus den 4 DB´s zu.

Ich denke so müsste es doch gehen, oder?
 
Puh, schwere Geburt.

Aber mal was gunrundsätzliches zum Thema UDT:

Wennn ich einen Datenbaustein anlege und als Variable den Typ UDT festlege
dann sieht man ja wenn man diesen DB öffnet nur die eine Variable vom Typ UDT.

Wenn man dann also später mal wissen will was in diesem DB so alles steht dann muss man also noch zusätzlich den UDT öffnen.

Ist das richtig so oder geht das auch einfacher?

Gruß smartie
 
du kannst die Ansicht umschalten unter den Menü Ansicht,
zwischen Deklarationsicht und Datensicht.
In der Datensicht siehst du es dann aufgelöst. Beim Deklarieren
ist es ganz angenehm, die UDT nicht aufgelöst zu sehen, so
ist der Baustein übersichtlicher.
 
Zurück
Oben