I will try to explain my understanding. Some some simple example will illustrate the difference.
Simple Example of Behaviour PC is a software program.
Example Node PC is a computer hardware.
Behavior PC can be deployed on Node PC. In this example this means that software can be deployed on the hardware.
Another example from mechanical system.
Let’s build model of a house.
There are many systems and components in a house: constructions and engineering systems, user systems, …
There are many rooms and walls that accomodate different behaviour components.
In this case room or wall can be modeled as NodePC. Furniture, engineering systems components, air volumes and so on can be modeled
as behaviour PCs. When you deploy behaviur components to the node pc you say that some components
are situated in the room (Node PC). (room runs this components)
Another example of Node PC is building wall. For building wall can be deployed components from different behaviour systems:
construction components, electrical wires, insulation components, pump tubes and so on.
When you deploy these behaviour components to node pc you say that this node runs this behavor PC.
For Node PC hierarchy of node PCs can be defined.
Buidling->Building level->Room/Room Zone (->Wall->Wall section)
In Capella you can deplot your behaviour PC on any level of node PC’s hierarchy.
Behaviour PCs constitutes another hierarchy
When you deploy from behavior PC to node pc you map elements of two different hierarchies.
Principal near the same as for function allocations to components (logical components or physical behaviour components )
function -> behavior component -> node
There are three types of exchange types
- functional exchange between functions
- component exchanges between logical/physical behaviour components
- physical exchanges between node pc’s
Examples of this exchanges
- remote fuction call
- program link between 2 software components
- physical Ethernet cabel conection between 2 computers that
In Capella you define allocations between this exchange types
function excgange -> component exchange -> node exchange
When you make your desing you say
- this functions exchange some information
- this functions exchange information over this component’s exhcnges/interfaces
- this components exchange is realized by this physical media (cabel, air, …)
one physical can run different behavior components exchanges
one components exchange can run different fuctional exchanges
Hope this will help