Merge pull request #6 from jsonBackup/fix/misspelling

Fix Misspellings

Author: jsonBackup

README.md

@@ -5,7 +5,7 @@ through the typical process of an application developer and learn about MORYX
 concepts and terminology on the way.
 
 You will accompany a pencil manufacturer on its road to the digital factory. 
-Despite using some specialised machines, they don't have any automatted 
+Despite using some specialized machines, they don't have any automated 
 processes right now.
 
 
@@ -19,7 +19,7 @@ Programming**, all of that is **not mandatory** to master this.
 
 ## Prerequisite
 
-Below is a list of patterns and basic concepts that MORYX is build upon, but you
+Below is a list of patterns and basic concepts that MORYX is built upon, but you
 don't need to know right upfront. 
 
 ### General/OOP
@@ -46,7 +46,7 @@ This is a list of more or less 'advanced' topics
 
 ## Requirements
 
-Before to start, you need the following tools installed on you machine:
+Before you start, you need the following tools installed on your machine:
 
 * [ ] [Git](https://git-scm.com/)
 * [ ] [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) (Any version below wouldn't work, but you can install them in parallel)
@@ -80,12 +80,12 @@ MORYX Terminology and Concepts you will learn
 
 ## [Chapter 2 - Drivers](chapter-2-drivers.md)
 
-Since so many pencils were sold, the manufacturer decided that only manual cells aren't feasible anymore. So some manual cells are replaced by full automated ones. 
+Since so many pencils were sold, the manufacturer decided that only manual cells aren't feasible anymore. So some manual cells are replaced by fully automated ones. 
 
 In this chapter you will learn how to
 * Communicate with hardware 
 * Use different hardware, without having to adjust the source code
-* Setup a simulated production
+* Set up a simulated production
 
 Terminology and Concepts you will learn
   * Drivers
@@ -94,9 +94,9 @@ Terminology and Concepts you will learn
 
 
 ## [Chapter 3 - Basics II](chapter-3-basics-II.md)
-The manufacturer decided to have a seperate Colorizing Cell for each color in order not to have to change the paint anymore.
+The manufacturer decided to have a separate Colorizing Cell for each color in order not to have to change the paint anymore.
 
-In this chapter you will lean how to
+In this chapter you will learn how to
 
 * Find the right Cell depending on a product property
 

chapter-0-requirements.md

@@ -5,5 +5,5 @@
 * [ ] [CodeMeter User Runtime (Version 8.x)](https://www.wibu.com/de/support/anwendersoftware/anwendersoftware.html)
 
 ## Get all your licenses running
-The application developer program uses developer licenses. The licenses end on WibuCmRaU. You need the CodeMeter Control Center, where you can add those files via drag and drop. This can be downloaded from the Wibu website directly.
-For a scenario in which you want to use production licenses you may consider installing the PHOENIX CONTACT Activation Wizard available on the [PHOENIX CONTACT page](https://www.phoenixcontact.com/de-de/produkte/programmier-software-plcnext-engineer-1046008) under Downloads -> Software.
+The application developer program uses developer licenses. The licenses end with WibuCmRaU. You need the CodeMeter Control Center, where you can add those files via drag and drop. This can be downloaded from the Wibu website directly.
+For a scenario in which you want to use production licenses, you may consider installing the PHOENIX CONTACT Activation Wizard available on the [PHOENIX CONTACT page](https://www.phoenixcontact.com/de-de/produkte/programmier-software-plcnext-engineer-1046008) under Downloads -> Software.

chapter-1-basics.md

@@ -3,11 +3,11 @@ In this chapter you will learn the basics of MORYX and how it helps you to set u
 
 ## Use Case
 
-Your costumer *Pencilla Inc.* produces pencils. The production needs prepared 
+Your customer *Pencilla Inc.* produces pencils. The production needs prepared 
 material - wooden slats and graphite - and consists of the following four steps:​
 
 * Assembling: Glue slats and graphite together​ and shape it.
-* Colorizing : Add paint and imprint text
+* Colorizing: Add paint and imprint text
 * Testing: Test if the pencil writes and if the colors are visible on paper.
 * Packing: Pack each article in a box​
 
@@ -62,7 +62,7 @@ Run the application (press `F5`).
 ![Application dashboard](./chapter-1/HomePageOfPencilApp.PNG)
 
 
-Now, that you have a running MORYX instance, you need to create some databases. 
+Now that you have a running MORYX instance, you need to create some databases. 
 To skip the UI here and speed things up, you'll use the MORYX CLI again.
 
 While the application is still running, `moryx exec post-setup` will create empty 
@@ -80,9 +80,9 @@ At first, you will model [products](https://github.com/PHOENIXCONTACT/MORYX-Fram
 Products represent the articles to be manufactured. MORYX differentiates between 
 `ProductType` and `ProductInstance`. The `ProductType` is what you can order 
 in a catalog, while the `ProductInstance` is what you would receive after ordering: 
-an instance of the product with its unique serialnumber. In order for a `ProductType` 
+an instance of the product with its unique serial number. In order for a `ProductType` 
 to be produced, it needs a corresponding `ProductInstance`. For further 
-information on how to create a product see [this](https://github.com/PHOENIXCONTACT/MORYX-Framework/blob/main/docs/tutorials/HowToCreateAProduct.md).
+information on how to create a product, see [this](https://github.com/PHOENIXCONTACT/MORYX-Framework/blob/main/docs/tutorials/HowToCreateAProduct.md).
 
 Let's take a look at the composition of the pencil *Pencilla Inc.* produces.
 
@@ -103,7 +103,7 @@ From the details above, the `GraphitePencilType` needs
 You will find the `GraphitePencilType` among all other `<Product>Types` in the
 `PencilFactory` package within the `Products` folder.
 
-For properties to be shown on the UI, add the [EntrySerialize](https://github.com/PHOENIXCONTACT/MORYX-Framework/blob/dev/docs/articles/Core/Serialization/EntryConvert.md#entryserialize-attribute)
+For properties to be shown in the UI, add the [EntrySerialize](https://github.com/PHOENIXCONTACT/MORYX-Framework/blob/dev/docs/articles/Core/Serialization/EntryConvert.md#entryserialize-attribute)
 attribute. For properties to be saved in the database, use the [DataMember](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.serialization.datamemberattribute?view=net-7.0) attribute.
 
 ``` cs
@@ -144,7 +144,7 @@ To create a product, you need to run the application now and head to the
 **Products UI**. 
 
 Click on the plus button to open the 'Product Importer' menu. This title may 
-sound a bit confusing, but it let's you add new products. 
+sound a bit confusing, but it lets you add new products. 
 
 > *Note* The naming here comes from the fact, that you wouldn't necessarily add
 > products here, but 'import' them from other systems.
@@ -160,13 +160,13 @@ sound a bit confusing, but it let's you add new products.
 * Click on the product you just added: `100001-00 GP-1B`
 * Click on the edit icon at the top right to edit.
 * In the `Color` dropdown choose `Green`
-* In the `Hardness` dropdown choose `B` as the hardness, which represent `1B`
+* In the `Hardness` dropdown choose `B` as the hardness, which represents `1B`
   in this case.
 * Save your changes by clicking on the save icon at the top right corner.
 
  ![Graphite GP-1B](./chapter-1/AddGraphiteProduct.PNG)
 
-Repeat the same step for a second product:
+Repeat the same steps for a second product:
 
 
 * `GraphitePencilType`
@@ -176,7 +176,7 @@ Repeat the same step for a second product:
   * *Hardness*: `HB`
   * *Color*: `Brown`
 
-If you did everything correctly you should end up with something more or less 
+If you did everything correctly, you should end up with something more or less 
 similar to the image below.
 
 ![Products list](./chapter-1/productList.PNG)
@@ -191,7 +191,7 @@ Therefore, the next step is to model a resource after which we can create a **Re
 
 ## Resources
 
-We begin with modelling the assembling station, used to assemble the pencils. This
+We begin with modeling the assembling station, used to assemble the pencils. This
 is where resources come into play.
 
 Resources represent physical assets and logical objects like robots or drivers 
@@ -219,7 +219,7 @@ Based on these requirements
 
 ### Add worker support
 
-The `AssemblingCell`, you will find it in `PencilFactory.Resources`, 
+The `AssemblingCell`, which you will find in `PencilFactory.Resources`, 
 already has an instructor.
 
 ``` cs
@@ -244,7 +244,7 @@ instructions to a worker. So the following resources are needed:
 * 1 `AssemblingCell`
 * 1 `VisualInstructor`
 
-You will setup these in MORYX within the *Resources UI* by clicking the "+" 
+You will set up these in MORYX within the *Resources UI* by clicking the "+" 
 button and selecting the required cell.
 
 
@@ -281,14 +281,14 @@ Usually a *session* (and with it a *sequence*) is started by a resource, telling
 the process engine, that it is *ReadyToWork*. 
 
 Then with `ActivityStart()` the process engine can tell a resource, that it 
-should start working on a product. After the resource has finished it's job, it 
+should start working on a product. After the resource has finished its job, it 
 will signal this with `ActivityCompleted()`.
 
 When the process engine has processed the *ActivityResult* (submitted by `ActivityCompleted`),
 it will "close" the sequence with `SequenceCompleted()`.
 
 Then, the resource could continue the current *session* (`ContinueSession`) with
-another *sequence* or start a whole new *session* by signalling `ReadyToWork`. 
+another *sequence* or start a whole new *session* by signaling `ReadyToWork`. 
 
 ![Activities, Sequences and Sessions](./chapter-1/SessionsAndSequences.png)
 
@@ -317,8 +317,8 @@ thus signal `ReadyToWork` to the ProcessEngine.
 * `ActivityClassification.Production` is used to notify that the cell is ready to
  work on an `Activity` of type `production`.
 
-Since that should result in an `ActivityStarted` event, the next thing to be
- implemented will be the `ActivityStarted()` function. Find the comment
+Since that should result in an `ActivityStarted` event, the next thing to
+ implement will be the `ActivityStarted()` function. Find the comment
 `/* Start execution here */` and replace it so that the whole function looks 
 like this:
 
@@ -379,7 +379,7 @@ This allows you to define in a rather abstract way, *what* needs to be done with
 going much more into details. MORYX will find the way later, *how* this is done
 for a running order. 
 
-Start the application, go to *Wokplans* and click on the plus button.
+Start the application, go to *Workplans* and click on the plus button.
 
 ![Create new workplan](./chapter-1/NewWorkplan.png)
 
@@ -402,7 +402,7 @@ When you are done, modeling your workflow, you have to save the workplan.
 
 ### Add a *Recipe*
 
-In order to make the connection between a`Product` and the `Workplan` you just 
+In order to make the connection between a `Product` and the `Workplan` you just 
 created, you need a *Recipe*.
 
 Go to *Products* and select the *Product* you want to produce, that is the 
@@ -418,13 +418,13 @@ your created workplan `Workplan`.
 ![Create a new recipe](./chapter-1/pencilRecipe.PNG)
 
 * Click on **Create** for the recipe to show up in the products UI. 
-* For the recipe to be automatically seletcted when the product is produced, select 
+* For the recipe to be automatically selected when the product is produced, select 
 `Default` Classification.
 * Save your changes by clicking on the save icon located at the top right corner.
 
 ![Select recipe classification](./chapter-1/firstRecipe.PNG)
 
-* Repeat the same step for the second product `100002-00 Green Pencil GP-HB`.
+* Repeat the same steps for the second product `100002-00 Green Pencil GP-HB`.
 
 ### Start production
 
@@ -463,7 +463,7 @@ Now the production is running!
 That's it, you should now be able to let the pencils flow through the assembling
 cell.
 
-In order to see the visual instructions, got to the module `Worker Support` and select for VisualInstructor as Display
+In order to see the visual instructions, go to the module `Worker Support` and select for VisualInstructor as Display
 
 ![Select Display](./chapter-1/SelectDisplay.png)
 
@@ -483,7 +483,7 @@ The application depends on MORYX modules, that are licensed. But no worries:
 They ship with developer licenses, that need to be activated:
 
 * Open *CodeMeter Control Center*, 
-  that you should have installed beforehand through the [CodeMeter User Runtime (Version 8.x)](https://www.wibu.com/de/support/anwendersoftware/anwendersoftware.html)
+  which you should have installed beforehand through the [CodeMeter User Runtime (Version 8.x)](https://www.wibu.com/de/support/anwendersoftware/anwendersoftware.html)
 * Drag & Drop the `.WibuCmRau` files onto it
 
 ![Activate developer licenses](./chapter-1/drag-licenses.png)

chapter-2-drivers.md

@@ -1,14 +1,14 @@
 # Driver
 In this chapter you will implement the ColorizingCell and the TestingCell. 
-Both of them are automatic cells, which don't need any user interactions. 
+Both of them are automatic cells, which don't need any user interaction. 
 Correspondingly there are no visual instructions. Instead there is some kind of hardware, which needs to be connected to MORYX.
 
 For the cell to communicate with the hardware a [Driver](https://github.com/PHOENIXCONTACT/MORYX-Framework/blob/dev/docs/tutorials/HowToBuildADriver.md) is needed. 
 In here the communication is encapsulated.
 
 As there are many different ways to communicate, there are also many different implementations of drivers. 
 Common interfaces for drivers are `IMessageDriver<TMessage>` and `IInOutDriver`.
-* The `IMessageDriver<TMessage>` is used for message based protocols. The driver is able to send and receive messages. When a new message is received, an event get's invoked. A typical procotol would be MQTT.
+* The `IMessageDriver<TMessage>` is used for message based protocols. The driver is able to send and receive messages. When a new message is received, an event gets invoked. A typical protocol would be MQTT.
 * The `IInOutDriver` can read and write variables on a server. A typical protocol is OPC UA. 
 
 ## Simulated InOutDriver
@@ -24,10 +24,10 @@ The ColorizingCell is using a protocol, where it can read and write variables on
 
 1. When the physical cell is ready to work, it will set the input `Ready` to `true`.
 2. The digital twin will send a `ReadyToWork`. 
-3. When the cells receives an activity, set the output `ProcessStart` to `true`. 
+3. When the cell receives an activity, set the output `ProcessStart` to `true`. 
 4. Read the result from the input `ProcessResult`. 
 
-For a protocol like that the `IInOutDriver` makes the most sense. Open the ColorizingCell and replace the already generated `IMessageDriver` by an `IInOutDriver`. Also add constants the names of the variables to read and write.
+For a protocol like that the `IInOutDriver` makes the most sense. Open the ColorizingCell and replace the already generated `IMessageDriver` by an `IInOutDriver`. Also add constants for the names of the variables to read and write.
 
 ```cs
 [ResourceRegistration]
@@ -44,7 +44,7 @@ public class Colorizing : Cell
 }
 ```
 
-In order to recognize, when an input changed, subscribe to that in  `OnInitialize` and when the driver is set. If you don't also subscribe to the event in the setter of the driver, you always have to restart the system after changing the driver of a cell.
+In order to recognize, when an input changes, subscribe to that in  `OnInitialize` and when the driver is set. If you don't also subscribe to the event in the setter of the driver, you will always have to restart the system after changing the driver of a cell.
 
 ```cs
 private IInOutDriver<bool,bool> _driver;
@@ -74,7 +74,7 @@ protected override void OnInitialize()
 
 
 
-In the method `OnInputChanged` you will check, if the value of `Ready` changed. If it is true, send a `ReadyToWork` to the ProcessEngine.
+In the method `OnInputChanged` you will check, if the value of `Ready` has changed. If it is true, send a `ReadyToWork` to the ProcessEngine.
 
 ```cs
 private void OnInputChanged(object sender, InputChangedEventArgs e)
@@ -108,7 +108,7 @@ private void OnInputChanged(object sender, InputChangedEventArgs e)
 }
 ```
 
-In order to start an activity on the phycial cell when an activityStart is received, set `ProcessStart` to `true`.
+In order to start an activity on the physical cell when an activityStart is received, set `ProcessStart` to `true`.
 ```cs
 public override void StartActivity(ActivityStart activityStart)
 {
@@ -135,7 +135,7 @@ public override void SequenceCompleted(SequenceCompleted completed)
 }
 ```
 
-The same applies for `ControlSystemAttched`.
+The same applies for `ControlSystemAttached`.
 
 ```cs
 public override IEnumerable<Session> ControlSystemAttached()
@@ -158,7 +158,7 @@ public class SimulatedColorizingDriver : SimulatedInOutDriver<bool, bool>
 }
 ```
 
-A `SimulationDriver` has several states, which are needed in order for the SimulationModule to know whats happens. After the system has booted, the driver is in the state `Idle`. Is a product arriving, the cell sends a `ReadyToWork` and the driver changes its state to `Requested`. During production the state is `Executing` and afterward it changes back to `Idle`.
+A `SimulationDriver` has several states, which are needed in order for the SimulationModule to know what happens. After the system has booted, the driver is in the state `Idle`. Is a product arriving, the cell sends a `ReadyToWork` and the driver changes its state to `Requested`. During production the state is `Executing` and afterward it changes back to `Idle`.
 
 ![States of a SimulationDriver](./chapter-2/SimulationStates.png)
 
@@ -173,7 +173,7 @@ public override void Ready(IActivity activity)
 }
 ```
 
-The method `OnOuputSet` gets called when outputs where changed. In this example only the output `ProcessStart` gets set, which would activate the production.
+The method `OnOuputSet` gets called when outputs are changed. In this example only the output `ProcessStart` gets set, which would activate the production.
 
 ```cs
 protected override void OnOutputSet(object sender, string key)
@@ -189,7 +189,7 @@ protected override void OnOutputSet(object sender, string key)
 }
 ```
 
-The method `Result` gets called by the after the (simulated) physical cell has finished its task. It sets the input `ProcessResult` in order to pass on the result to the digital twin.
+The method `Result` gets called after the (simulated) physical cell has finished its task. It sets the input `ProcessResult` in order to pass on the result to the digital twin.
 
 ```cs
 public override void Result(SimulationResult result)