Robert Puskas

Eine kleine Rezension über - C# 10 in a Nutshell

Tue, 16 Aug 2022 20:50:28 +0200

C# 10 in a Nutshell by Joseph Albahari

My rating: 5 of 5 stars

Liebe Leser, liebe Leserinnen,

ich bin glücklich eine weitere Rezension zu verkünden. Diesmal ist es über ein Buch, das mein erster Einblick in die C# Programmierungssprache ist. Viel Spaß!

I picked up this book because I wanted a to read something on C# that is somewhat similar to what “Programming: Principles and Practice Using C++” by B. Stroustrup is to C++, and I must say, I wasn’t disappointed. Let’s see why.

First of all, as any book on any programming language should do, it starts with the basics, like syntax, built-in features and types, followed by a deep explanation of how to create user-defined types. After that we can read about advanced language features, like delegates, lambdas, extension methods, operator overloading, etc. in a separate chapter. So far, so good.

At this point we already know the most important things about the language itself, and the author moves on to discuss many other topics, like LINQ, Streams, Networking, Concurrency, etc. all of which are less comprehensive than the first few chapters. This is understandable though, as it is impossible to discuss any of the aforementioned topics in detail in a single book, as they are simply too large for that. The presented level of detail seems to be enough though to provide a usable reference for day-to-day development, especially when one just quickly needs to find a particular feature or a clue, which could help to solve the current problem. If the level of detail is not enough, the comprehensive official online documentation is still available.

So what does the book lack, one might wonder? For one, it is the exercises. A lot of programming books out there provide a set of exercises at the end of each chapter, but there are none in this book. To me personally it is not a great loss, as I always found that simple exercises presented in such books are by far less effective at helping to learn the language than some work on an actual hobby project, so I don’t mind. The author may have had the same opinion, as instead of exercises there is a large amount of sample code covering almost every topic and feature discussed.

All in all, I think that this book is excellent at what it sets out to do: introduce the reader to C# and .NET. The topics are well chosen, each chapter has a well balanced content, the explanations are clear and there is enough sample code to support them. After reaching the end of the book, the reader will have all the background information required to be able to start courses/get coached on developing actual projects. Moreover it can serve to a more experienced developer as a quick reference as well.

View all my reviews

Codebasierte UML Diagramme - Eine schnelle und einfache Weise zur Erstellung von Diagrammen

Sat, 23 Jul 2022 20:50:28 +0200

Liebe Leserinnen, liebe Leser,

In diesem Beitrag möchte ich einige meiner Gedanken über eine jüngste Entdeckung im Bereich Diagramm- und Modellerstellung teilen, also lasst uns sofort starten. Für Leute, die sich mit (Software oder andere Art von) Projektierung beschäftigen, ist der Bedarf an der Erstellung von Diagrammen wahrscheinlich aufgekommen, um wichtige Informationen über den Systemaufbau, Funktionsweise, usw. übergeben zu können. Ganz viele Werkzeuge stehen für diesen Zweck zu Verfügung, und die Kategorie, die meine Aufmerksamkeit wirlich erregt, war das “Code based tools”.

Als es sich herausstellte, es gibt mehrere Werkzeuge, die ducrch das Tippen von Code die Erstellung von UML, C4, Gantt, Git, Netzwerk und andere Art von Diagrammen ermöglichen. Warum ist das gut? Es gibt mehrere Gründe, wie:

Diagramme können genauso wie Code gehandhabt werden
Diagrammlayout braucht keine Sorge, da Diagramme automatisch erzeugt werden
Diagramme (und die Fähigkeiten für die Erstellung) sind sehr übertragbar, da Code nicht auf ein einziges Werkzeug begrenzt ist
Man kann sich völlig auf die Erstellung von Diagrammen konzentrieren, ohne mit dem Werkzeug zu Kämpfen
Das Datenformat verfügt über eine sehr hohe Konzentration von wichtigen Informationen, aber trotzdem ist es sowohl Machinenenlesbar als auch Menschenlesbar
Einfache Skriptfähigkeiten (Schleifen, if-Anweisungen) stehen zur Verfügung, um die Erstellung von Diagramme zu beschleunigen

Da man aus mehrere Sprachen und Tools wählen kann, muss man sich basierend auf einige Eingenschaften entscheiden, welches Tool am besten ist: Einige Werkzeuge unterstützen nur Diagrammerstellung, andere unterstützen auch Modellierung; Einige Werkzeuge sind kostenlos, andere brauchen Abos; Einige Werkzeuge können lokal ausgeführt werden, andere sind Online-Tools, usw. Da ich diese Art von Diagrammerstellung nur ausprobieren wollte, habe ich mich für PlantUML zusammen mit VS Code und eine zugehörige Erweiterung entschieden, da es Livepreviews und einfacher Diagrammexport unterstützt.

Wie bei allen anderen Werkzeugen gibt es natürlich Nachteile. Einer dieser Nachteile ist, dass nicht alle UML Diagramtypen unterstützt sind, obwohl das nicht immer ein echtes Problem ist, weil man die gänglichen Diagramme erstellen kann. Ein Vorteil von codebasierten Diagrammen kann auch ein nachteil sein (nämlich die Autoerzeugung), da die Objekte nicht von Hand organisiert werden können (obwohl Syntax für die Änderung der automatisch erzeugten Positionen existiert, bietet es nur eine sehr beschränkte Positionskontrolle). Das ist kein Problem bei einfachen Diagrammen, aber bei komplizierteren Diagrammen könnte es sein.

Außer dieser Sachen habe ich bisher codebasierte Diagrammerstellung als ganz produktiv festgestellt, da ich mich wirklich auf den echten Inhalt konzentrieren kann, ohne mit dem graphischen Werkzeug kämpfen zu müssen. Ob diese Art von Diagrammerstellung langfristig gut genug bleibt, wird das sich finden.

Wie immer, vielen Dank fürs Lesen.

Ein Projekt - Automatisierung einer virtuellen Produktionsanlage

Sun, 05 Jun 2022 10:50:28 +0200

Liebe Leserinnen, liebe Leser,

ich bin glücklich bekannt zu geben, dass das Hobby-/Demoprojekt, an dem ich in diesen letzten vielen Monaten gearbeitet habe, letztendlich fertig ist. Das war schwere Arbeit, aber es lohnte den Aufwand, da ich während der Arbeit sehr viele neue Sachen erlernt habe. Da die Erstellung des Projekts viel mehr Aufwand als die andere Sachen, die ich auf meiner Webseite bisher presentiert habe, brauchte, habe ich mich entschieden, eine ganz neue Seite dafür zu machen. Auf die Seite kann unter ‘Projekts’ im Hauptmenu zugegriffen werden. Die Seite beinhaltet die Beschreibung des Projekts, also ich werde hier nichts wiederholen, stattdessen ist die vorgenannte Seite für mehr Informationen zu besuchen.

Mal wieder, vielen Dank fürs Lesen.

Eine kleine Rezension über - Software Architecture Patterns

Sun, 30 Jan 2022 19:50:28 +0100

Software Architecture Patterns by Mark Richards

My rating: 5 of 5 stars

Liebe Leserinnen, liebe Leser,

dieses Mal stelle ich eine kurze Rezension eines kurzen Buches dar. Das geht über ein sehr wichtiges Thema, nämlich Softwarearchitektur. Vielen Dank fürs Lesen.

I picked this book up because it was offered as a free download by O’Reilly as I was visiting their webpage and since it’s not long at all (not even 50 pages), I thought it would be a nice quick read for a weekend evening. Let’s see what it has in store.

The book starts out with a short single page introduction on software architecture, where the author basically discusses the importance of such concepts, then switches immediately to present 5 commonly used software architectures. Each architecture has its own dedicated chapter, where with the help of a few simple figures, the author describes them in a short and easy to understand manner, then continues with some recommendations and topics of considerations for choosing or discarding them. Each pattern is finally analyzed from several points of view, like agility, performance, testability, etc. and are given scores for easy comparison.

Generally there isn’t much to say about the book, as it is very targeted and very short, so above from the most necessary thoughts there isn’t much else. The topics are well chosen and the discussions are well executed. But I was hard pushed to say something anyway, I’d say that I liked the fact that non of the patterns is treated as the being better than the other, but instead each is given fair credit. If I had to complain about something than it would be the amount and scope of examples (small and limited), but it is hardly a complain as the book is hardly long enough to include a lot of examples. So all in all, I would recommend this to everyone interested in software craftsmanship, as it costs literally nothing, and it requires almost no time at all to read from cover to cover.

View all my reviews

Eine kleine Rezension über - Catching the Process Fieldbus: An Introduction to Profibus and Profinet

Tue, 28 Dec 2021 19:50:28 +0100

Catching the Process Fieldbus: An Introduction to Profibus and Profinet for Process Automation by James Powell

My rating: 4 of 5 stars

Liebe Leserinnen, liebe Leser,

da das Ende des Jahres kommt, ist es eine gute Zeit etwas nicht zu Kompliziertes, das innerhalb der professionellen Interesse liegt, zu lesen. Für mich war das ein nicht zu langes Buch über Profibus und Profinet, nämlich Catching the Process Fieldbus von James Powell. Lasst uns sehen wie war das:

I chose this book because I wanted to read something about Profibus and Profinet from a process automation perspective. As any technical book, it starts with discussing the basics, mainly what these fieldbuses are, how they operate, what are the differences between the three of them (DP, PA and Net) and so on. The scope of these discussions are enough to gain a fair understanding of these technologies, but don’t expect any in-depth explanations, for which there seems to be a good reason (see a bit later).

After having the basics dealt with, the author moves on to day-to-day engineering type of topics, like installation, commissioning, maintenance, troubleshooting or even designing an actual Profi-based fieldbus for an industrial application. Such a choice of topics is really welcome, as now the reader basically has a nicely compiled list of things to do and look out for, when working on projects involving these fieldbus technologies. Moreover, the author also included some real-world examples to demonstrate how some of the aforementioned activities are actually done and with what tools (both software and hardware).

It is also worth mentioning, that this book leans towards process automation quite heavily, so topics generally involving manufacturing, like application of RT or IRT capabilities, Profidrive, Profienergy, etc. is pretty much omitted, though the author stated as much right at the beginning.

All in all, the just-enough technical explanations and a heavy emphasis on daily engineering related topics makes this book an excellent choice for people who just need a quick guide to start working on Profi-based problems and projects in the process automation field, though the reader shouldn’t expect to gain a deep understanding of any of these technologies. For that, other resources will need to be used, just as the author recommends at the very end of the book.

View all my reviews

Absolvierung des Kurses - KUKA (KRC4) industrial robot operator and programmer training - advanced programming level

Fri, 17 Sep 2021 20:50:28 +0200

Liebe Leserinnen, liebe Leser,

ich bin glücklich bekannt zu geben, dass ich einen Präsenzkurs für KUKA Industrieroboterarme absolviert habe, der in einem staatlich anerkannten Zertifikat resultiert hat. Der Kurs wurde von professionellen Roboterprogrammierern an einem Firmenstandort gemacht, was bedeutet, dass wir (die Studenten) nicht nur einen umfangreichen theoretischen Hintergrund bekommen haben, sondern auch hatten wir ausreichend genung Gelegenheit, unsere Kentnisse mit einem echten Roboterarm auszuprobieren. Jeder Tag bestand aus zwei Teilen: ein theoretischer Teil, und ein Praxisteil. Der theoretische Teil bestand sowohl aus der Übergabe von neuen Kenntnissen, als auch aus Testfragen, wohingegen während der Praxisteil alle früher gelernte Sachen geübt wurden. Eine derartige Kurstrukturierung gefällt mir sehr viel, besonders wenn man bedenkt, dass jeder Stundent genung Zeit hatte, alle Lernübungen mit einem echten Roboterarm durchzuführen.

A KUKA robotic arm placing a test object onto a conveyor driven cart

Das Bild oben stellt eine der oben erwähnten Lernübungen dar. Wir mussten ein Steuerungsprogramm für den Roboterarm und das Förderbandsystem schreiben, um Werkstücke aus/in einer/e Lagerkiste auf/aus eine/r Karre in Abhängigkeit von dem Füllstand platzieren zu können. Es war wirklich erstaunlich zu sehen, wie schnell und gleichzeitig wie präzis der Roboterarm arbeitet! Zum Beispiel könnte der Arm die Karre nur in ein paar Sekunden entleeren oder füllen (wenn auch die Kiste jenseits des Roboterarms war), falls die maximale Geschwindigeit angewandt würde (im Lehr/Testumgebungen die Nutzung der maximalen Geschwindigeit ist nicht erlaubt). Das war sogar bei einer zu 30% reduzierten Geschwindigeit sehr schnell.

Weiterhin gab es viele interesstante (und vielleicht erstaunliche) Sachen, die ich über Roboterarmprogrammierung gelernt habe. Eine solche Sache war, dass der kürzeste (gerade) Pfad zwischen zwei Punkte nicht erforderlich der schnellste Pfad in der Roboterwelt ist. In vielen Fällen kann das Roboterwerkzeug einen gebeugten Pfad viel schneller als einen präzisen geraden Pfad durchlaufen, das ein Resultat der Zusammenarbeit der Achsen ist.

Aber endet der Strom der interessanten Sachen hier nicht. Zum Beispiel, der Robotercontroller kann gleichzeitig zwei Programme ausführen. Das erste ist für den Arm, und das zweite ist für andere Zwecke, wie die Steuerung von externen Geräten. Wir hatten die Gelegenheit, dieses Merkmal ein bisschen zu entdecken, und für mich kam die interessanteste Erfahrung (aus dem Gesichtspunkt Programmierung) genau aus dieses Merkmal: Ich habe es herausgefunden, wie schwierig es ist, ein nebenläufiges Programm nur mit Grundfunktionen einer Sprache zu schreiben.

In der obenerwähnten Förderbandübung hat das Robotersteuerprogramm und das Förderbandsteuerprogramm in zwei abgesonderten Ausführungssträngen ausgeführt. Um es ein bisschen komplizierter zu machen, haben die zwei Ausführungsstränge unterschiedliche Zykluszeiten. Das bedeutet, dass wir eine sichere Weise für die Datenübergabe zwischen diesen zwei Ausführungssträngen finden mussten, um die beabsichtigte Zusammenarbeit des Arms und Förderbandsystems zu erreichen. Das ist ganz schwierig, wenn Grundsynchronisationsmerkmale, wie Mutexe, zur Verfügung nicht stehen. Als eine Randbemebrkung möchte ich es sagen, dass diese Erfahrung meine schon große Anerkennung der Arbeit von A. Williams an C++ Nebenläufigkeit weiter erhöht hat. Falls Sie schnell herausfinden wollen, was C++ im Bereich Nebenläufigkeit bieten hat, lesen Sie bitte meine zwei Zusammenfassungen darüber hier und hier.

Natürlich wird das Fehlen von Synchronisationsmerkmalen Programmierung schwieriger als nötig machen, aber, als ich es gelernt habe, die Welt scheint derartige Schwierigkeiten durch die Nutzung von anderen Werkzeuge zu beseitigen, um solche Steuergsysteme bauen zu können. Das auf dem Robotercontroller ausgeführte Steuerungsprogramm wird am meistens möglichst einfach gehalten. Das bedeutet, dass der Roboterarm nur die Funktion eines weiteren hochentwickelten Aktors übernimmt, der, genauso wie eine frequenzumrichterangetriebene Maschine, von einer SPS gesteuert wird. Das ist so wahr, dass auch Fehlerbehandlung scheint von der SPS komplett erledigt zu sein, da im Falle eines Fehlers das Roboterprogramm nur ein Fehlersignal sendet (und vermutlich wird das den Arm auch stoppen), und wird danach die SPS sich entscheiden, was weiter zu tun ist.

Es gab auch einige komische Sachen, wie z.B wie unterschiedlich die Entwicklungswerkzeuge in der Industrie sein können. Beispielweise ist die Entwicklungsumgebung des KUKA-Programmierhandgeräts überhaupt einfach: das unterstüzt weder Syntaxfehlerhervorhebung noch Codeeinrückung. Wenn man solche gängliche Merkmale haben will, muss man ein Desktop-Entwicklungsumgebung von KUKA (die kostenlos zur Verfügung steht) benutzen. Es war auch ganz erstaunlich für mich, dass dieses Werkzeug die Werte von Variablen zur Laufzeit nicht zeigen kann. Stattdessen muss man durch Menüs gehen, um ein weiteres Fenster zu eröffnen, mit dem man das Wert eines Variables herauslesen kann. Ich bin darüber nicht sicher, warum solche einfache Merkmale von dem Programmierhandgerät nicht unterstüzt sind, aber ich vermute, dass dieses Gerät nur für Endprüfungen und kleine Änderungen vorgesehen ist. Oder vielleicht nicht, ich weiß es nicht.

Es gab auch viele andere interessante Sachen, die ich gelernt habe, wie die physicalische Limitationen der Arme, verschieden Armwerkzeuge, industrielle Trends, usw, aber dieser Beitrag ist schon zu lang, also ich werde das jetzt zum Abschluss bringen. Alles in allem, ich war mit diesem Kurs sehr zufrieden, und meiner Meinung nach war die Zeit damit sehr gut verbracht.

Wie immer, vielen Dank fürs Lesen.

Eine Kurzübersicht von - der modellbasierten Systems-Engineering Methode Arcadia

Fri, 23 Apr 2021 20:50:28 +0200

Liebe Leserinnen, liebe Leser,

Ich bin glücklich zu verkünden, dass ich das Schreiben einer Übersicht/Zusammenfassung der Arcadia modellbasiertes Systems-Engineering Methode, die ich auf meiner Github-Seite veröffentlicht habe, zu Ende gemacht habe. Dies war hart zu erledigen, besonders wenn man die interessante Struktuierung des Buches in Betracht zieht (siehe meine Rezension), aber es lohnte sich, mit dieses Thema Zeit zu verbringen.

Also, warum sollte man beträchtliche Zeit in das Schreiben dieser Zusammenfassung investieren? Einfach gesagt, weil modellbasiertes Systems-Engineering (MBSE) heutzutage schwer zu vermeiden ist. Da ein stetiger Übergang von dem klassischen dokumentbasierten Systems-Engineering (DBSE) zum MBSE stattfindet, ist das Lernen der Methode gut angelegte Zeit. Um es deutlicher zu machen, warum dieser Übergang unterwegs ist, werden beide Ansätze in Kürze unter die Lupe gestellt.

DBSE bewältigt das Problem des Systementwurfs durch die Erstellung eine Reihe von Dokumenten, während eine gut definierte Methode, wie das V-Modell, im Auge behalten wird. Einerseits stellt die linke Seite der “V” die Dekomposition der Anforderungen und die Erstellung von Systemspezifikationen dar, andererseits die rechte Seite die Integration und Validierung. Die linke Seite produziert eine Reihe von Dokumenten, wobei jede stimmt mit einer der Abstraktionsebenen des V überein. Eine Beispielreihe von Dokumenten könnte das Folgende sein:
Projektantrag –> funktionaltechnische Spezifikation –> architekturtechnische Spezifikation –> komponententechnische Spezifikation
Das Endprodukt ist eine große Reihe von Dokumenten, die miteinander etwas verbunden sind.

Hier gibt’s ein paar Einschränkungen dieses Ansatzes:

Um Kohärenz und Konsistenz unter allen Dokumenten zu halten, braucht man im Laufe des Projekts in ein erheblich hoches Ausmaß an Arbeit für das Schreiben, die Prüfung und Aktualisierung der verschiedenen Dokumenten zu investieren.
Anforderungen werden mithilfe der natürlichen Sprache und Abbildungen erfasst, aber es ist aufwändig, die Konsistenz darunter zu halten. Überspezifikation ist eine echte Gefahr.
Wegen der fehlenden gut definierten und durchzusetzenden Verbindungen ist es sehr schwierig, eine Rückverfolgbarkeit unter den Entwurfelementen der Tief- und Hochebenen zu schaffen.
Die Kommunikation der Ideen ist aufwändiger, da die Informationen unter vielen Dokumenten ausgebreitet sind.
Eine große Reihe von Werkzeugen ist notwenig, um die Dokumenten zu erstellen: Analysewerkzeug, Diagrammwerkzeug, Veröffentlichungswerkzeug, Dokumentenmanager, usw.

Andererseits, MBSE konzentriert sich auf die Erstellung von Dokumenten nicht (sie sind nur Nebenprodukte), stattdessen verfolgt das das Ziel, eine Reihe von Elementen, die eine Anforderung, einen Bedarf, ein Verhalten, eine Aktion, einen Aktor oder etwas Anderes in Bezug auf das System representiert, zu erstellen. Diese Elemente werden in einem Datenbank gespeichert, und gut definierte Beziehungen werden für alle Elemente binnen und unter den verschiedenen Engineeringebenen auch erstellt. Dies garantiert nicht nur die uniforme Darstellung der Konzepte, sondern auch ermöglicht das eine uniforme Visualisierung durch standardisierte Diagramme. Die Verwendung solches Ansatzes garantiert Konsistenz und Rückverfolgbarkeit unter allen Ebenen, und das ermöglicht eine einfachere Kommunikation unter allen betroffenen Beteiligten auch.

Natürlich braucht man eine Modellierungssprache und Methode, um ein Modell bauen zu können. Glücklicherweise stehen einige Möglichkeiten zur Verfügung:

Als Sprache gibt es:
- EAST-ADL
- AADL
- SysML
- NATO Architecture Framework viewpoints
- Capella
- Und vielleicht mehr
Als Methode kann man die Folgenden auswählen:
- Harmony-SE
- INCOSE Object-Oriented SE (OOSEM)
- IBM Rational Unified Process SE (RUP SE)
- Vitech SE
- JPL State Analysis (SA)
- NATO Architecture Framework Methodology (NAF)
- Dori Object-Process Methodology (OPM)
- Arcadia
- Und vielleicht mehr

Über eine gute Übersicht der meisten obengenannten Methoden (ausschließlich Arcadia und NAF) kann man in einer JPL-Publikation lesen. Eine weitere gute Quelle ist eine relativ aktuelle Dissertation, die OOSEM/SysML mit Arcadia/Capella vergleicht. Letztendlich kann man über NAF in der offiziellen NATO-Publikation mehr herausfinden.

Es ist schon ganz klar, dass ziemlich viele Möglichkeiten vorhanden ist, und die Auswahl ist nicht einfach. Lange Rede kurzer Sinn, ich habe Arcadia/Capella basierend auf den folgenden Gründen ausgewählt:

Die Methode, Sprache und das zugehörige Entwicklungswerkzeug wurden

unter Betrachtung von Zusammenarbeit
basierend auf den Erkenntnissen, die bei der Nutzung der anderen Methoden gewonnen wurden,
mittels Ideen aus etlichen anderen Sprachen (NAF, SysML, AADL)
als etwas Einfacheres für Ingeniuere (schneller On-Boarding)
als etwas Allgemeineres und nicht Bereichspezifiziertes
unter Betrachtung von dem “Leerpapier-Syndrom”
schrittweise, im Laufe mehreren Jahren (8), basiernd auf den Rückmeldungen der Ingeniuere, die an verschiedenen Projekten aus verschiedenen Bereichen arbeiten,
von einem großen Unternehmen (Thales), das sachliche Systmes-Engineering (Luftfahrt, Transport, Verteidigung, Sicherheit) macht,

entwickelt.

An dieser Stelle weiß ich natürlich nicht, ob sich Arcadia als das erwartete Werkzeug herausstellen wird, aber die obengenannten Argumenten scheinen für eine ernste Ausprobierung ziemlich solide zu sein, besonders wenn man bedenkt, dass ich die Zeitmenge, die die Tales-Leute für die Prüfung der anderen Sprachen/Methoden hatten, nicht habe. Einfach gesagt verlasse ich mich jetzt auf ihre Erfahrung und Beurteilung (und ihren Bedarf für die Entwicklung einer eigenen Methode trotz der zahlreichen anderen vorhandenen Methoden).

Mal wieder, vielen Dank fürs Lesen.

Eine kleine Rezension von - Model Based System and Architecture Engineering with Arcadia

Mon, 19 Apr 2021 20:50:28 +0200

Model-Based System and Architecture Engineering with the Arcadia Method by Jean-Luc Voirin

My rating: 3 of 5 stars

Liebe Leserinnen, liebe Leser,

dies ist ein weiterer Beitrag mit einer weiteren Rezension. Dieses Mal könnte das Thema ein bisschen ungewöhnich scheinen, aber das liegt mit den bisherigen Sachen auf der gleichen Linie, da Modellbasiertes Systems-Engineering ein großartiges Werkzeug ist, Lösungen auf eine struktuierte und standardizierte Weise von Grund auf zu entwickeln. Lasst uns sehen, wie schnitt das Buch ab. Viel Spaß beim Lesen.

This book is meant to introduce the reader to the Arcadia MBSE method and the accompanying Capella modeling language, which is not an easy task to do, considering that engineering methods are rather complex topics. There are probably several ways to do it, so let’s see which approach the author chose to tackle the problem.

The book is broken up into three main chapters: fundamentals, application of the method and a glossary. The first part starts out with a usual introduction, where the author describes the motivations behind creating this new method, and then continues with a brief history about how the method came to life. Next, the main parts (perspectives) of the model are described briefly, to give the reader some idea what is about to be discussed in length. Finally, the rest of the first part is taken up by a systematic and detailed description of how each perspective of the model is developed.

What immediately stands out, is that almost the entirety of this part is written in prose, which makes it quite hard to follow what tasks and in what order need to be done to develop the perspectives. To further complicate things, the author chose not to explain all concepts the first time they appear, instead the majority of such explanation is found in the last chapter. The explanations that do appear in place, are completely hidden in the wall of text. Highlighting such concepts and their explanations in a box would’ve helped immensely.

I also couldn’t help but notice that there is a serious lack of explanatory figures in this chapter. I’m not talking about the example project (and associated diagrams) that is being constructed as the book progresses, but figures that would help to understand the method structure (of building the perspective) itself. As it turned out, such figures do exist in the book, but for some reason they are also presented in the very last chapter only. Moreover, having a before-after pair of example model diagrams would’ve been extremely beneficial as well, as right now it is completely up to the reader to figure out which model diagram (and associated model elements) evolved into which ones up in the model hierarchy. This unfortunately also requires a large amount of back-and-forth seeking in the book.

The second main chapter is about applying a model in viewpoint analysis, IVV planning and execution, designing system supervision, states and modes and more. This chapter follows a similar structuring and implementation as the previous one with the same associated problems, so there is no need to repeat them. The Third part of the book is pretty much a glossary of terms, concepts and modeling language elements listed one after another, which is pretty easy to follow and understand. In this part of the book the author presented a lot more explanatory figures than before, which the reader will really appreciate after the first two main chapters.

The overall structuring of the book follows a rather interesting approach. As mentioned before, a lot of first time concept definitions are ported to the back of the book, which indeed makes it easier to look them up, but in turn it makes it harder to comprehend the book as a first time reader (due to the missing in-place explanations). This structure of course can work if the reader is fully aware of it right from the beginning, but expecting this from the first time reader is not necessarily a good strategy.

The overall impression is that even though the book contains pretty much everything needed to master Arcadia (or at least to acquire a solid understanding to start out with it), using this book as a reference in a day-to-day work seems to be very hard, due to it being almost entirely written in prose with very little highlighting and summary of important concepts. As such, learning the method poses quite a challenge without creating a separate bullet-pointed list of tasks/concepts as the book is read. Because of aforementioned reasons I can only give it 3 stars.

View all my reviews

Eine kleine Rezension über - Taschenbuch der Automatisierung

Mon, 05 Apr 2021 20:50:28 +0200

Taschenbuch der Automatisierung by Reinhard Langmann

My rating: 5 of 5 stars

Liebe Leserinnen, liebe Leser,

wie gewöhnlich kommt jetzt eine weitere Rezension, dieses Mal über Automatisierung. Da das Buch ganz lang ist, verdient das eine Rezension mit egaler Proportion. Viel Spaß.

I picked this book up, because I wanted to read a comprehensive German language book on automation, which could also serve as a quick reference in case something needed to be looked up. Let’s see how well it did.

What immediately stands about this book out after opening it up, is the shear amount of topics it includes. The table of contents in itself is almost ten pages long, and after reading the book, I can say that it could’ve been even longer. The other thing one notices is the large amount of figures, tables, lists and highlights. Barely any page goes by without at least one of those, which I really like, because they make it easier to understand the current topic, and they can serve as anchor points for the reader as well. But what are those topics exactly? Let’s examine them a bit closer.

As any book, it starts out with a short introduction, but then immediately dives into the real discussion, beginning with the discussion of the basic terms, notation methods, diagrams, types of automated systems, plant structures and components, etc, so basically with everything the reader needs to be on the level before moving on to the next chapters. After the reader has been familiarized with these essentials, the rest of the book discusses in detail what components and techniques can be used to achieve automation.

The first and most important component is probably the computational device that drives the system, so a complete chapter is dedicated to the basics of computing, like data representation, processor structure, multitasking, memory management, types of controllers, IO, etc. Of course this is not a book on computers, so it never goes into great depths, but the amount of information is still quite enough to have a firm understanding of how industrial controllers really work.

The book then moves on to discuss the most common automation components (divided up into subsections for sensors, actuators and controllers), where the reader will find information on anything from the physical effects used for signal generation in sensors to the basic types of sensor technologies for a great many physical properties. The part about actuators is pretty similar in this regard (discussing driving force, characteristics, types, etc.), so the read will have a good grasp on those as well. A quick overview of the different types of available control devices comes next, where PLCs, soft PLCs and PACs are introduced. It’s still not everything, as open-loop, and especially closed-loop controls deserved a lengthy discussion as well, where topics include switching, adaptive, PID control, control stability and parameters, some mathematical background about these and so on.

After having learned what devices can be used to automate processes, the authors drive the reader’s attention to modeling, which is especially important during the design and implementation phase of a project. The readers get acquainted with the basics of model building and usage, process analysis, program models and paradigms (state machines, UML, IEC language blocks etc.), and the different types of diagrams (finite state machine diagram, grafcet diagram, automaton table, etc.) that help communicate and test the aforementioned concepts. The authors then continue with general software concepts, including what programs, operating systems, programming languages are available and, but programming paradigms (OOP, component based) relevant to automation are not left out either.

As communication is an important part of automation, a full chapter is dedicated to it as well. The selection and order of topics pretty much follows any other piece on networking: it starts with the OSI and TCP/IP models, followed by the physical layer and network topologies, Ethernet, standard protocols, interfaces, etc., then it finishes with an introduction to industrial communication standards. There really isn’t much to say about this chapter, it is pretty standard.

Of course it would be hard to control and set automate systems up without human-machine interfaces, so this is what the reader gets next. Here, one can read about the various forms of inputs, basics of windowing systems, process visualization, virtual reality etc. The chapter is not long enough to dive deep into any of these topics, so it is more of a quick overview.

The next and probably longest part of the book is about software applications in automation. It basically expands on the topics mentioned in of the previous chapters, so now the reader gets some really good insight how various industrial control applications are built up. This chapter in itself is divided up into major parts as well, where process control, motion control, NC, robots, etc. are presented. Each major part introduces the basics and moves on to showing how these various control problems can be solved by introducing different approaches, technologies and paradigms. Of course, if each of these subsections are examined, these different parts follow the same proportions as all previous chapters in the book, so despite this chapter being quite large, it is not overwhelming.

The book finally ends with project management, including the various design phases, quality control, availability, security, protection, etc.

It is quite evident from everything mentioned above, that this book touches an incredibly large amount of topics, which turns it into a really good reference book. There is hardly any topic related to automation that the reader cannot find in it, which also means that there simply was no way to have deep discussions. Because of it, all chapters are basically very highly detailed overviews, which isn’t a problem, as this is exactly what the authors set out to achieve with this piece. And they did an excellent work at that. If I would need to mention some downside, then it would be the somewhat dated content here and there (even though this edition is from 2017), but it is by far not blatant. I also really like the collection of the most essential standards and guidelines attached as an appendix, as it makes really easy to quickly take a deeper dive in any of the topics.

All in all, this book achieves everything it sets out to achieve, and is highly recommended to anyone working in the field of automation or just learning about it.

View all my reviews

Eine kleine Rezension über - Grafcet Step-by-Step

Sun, 28 Mar 2021 20:50:28 +0200

Grafcet Step-by-Step by Paul Baracos

My rating: 4 of 5 stars

Liebe Leserinnen, liebe Leser,

ein weiterer Beitrag, eine weitere Rezension. Dieser ist jedoch ein bisschen unerwartet, da ich dieses Buch nur dank eines Zufalls gefunden habe. Anfangs habe ich das verlegt, da Grafcet ganz selbsterklärend ist und die vorhandene Online-Dokumentation derüber ganz gut ist, aber ich habe an diesem Wochende dem Buch eine Chance gegeben, um ein bisschen Abwechslung bei meinen gewöhnlichen Lektüren zu haben. Viel Spaß.

I found this book recently by chance, so I decided to read it in order to check if I have a good enough understanding of Grafcet. Grafcet is of great importance in automation, as it is a simplified version of Petri nets, which allows one to model finite state machines with parallel and simultaneous control requirements, something the older state transition diagrams are not capable of. Since Grafcet can be learnt and understood in very little time, reading a book on it might seem superfluous (Grafcet tools have pretty good documentation on the language) but having a book that could serve as a reference material seemed to be a good idea, so I gave it a try.

As many other technical books, it starts out with the essential basic concepts, then takes a rather interesting approach to introduce the reader to the language: it starts to automate an imaginary drilling station. The first example is the most basic one could come up with, then with each example the author adds a few more requirements that need to be satisfied. Of course, this will also require the addition of additional language features, so the reader is gradually introduced to the most important features of the language in a very organic fashion. By the end of this section the reader is ready to create her own Grafcet diagrams.

The book doesn’t stop here though, as it moves on to a more formal description of all the features. This is the part that could serve as a reference for later. The only problem I found is, that it seem to be a bit outdated, as it doesn’t include some of the newer notation elements like, enclosing step, initial enclosing step, conditional action, stored action, etc. To avoid confusion, these concepts are actually mentioned in the book, but it would seem, that at the time of writing (1992) they didn’t have separate notation elements for them.

What I really liked is, that the author doesn’t only included a reference style listing of notation elements, but quite some basic structures and simple control examples as well, which cover a lot of things from basic data initialization to sequence synchronization. Moreover, these examples are also supplemented by timing diagrams to help the reader understand how they would actually execute. The book then ends with a short case study on how Grafcet was introduced to the parent company of the publisher to show that it really is a very usable tool even for mission critical systems.

All in all, I really liked almost everything about the book, there are large amounts of figures, the explanations are easy to understand, the book is well structured, and in general it is a quick and pleasant read. The one thing I’m a bit disappointed about is, that the book wasn’t updated by newer notation elements, even though it wouldn’t take too much effort to do (hence the four stars). Despite that, I would definitely recommend it as an introductory piece on Grafcet, as the missing notation elements can be acquired from other sources easily.

View all my reviews