RulePro◆
EN Plan een demo
Het productmodel

De taal van modulair werken, van positie tot variant

Negentig procent van modulair werken zit in de verbindingen, niet in de blokken. Leer de vijf lagen, de interfacekaart en de drie treden voor elke afhankelijkheid.

Modulair werken heeft een eigen taal. Posities, interfaces, modules, varianten en attributen. Wie die taal deelt met engineering en verkoop, bouwt een productmodel dat jaren meegaat. We leggen hem uit met twee beelden die iedereen begrijpt. Een puzzel en een werkbank.

Het product als puzzel

Het product als puzzel: posities zijn lege vakken, de interface is de nop en uitsparing, modules zijn de stukjes en varianten de waaier stukjes die ook passen
Een puzzel, vaste vakken, wisselende stukjes. Zolang de noppen bevroren blijven, mag elk stukje veranderen.

Het lege vak is de positie. Die ligt vast en wacht op een stukje. De nop en de uitsparing vormen samen de interface. Passen die, dan klikt elk stukje dat zich aan de vorm houdt. Het stukje is de module, en er passen meestal meerdere stukjes op hetzelfde vak. Alternatieven en varianten. Een stukje mag zelf weer een kleine puzzel zijn. Modules mogen modules bevatten, zolang ook daar de noppen bevroren zijn.

Vijf lagen, een taal

De vijf lagen van een modulair productmodel: geconfigureerd product, positie, module, variant en onderdelen, met attributen als aparte dimensie
Abstract bovenin, concreet onderin. De echte maten wonen bij de variant.

De test die alles simpel houdt.heeft het een fysieke interface? Het ladeblok schroeft aan het frame, module. Kleur verbindt niets, attribuut. Zo voorkom je dat alles een zware module wordt.

De positie ligt vast, de module wisselt

Werkbankvoorbeeld met twee posities waarin een ladeblok, deurkast of niets past, en een brede lade die beide posities claimt
De interface hoort bij de positie, niet bij de module.

De interface hoort bij de positie, niet bij de module. Elke module die de interface volgt past erin, ook de module die je volgend jaar pas bedenkt. En let op het brede stukje dat twee vakken tegelijk claimt. Zo'n brede lade is alleen kiesbaar als links en rechts allebei vrij zijn. Dit soort spelregels bewaakt een configurator foutloos, een mens niet.

De interface is het contract

Interfacekaart met mechanische aansluiting, elektrische doorvoer, verplicht attribuut en wijzigingsregels, plus het interfaceregister
Hier mislukken de meeste modulariseringen. Niet op de blokken, maar op verbindingen die stilletjes blijven schuiven.

Negentig procent van modulair werken zit in de verbindingen, niet in de blokken. Leg elke verbinding vast op een interfacekaart. Mechanisch (boutgaten, hart-op-hartmaten), elektrisch en de attributen die elke module moet melden. Kaarten hebben een status, versie en eigenaar en vormen samen het interfaceregister, in de industrie bekend als interface control document. Bevroren is bevroren. Wijzigen kan alleen via een nieuwe versie met impactcheck.

Wie levert de waarde van een attribuut?

De positie eist dat een bezette breedte gemeld wordt. De module belooft dat zijn uitvoeringen dat doen. Maar het echte getal komt van de variant. Daar liggen de maten vast. Globale attributen (zoals buitenkleur) leg je eenmalig vast. Gemarkeerde delen lezen mee en een bewuste override blijft mogelijk.

De ERP-nuance

Kleur blijft een eigenschap in het model. Wil je ERP per kleur een eigen artikelcode? Prima, het systeem genereert die op ordermoment. Het punt is niet dat die code niet mag bestaan, maar dat je engineer hem niet meer met de hand maakt.

Van als-dan-regels naar een attribuut

Vergelijking van als-dan-regels tussen modules met de schone aanpak waarin elke module zijn bezette breedte meldt en de plint per kant zijn eigen lengte berekent
De afhankelijkheid stroomt als data door de interface, niet als regels tussen modules.

Voorbeeld werkbank. De plint moet passen bij wat er aan zijn kant onder hangt. Naïef wordt dat een web van als-dan-regels dat bij de tiende module onbeheersbaar is. De schone aanpak werkt anders. Elke module meldt een waarde aan zijn positie (de bezette breedte), en elke plint leest alleen zijn eigen kant. Links een blok van 300 mm? Plint links = 3.000 − 300 = 2.700 mm. Nieuwe module volgend jaar? Die meldt alleen zijn breedte. Nul nieuwe regels.

De discipline in drie treden.ontwerp de afhankelijkheid weg (een lengte met vulstuk), anders absorbeer hem in de interface (gepubliceerd attribuut), en pas als laatste een beheerde spelregel in het regelregister, met eigenaar, versie en reden.

Elke afhankelijkheid is een verplichting, geen feature.

Veelgestelde vragen

Wat is het verschil tussen een module en een variant?
Een module is een bouwsteen met een stabiele interface die je kunt selecteren zonder de buren opnieuw te engineeren (het ladeblok). Een variant is een verwisselbare uitvoering van die module (ladeblok 300 of 400 mm breed). Op een positie kies je eerst welke module, daarna welke variant.
Wat is een positie in een productconfigurator?
Een positie is een vaste plek in de productstructuur waar een module in klikt, zoals een leeg puzzelvak. De interface hoort bij de positie, niet bij de module. Elke module die de interface volgt, past. In PLM komt dit overeen met een slot in de stuklijst (find/positienummer).
Wanneer is iets een attribuut in plaats van een module?
De testvraag. Heeft het een fysieke interface die met iets anders verbindt? Zo ja, dan is het een module. Zo nee (kleur, materiaal), dan is het een attribuut. Attributen beheer je als data. En als je ERP per kleur een artikelcode wil, genereert het systeem die op ordermoment. Je engineer maakt hem niet met de hand.
Hoe beheer ik interfaces in de praktijk?
Via een interfaceregister, met per verbinding een interfacekaart met wat erover gaat (mechanisch, elektrisch, data/attributen), een status (concept of bevroren), een versie en een eigenaar. Wijzigen kan alleen via een nieuwe versie met impactcheck. In de industrie heet dit een interface control document (ICD).
Hoe voorkom ik een wirwar van als-dan-regels?
Drie treden, in deze volgorde. Ontwerp de afhankelijkheid weg; absorbeer hem in de interface als gepubliceerd attribuut dat modules melden en buren lezen; en pas als laatste een expliciete, beheerde regel in een regelregister.

Van jouw posities en interfaces naar een werkend model.

Breng je lastigste samenstelling mee. We zetten de posities, interfaces en varianten om in een model dat alleen maakbare keuzes toelaat.

Plan een demo Waar je stuklijsten leven