Van idee naar prototype – vanuit een softwareperspectief

Robbert Ploeg werkt tweeënhalf jaar als softwareprogrammeur bij Moba in Barneveld. Voor een nieuwe machinelijn zet hij in teamverband de software op. Naast de technische uitdagingen betekent dat ook veel afstemming met andere ontwikkelgroepen binnen het bedrijf.

Robbert Ploeg is junior programmeur bij Moba in Barneveld.

Om aan de groeiende wereldwijde vraag naar eieren en eigerelateerde producten te voldoen, worden er dagelijks honderden miljoenen eieren gesorteerd, verwerkt en verpakt. Het zal u niet verbazen dat het bij dergelijke aantallen een behoorlijke uitdaging is om het ei van kip naar consument te krijgen. Het is een logistiek en hightech proces van de bovenste plank.

Als marktleider heeft Moba zeventig jaar ervaring in de eierindustrie. We leveren geïntegreerde totaaloplossingen op het gebied van sorteren, verpakken en verwerken van eieren. Oplossingen die een meerwaarde bieden als het gaat om resultaat, voedselveiligheid, flexibiliteit en gebruiksgemak.

De verschillende machinetypes die Moba maakt, zijn binnen de r&d-afdeling verdeeld over verschillende Product Groups. Dit zijn projectteams van ongeveer acht personen die ook nieuwe machines en concepten ontwikkelen, alsmede modificaties op bestaande lijnen doen. Op het moment van schrijven is de productgroep waarin ik werk gegroeid naar dertien mensen. Samen zijn we nu anderhalf jaar bezig met het ontwikkelen van een nieuwe machinelijn.

Een nieuw idee

Het hele ontwikkeltraject voor de nieuwe machinelijn is ongeveer twee jaar geleden begonnen. Collega’s hadden een idee voor een dynamische, generieke nieuwe machinelijn. Het managementteam was enthousiast, dus we mochten een proof of concept gaan ontwikkelen.

Onze productgroep – op dat moment nog zeven personen groot – kwam direct in actie. We startten met het bedenken van het mechanische concept. Hoe komt de nieuwe machine eruit te zien? Welke opties komen erop? Welke Moba-principes nemen we mee? Initieel veel mechanisch denkwerk dus. Niet veel later kwam de benodigde hardware ter sprake: hoe zal de hardwarearchitectuur eruitzien? Welke pc’s of plc’s zijn nodig? Ook de software werd besproken: wat kunnen we hergebruiken van andere machines en productgroepen? Met welke talen zal het worden geschreven? Welke features zijn nodig? Welke features zijn kritiek voor het prototype?

De eerste software

Een maand nadat we een initieel machineconcept op alle vakgebieden hadden opgesteld, was het tijd om te starten met de softwareontwikkeling. De eerste stap – zoals bij alle andere grote softwareprojecten – was het opstellen van modellen en ontwerpen. Samen met een softwarecollega binnen het team dook ik in de UML. Het resultaat was een aantal initiële diagrammen, die we hebben gepresenteerd aan de softwarearchitecten en andere grote spelers binnen de softwarevakgroep van Moba. Deze softwareontwerpen heb ik anderhalf jaar later nog steeds naast mij op mijn bureau liggen.

Ook een ontwikkelomgeving was nodig om de eerste projectopzet in te maken en de eerste software in te schrijven. De keuze viel op Linux en C++. Het ontwikkelen van Linux-applicaties gebeurt binnen Moba met virtual machine images die op dit moment in het project nog niet waren gestandaardiseerd. Met z’n tweeën waren we de initiële gebruikers van de eerste generieke development image. Dit vergde extra overleg en gezamenlijke ontwikkeling met de mensen die met deze standaard images bezig waren.

Een nieuwe jas

Drie maanden na de start van het project hadden we een goedgekeurd ontwerp voor een blank-sheet machineapplicatie, meerdere uitgebreide UML-diagrammen, een werkende ontwikkelomgeving binnen Linux en een passie om te starten met het schrijven van de software. Dat we de software vanaf een leeg papier mochten opzetten, betekende dat we te maken hadden met nul legacycode.

Features die door eerdere Moba-programmeurs zijn gemaakt voor andere machines hebben we bekeken, besproken met de desbetreffende kennisdragers en daarna omgezet om te passen in ons top-of-the-line softwareontwerp. Uiteraard spelen de bestaande documentatie en de feedback van de kennisdragers mee bij het bepalen hoe de software eruit komt te zien.

De software die we schreven, hield rekening met de laatste interne en externe standaarden zoals bijvoorbeeld C++11, nieuw binnen Moba.

Simulatie

Het programmeren van de benodigde softwarefeatures voor het aankomende prototype nam in deze fase van het project veel tijd in beslag. Nieuw geschreven software wil je testen, het liefst natuurlijk op een machine. Maar hoe kun je software testen als de machine nog niet bestaat? Dit doen we voor onze nieuwe machine op twee manieren: Google-unittests en simuleren.

Dat laatste is mogelijk aangezien we alles kunnen gebruiken van de gedeelde Moba-softwarelibrary’s. Met behulp van een in Javascript geschreven simulatielibrary (Three.js) kunnen we de machine, zoals deze er volgens het bedachte concept uitziet, tekenen in een webgebaseerde 3d-omgeving.

Met een Rest-interface en een aantal api’s gekoppeld aan onze backend-machinecode kunnen we de huidige data die speelt in de machine sturen naar de 3d-simulatie. Op deze manier is het dus mogelijk om softwarefeatures te testen op de ‘machine’. Lastige features zoals het sorteeralgoritme kunnen met behulp van unittesting en simulatie compleet worden afgetest zonder dat hier een echte machine met echte eieren voor nodig is.

Integratie en nieuwe technieken

Tijdens het programmeren, simuleren en testen van de nieuwe software werden onze ontwikkelingen steeds bekender bij de andere productgroepen. Hierdoor kwamen er externe wensen binnen die voor bijvoorbeeld een prototype mooi zijn om mee te nemen. Denk bijvoorbeeld aan een userinterface van de machine, iets waarmee een andere productgroep binnen Moba is begonnen. Deze productgroep, Integratie, heeft onder meer als doel om de gebruikersinterfaces voor alle Moba-machines gelijk te trekken. Dit betekende voor onze machine dat we begonnen aan een eerste versie van een userinterface (ui).

Deze ui is geschreven in Javascript, waarbij met behulp van de door de Integratie-groep gestandaardiseerde elementen een eerste paar schermen is opgesteld. Tijdens de ontwikkeling van de andere backend-softwarefeatures werd nu ook steeds over de frontend nagedacht. Deze frontend-code en implementatie werden gereviewd door user experience-specialisten binnen Moba, zodat de door ons bedachte schermen ook gebruikersvriendelijk zijn.

In de backend zijn meerdere technische upgrades geweest. Zo blijft natuurlijk de gedeelde Moba-library verbeteren, maar ook vanuit andere teams komt er input. Een andere productgroep, op dat moment ook bezig met een nieuwe machine, heeft met een modelleertool (en bijbehorende codegeneratie) de hele machine in elkaar gezet. Deze tool kan complexe statemachines valideren en daarbij alle situaties nalopen. Deze dienen allemaal te worden afgevangen, om te voorkomen dat in het veld bij de klant excepties kunnen optreden. We hebben de tool toegepast in een grote component van de machine waarvoor op dat moment nog geen code was geschreven. Aangezien deze component ook voor andere machines wordt gebruikt, denken we bij elke stap na over de herbruikbaarheid voor de andere productgroepen binnen Moba.

Prototype

En dan komt alles samen. De prototypefase is aangebroken. Onze mechanische mannen hebben een prototype van het concept neergezet in het Product Research Center in Barneveld. De eerste stap is om samen met de hardwareman onze Linux-pc werkend te krijgen. Dan met de laptop onder de arm naar het PRC, spanning op de machine en alles opstarten. Na een tijdje de applicatie starten en dan komt de userinterface naar boven. Ethernetkabel van de laptop naar de machine? Check. Verbinding? Check.

De volgende taken op de planning? Het testen van de vooraf geschreven en tot nu gesimuleerde code in de echte wereld. Het is fantastisch als de lampen aan- en uitgaan, de servomotoren en de bijbehorende controllers worden aangestuurd en de machine gaat leven.