Guide - Assembly Module - SimpleMES

This plugin module requires the Core SimpleMES , which in turn requires a number of other plugins, such as the Enterprise Framework .

The only dependency you have to include in your build.gradle file is the core module:

This will add any required plugins to your application.

This module works with the core MES module, which is located under the package org.simplemes.mes. To avoid conflicts with other modules, the assembly module is located under the package org.simplemes.mes.assy.

The basic package layout is:

All classes provided by this Assembly module will be under the org.simplemes.mes.assy package. The packages under this package will mirror the mes core structure (e.g. shop floor extensions will be in the floor sub-package. Product extensions will be in the org.simplemes.mes.assy.product package.

The sections below will give an overview of the main features provided by this module. The specific details will be covered in detail in the reference document.

This module makes a number of additions to the core MES module. This addition adds related domain classes to support logging of components assembled into orders and LSNs. See Data Model for details.

SimpleMES will index all assembly data entered by the operators. This allows a full-text search on the data collected during assembly. Typically, this will include data collected for the assembly data type (a flex type) fields. For example, you might collect a LOT and VENDOR during the assembly process. If you want to find all orders that used anything with the text '65028937-011', then you could search with:

This would find any order that has the text '65028937-011' in its data. This could match things other than the LOT. To limit your search to just the LOT field, you could search with:

This will find just records that have the value '65028937-011' in the Flex Type field LOT.

The Search Engine and the Postgres JSON SQL queries use the flex type field names in case-sensitive queries. If you define a field name as 'LOT' and then try to query on 'lot', then the values won’t be found.

You should make sure you use a consistent field naming convention. In particular, make sure to use the same case for all field names. Use all upper case, all lower case or consistent mixed case.

When you need to find the orders/LSNs that used a given component lot, this report is the best starting place for your search. This report will perform a full-text search for any text entered. It also supports the syntax for searching on just a single flex type field (e.g. 'lot:65028937-011').

The orders/LSNs found with the component will be displayed in a simple list with a hyper-link to the detailed Order/LSN Assembly Report.

This report shows the detail assembly data for the given Order/LSN. This can include any removed components. The important assembly information shown includes the user, date of assembly and the component details.

There are a number of object diagrams to show you the relationships between various objects. These follow a general shape and color scheme as shown below:

Most orders will be built with components of some sort. The required components are pre-defined in the Product . These are copied to the order upon release so each order has its own specific list of components required. These are stored in the OrderBOMComponent domain class.

The Order Assembled Component tracks the actual components assembled into the order. This includes optional details on the source of the components (e.g. vendor and lot).

This element informally belongs to the MES Core Order parent. Since the Order is in another module, the normal child relationship notation can’t be used. Instead, this module maintains the relationship between the component and order records. It also provides an archive mechanism to keep the component requirement data long term.

Defines a single component assembled into an order (and optionally an LSN). This includes a 'location' mechanism to track where the component was loaded from on the work center setup. This location can be a bin, shelf or automated feeder location. These are stored in the OrderAssembledComponent domain class.

This object records the long-term component history, so there are no real primary keys for the record. No records are deleted from this table (except during order archive or other order delete scenarios). A unique sequence is assigned to each record added.

The component’s history is tracked using assembly data (e.g. the supplier, lot code, date code, etc) provided by the operators. This assembly data is stored in a Flex Type based on the assemblyData Flex Type. This means the actual assembly data is stored in JSON in the field assemblyDataValues. This allows the GUIs to collect configurable data from your operators without forcing any database or other customizations.

This component history is associated with an Order and optionally with an LSN. This means you can track component usage at the order level or at a lower level for the individually unit or lot (LSN).

The OrderAssembledComponent domain is loosely linked to an Order and an optional LSN. This means component can be assembled as a lot assembled into a lot, or a serailized component assembled into a specific unit (LSN).

The ProductComponent a single component requirement for a specific Product. A Bill of Material (BOM) is a list of the components needed to build a given product. This BOM can contain manufactured or purchased products as components for the manufactured product.

Components are just another product that is assembled into a final product. These can be manufactured or purchased from an outside supplier.

The BOM is added to the core MES Product GUIs by this module. It allows you to define which components (other products) that must be assembled to make an assembly. This includes the quantity required.

The BOM is stored in the ProductComponent domain class, which is a custom child list extension to the core Product domain.

An LSN (Lot/Serial) a single order.

This LSN is provided by the core MES module.

A single order from a customer to produce a quantity of a product. This is sometimes known as a job or shop order.

This Order is provided by the core MES module.

A Product is a part or object that is produced on your shop floor or purchased from external sources. This is sometimes known as a part number or model number.

This Product is provided by the core MES module.

This module adds the Product Component (BOM) child list to the Product domain to track the required components for a product.

A Routing is a sequence of operations needed to manufacture a Product. These operations can be simple actions such as ASSEMBLE or TEST. They may also be a composite operation that is made up of several actions that are not tracked within SimpleMES.

This module adds a new flag to the RouterOperations to control when automatic assembly is done on processed Orders or LSNs:

This is am AssemblyModeEnum .

When the assemblyMode is set to anything other than NONE, the start() or complete() methods will automatically assemble the appropriate components from the work center’s components into the order or LSN.

A Work Center is a machine or location where a manufacturing operation is performed. It can also refer to the people at a location where the operation is performed.

This assembly module provides additions to the core Work Center domain and services.

This assembly module provides:

Provides user-defined data types. The framework supports these user-defined fields directly using Flex Types .

The user-defined field values are stored in a large string column in the database as JSON.

This MES Assembly plugin provides most of the business logic of assembly as services. These services use the domain objects to affect the persistent state of objects.

See the MES Core Services for an overview of how the domain objects and services interact. This includes working with input arguments and database transactions.

addComponent() findComponentAssemblyState() postRelease() removeComponent() undoComponentRemove()

The Order Assembly Service provides methods to process assembly information on an order or LSN. This service provides the ability to assemble components and adds assembly extensions to the mes core Order logic. This includes copying component details to the order during release of the order. See MES Core Services for details on the core service.

The service methods are exposed using the OrderAssyController . These controller methods generally match the inputs and outputs of the services. The only difference is the values are passed as JSON strings.

The ScanAssyService supports scanning of assembly information in the Scan Dashboard . This service adds extensions to the core ScanService.scan() method to identify component barcodes as scanned by the operator. These scans will provide almost all of the information needed to assemble components.

See MES Core Services for details on the core service.

The scan service methods are not exposed by any controller in this module. The module relies on the core scan controller to provide access. This module does provide data entry activities for component assembly and the related controller.

The easiest component barcode for the operator to work with is the formatted barcode that contains the component and the lot/serial number to assemble. This is typically used to assemble purchased products with multi-part barcodes labels.

Using the simplest internal format, an example barcode looks like this:

This will assemble the component WHEEL-27 from the vendor ACME_WHEELS with the lot code 200171023. When scanned with a current order/LSN in the scan dashboard, this module will auto assemble the component into the order.

This example uses the simple internal format for multi-part barcodes. For supported barcode formats, see Barcode Formats .

See Barcode Prefixes for details on encoding multi-part barcodes for assembly-related data.