[C++] Groot project

[epic007]

Ik ben bezig met een redelijk groot software project. Het betreft een industriële applicatie die bestaat uit een camerasysteem met meerdere robots. Het camera systeem moet voorwerpen op een lopende band herkennen en vervolgens opdrachten geven aan robots. De robots zijn zelfstandige 'domme' units die met de software gaan communiceren via tcp/ip.

De software zal gaan bestaan uit verschillende modules:

- server
- taakverdeler voor robots
- vision gedeelte (camera interface, framegrabber, processing)
- user interface
- database

De losse onderdelen ontwikkelen is niet zo'n probleem, ik heb al een server die met de robots kan communiceren en de camera interface werkt ook al standalone. Mijn vraag is hoe ik deze onderdelen op een mooie manier kan laten samenwerken. De vision software zal met de taakverdeler moeten communiceren en de taakverdeler met de server. Verder moeten de onderdelen via de UI benaderbaar zijn.
Omdat de vision component vrij veel performance vraagt heb ik het project nu opgezet in c++. Ik maak hier bij zoveel mogelijk gebruik van STL en andere c++ libraries (OpenCV, Poco, Qt voor UI). Ik heb het project nu zo opgezet dat de verschillende modules ook als losse libraries gecompileerd worden. (Windows, Visual Studio 2010).

Ik probeer te streven naar "low coupling en high cohesion" maar wat zijn hierbij de best practises? Zijn hier goede boeken over? Ik ben bekend met design patterns e.d. alleen dit gaat een stapje hoger naar mijn idee.

[MSalters]

Het is lastig om boek-kennis zomaar te vertalen naar praktijksituaties. Het vakgebied wat je zoekt is systeemarchitectuur cq. systems engineering. Ik zie in je lijstje dat je daar beperkte ervaring mee hebt.

Zo is "server" een generieke benaming voor een gedeelde component uit een client-server componenten architectuur, "taakverdeler" is een specifieke component die een bepaalde rol vervult, en "vision gedeelte" is een conceptuele afbakening. Het is dus een heterogene lijst.

Een gestructureerde aanpak beschrijft de taken van het hele systeem, en breekt dit systeem op in componenten. Sommige taken kunnen exclusief door 1 compoment worden uitgevoerd; andere taken zijn de verantwoordelijkheid van 1 component die werk delegeert aan andere componenten, en (niet ideaal) sommige taken zijn de gecombineerde verantwoordelijkheid van meerdere componenten.

Low coupling betekent in deze context dat componenten zoveel mogelijk zelf een taak kunnen uitvoeren, en waar ze werk delegeren dat dit om een duidelijk afgebakende subtaak gaat. High cohesion betekent dat gescheiden taken bij aparte componenten terecht komen.

[epic007]

Klopt, die vakken hadden ze indertijd niet op mijn opleiding. Ik heb hier zelf mijn methoden in gevonden. (Misschien nog eens iets voor een opfriscursus).

Om toch nog iets meer in detail te treden, dit is hoe ik het nu heb opgelost. In mijn main project heb ik een Context classe gemaakt waar alle onderdelen samenkomen:

C++:

class Context
{
public:
  Context()
  ~Context()

  void start();
  void stop();

private
  Server _server;
  RobotManager _manager;
  Dispatcher _dispatcher
  ImageProcessing _processing;
}

En in de constructor hiervan worden de afhankelijkheden doorgegeven:

C++:

Context::Context() :
  _server(_manager),
  _manager(_dispatcher),
  _processing(_dispatcher)
{
...
}

Waarbij bijvoorbeeld de server er zo uitziet

C++:

class Server
{
public:
  Server(RobotManager& manager) : _manager(manager) {}

private
  RobotManager& _manager;
}

Dit werkt voor nu prima, alleen misschien zijn hier beter manieren voor? Ik heb in ActionScript wel eens met een direct injection framework gewerkt (http://www.robotlegs.org/) maar ben zoiets nog niet in c++ tegengekomen.

[MSalters]

Je code suggereert eerder een "pipeline" pattern.

PS. in C++ heb je constructors en destructors, dus "void start" en "void stop" zijn niet-standaard namen.

[YopY]

MSalters schreef op donderdag 07 juni 2012 @ 11:51:
Je code suggereert eerder een "pipeline" pattern.

PS. in C++ heb je constructors en destructors, dus "void start" en "void stop" zijn niet-standaard namen.

Die definieert hij ook in zijn header . Het starten en stoppen van een object of service is iets anders dan het construeren daarvan.

[epic007]

MSalters schreef op donderdag 07 juni 2012 @ 11:51:
Je code suggereert eerder een "pipeline" pattern.

PS. in C++ heb je constructors en destructors, dus "void start" en "void stop" zijn niet-standaard namen.

start() en stop() zijn inderdaad gewoon functies om de boel te starten / stoppen.

Het is niet echt een pipeline pattern omdat de constructors ook wel complexer kunnen worden:

C++:

Context::Context() : 
  _server(_manager), 
  _manager(_dispatcher, _server), 
  _processing(_dispatcher, _manager) 
{ 
... 
}