- Beiträge
- 9.836
- Reaktionspunkte
- 2.854
und wenn der Spezialist krank oder in Rente oder tot ist, kannst die Maschine wegwerfen... Schöne neue Welt...Genau das kann ja auch von so manchen Maschinenbauer gewollt sein.
Für so jede noch so kleine Störung muss dann der Spezialist ran, über
die Fernwartung oder auch vor Ort. Dieses wird dann teuer bezahlt.
St3.Bohren.Ab(300.000) := St2.Teilekontrolle AND St3.Ready
Gibts dann nen 1000seitiges Handbuch, wo erklärt ist, welche Methoden Objekte Eigenschaften es gibt und was diese tunNur wie die Signale gebildet werden und wo sie herkommen, ist halt nicht einfach erkennbar.
Schließlich können Methoden und Ereignisse über das ganze Programm verteilt sein.
Ist halt wie mit den berühmten Standard-Bausteinen der einzelnen LieferantenGibts dann nen 1000seitiges Handbuch, wo erklärt ist, welche Methoden Objekte Eigenschaften es gibt und was diese tun
Nicht ganz ;-)Gibts dann nen 1000seitiges Handbuch, wo erklärt ist, welche Methoden Objekte Eigenschaften es gibt und was diese tun
Deshalb verstehe ich vermutlich nicht, was daran neu sein soll...Eigentlich wenn man es genau nimmt, wendet jeder SPS-Entwickler der strukturiert die Software aufbaut schon passiv OOP an, in Form von FB's und FUN's
Da du ja recht spezielle Anwendung in Hinsicht auf unterbrechungsfreien Betrieb hast, wirst du sehr wahrscheinlich viel mit Global-DBs arbeiten und mit div. FBs und FCs darauf zugreifen. Bei OOP kannst du nun das alles unter einen gemeinsamen Hut (Objekt) packen. Somit entfallen z.B. viele interne Schnittstellen. Das Durchreichen von Datenstrukturen mit InOut ist so nicht mehr notwendig.Deshalb verstehe ich vermutlich nicht, was daran neu sein soll...
type... end_type;
- Blocks erstellt#Klassenname :class ... end_class;
- Blocks deklariert,type... end_type;
- Blocks statt.type
// enum / structs eg. for class or interface
enCountMode :enum(Up,Down);
//------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------
// Interface ICounter
//-----------------------------------------------------------
ICounter :interface
#pragma intellisense(off)
function GetActualCount() :int;
#pragma intellisense(on)
function Count(viCountValue :int := 1, Mode :enCountMode := enCountMode.Up);
property ActualCount :int read GetActualCount;
end_interface;
//------------------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------
// Class clUpCounter
//-----------------------------------------------------------
clUpCounter :class(ICounter)
//----------------------------------------
// Beschreibung:
// Klasse zum hochzaehlen eniner variable
//----------------------------------------
//---------------------------------------------------
// Member
protected viActualCount :int;
//---------------------------------------------------
// Other instances
//---------------------------------------------------
//Methods and propertys
#pragma intellisense(off)
protected function GetActualCount() :int;
// constructor
protected function clUpCounter(viInitCountValue :int := 0);
#pragma intellisense(on)
public function Count(viCountValue :int := 1, Mode :enCountMode := enCountMode.Up);
public property ActualCount :int read GetActualCount;
end_class;
end_type;
//-----------------------------------------------------------
// Constructor
function clUpCounter.clUpCounter
// set init value
this.viActualCount := viInitCountValue;
end_function;
//-----------------------------------------------------------
// GetActualCount
function clUpCounter.GetActualCount
// Getter
GetActualCount := this.viActualCount;
end_function;
//-----------------------------------------------------------
// Count
function clUpCounter.Count
viActualCount += abs(viCountValue);
end_function;
// Instanzierung
var
objUpCounter01 :clUpCounter();
objUpCounter02 :clUpCounter(5);
end_var;
Ich bin Instandhalter und traue mir OOP zu, und wenn ich es nicht begreife, dann lerne ich es. (In dem Fall einer von 200Mit Interfaces, Vererbung, Methoden und dann den Pointern "This" und "Super" an Anlagen die jemand fremdes programmiert hat, sind 99,5% der Leute einfach überfordert einen Fehler zu finden.
Der eigendliche Programmierer mag ja wissen was er wo macht (eventuell auch nach 5 Jahren noch) aber jemand fremdes hat hier keine Chance in einem angemessenen Zeitrahmen einen Fehler zu finden, geschweige ein Programm zu erweitern.
Mich auch.Hoffentlich noch viele Diskussionen, das Thema Interessiert mich!
Klar kann man alles lernen. Und am besten jeden Tag was neues.Ich bin Instandhalter und traue mir OOP zu, und wenn ich es nicht begreife, dann lerne ich es.
Ich könnte dir etwas zeigen aber das währe so groß dass würde niemand lesen wo es um ds402 für canopen geht. Da ist es so dass 90 Prozent des Protokolls meistens gleich ist aber irgendwo in einem Control oder statuswort war irgendwas doch mal anders. Da war Vererbung oder Methoden überschreiben klasse. Da hat man wirklich nur den spizifischen teil angepasst und Basta. Man hat dann halt auch sofort gesehen wo der Unterschied ist ohne viel Copy Paste Arbeit wie herkömmliche Programmierung. gerade Motorcontroller da kommt es dann halt auch sehr drauf an was für Technologien verwendet werden. Profinet und Ethercat da ist es eh sehr von den Hersteller abhängig was der anbietet. Auch soetwas wie generische Listen usw wo man viel Daten händelt hat oop Methoden und actions und properties auch große Vorteile.Naja, vielleicht zeigt hier mal jemand einfach den Code von nem OOP-Motorbaustein...i
We use cookies and similar technologies for the following purposes:
Do you accept cookies and these technologies?
We use cookies and similar technologies for the following purposes:
Do you accept cookies and these technologies?