2.5. Machine and Plant Data Collection and their Performance Indicators

The Machine Data Collection and Plant Data Collection are about recording actual values, times and quantities, which happen during the manufacturing process. The recording may be directly from the machine or by a staff member through Shop Floor Terminal. The Shop Floor Terminal is the central source of information for the staff members, where the operations to be executed are displayed, arranged according to their planned start date. The corresponding documents for each operation can also be displayed here. In addition, the Shop Floor Terminal is used for Production Data Collection, because processes and staff members are logged in and out here. In addition, the machine operator can provide all information on operating states and quality details of the output quantity if these cannot be read automatically from the machine or in case of a manual workplace.

2.5.1. Domain-Specific Knowledge

2.5.1.1. Key Performance Indicators

The key performance indicators (KPIs) describe the share of losses of a machine or process or provide information as to potential for optimization of machines and processes, respectively. This chapter explores specifically the following two information systems.

The Overall Equipment Effectiveness (OEE) considers availability, performance and quality losses and can - in case of insignificant figures - indicate unused production capacities, which equates to a waste of assets.

Overall Equipment Effectiveness

2.5.1 Overall Equipment Effectiveness

The Overall Process Efficiency (OPE) is a product-specific key figure. A low OPE indicates among other things avoidable capital commitment costs [1].

Overall Process Efficiency

2.5.2 Overall Process Efficiency

2.5.1.2. Durations

As explained in Section 2.4, a number of target values exist for the individual operations of a production order, for example with regard to their setup and processing times. During order processing, however, it is possible that these target values cannot be reached or adhered to. The actual values are recorded by the IoT Platform on the basis of Machine and Production Data Acquisition.

2.5.1.3. Difference between Operation Phases and Operating States

The following example shall illustrate the difference between operation phase and operating state.

An operation is assigned to a workplace. In order to start the processing, the worker logs in at the Shop Floor Terminal of that machine and switches, if applicable, to “setup”. With this, the operation phase setup is recorded. After the setup is completed, the worker switches the operation to “processing”. The operation phase “setup” is therefore completed and switches to the phase processing. Start and end times of the phases are recorded in the system.

Recorded operation phases

2.5.3 Recorded operation phases

Parallel with the start of the operation phase “setup”, the operating state “setup” is also recorded. When smoothly changing to the phase “processing”, the operating state “production” is recorded. The workplace now also has the state “production”. After some time, the machine is halted for unknown reasons, thereupon the operating state “undefined stoppage” is recorded. The operation phase does not change. The reason for this is that, along with the duration of the operation phases, the overall execution time is calculated, independently of the operating states that could have led to the machine stoppage. The operating state “production” is recorded again.

Recorded operating states

2.5.4 Recorded operating states

To identify what led to the “undefined stoppage”, the worker has to confirm this at the Shop Floor Terminal.

Rückgemeldete Betriebszustände

2.5.5 Recorded operating states after confirmation

2.5.1.4. Time Bases

Time bases are used to categorize the operating states reasonably. The following time bases are needed to calculate the key performance indicators.

2.5.1.4.1. Time Base: Setup

The “Setup” time base contains the operating states of a workplace or operation that influence the duration of the setup time.

Regarding the setup times, it should be noted that these should be generally prevented. Therefore they are divided into internal and external setup times.

  • Internal setup times mean, that the work has to be stopped/halted in order to e.g. change the tool.
  • External setup times mean that that processing does not have to be interrupted at the workplace.

Note

Only internal setup times have an influence on the availability and thus on the OEE of a workplace.

2.5.1.4.2. Time Base: Production

The time base “Production” is assigned to the operating states of a workplace or process respectively, that contribute to the duration of their production time.

2.5.1.4.3. Time Base: Scheduled Shift Time

The time base “Scheduled Shift Time” is assigned to the operating states of a workplace or process respectively, that contribute to the duration of their scheduled shift time.

The Scheduled Shift Time includes the shifts without shift breaks and without the planned maintenance times. Non-work shifts (such as weekends, public holidays, …) are not included.

Example

During processing phase, an additional setup operation of a scheduled tool change occurred. With it, the recorded duration of the operating state “setup” is longer than that of the operation phase “setup”. The time bases are visually clarified once again in figure 2.5.6.

../_images/time-bases.svg

2.5.6 Overview of the time bases

2.5.1.5. Correlation between Occupancy Time and Sum of Execution Times

The occupancy time of a workplace is the sum of the execution times of all operations while these were logged in at the workplace.

Example:

An operation was started on a workplace at 6:00 o’clock at first, was there halted at 17:00 o’clock and immediately continued at a different workplace.

It was finally finished at 6:00 o’clock the following day.

In addition, there are two shift breaks from 12:00 (noon) until 14:00 and from 20:00 o’clock until 22:00 o’clock (4 hours overall).

There is no scheduled maintenace.

The period under observation is 24 hours. Therefore the scheduled shift time is calculated from period under observation minus scheduled breaks minus scheduled maintenace.

\[\begin{split}Scheduled\ Operating\ Time &= Period\ under\ Observation\\ &- Scheduled\ Breaks\\ &- Scheduled\ Maintenance\end{split}\]
../_images/occupancyTime.svg

This results in the following times for the operation:

Processing time: 16 h
Setup time: 4 h
Execution time: 20 h
Production time: 16 h
Setup phase duration: 16 h
Processing phase duration: 4 h

This results in the following times for workplace 1:

Scheduled operating time: 20 h
Processing time: 6 h
Setup time: 3 h
Execution time: 9 h
Production time: 6 h

From this follows:

\[Occupancy\ Rate=\frac{Occupancy\ Time}{Scheduled\ Operating\ Time}=\frac{9}{20}=45 \%\]
\[Setup\ Reduction=\frac{Processing\ Time}{Occupancy\ Time}=\frac{6}{9}=\frac{2}{3}\]

This results in the following times for workplace 2:

Scheduled operating time: 20 h
Processing time: 10 h
Setup time: 1 h
Execution time: 11 h
Production time: 10 h

From this follows:

\[Occupancy\ Rate=\frac{Occupancy\ Time}{Scheduled\ Operating\ Time}=\frac{11}{20}=55 \%\]
\[Setup\ Reduction=\frac{Processing\ Time}{Occupancy\ Time}=\frac{10}{11}\]

2.5.2. The Digital Image in FORCE Bridge API

2.5.2.1. Operating States and the Workplace Status

Operating states are defined in order to determine what the current state of a workplace is. Possible operating states of a workplace are for example production, machine malfunction, tool damage, …

Each operating state has a workplace status to determine if a workplace is currently working or is stopped. They are defined as follows.

Workplace state Definition
DOWNTIME The workplace stands still.
PRODUCTION The workplace is producing.

Hint

The operating states can be configured freely in the Iot platform. It means each workplace can have individually adjusted operating states.

2.5.2.1.1. Operation phases

Between the release of an operation and its completion with final confirmation to the ERP system, the following phases occur in production, which are either reported at the Shop Floor Terminal or updated automatically by the IoT platform:

Phase Description
RELEASED The production order an operation belongs to has been released by the ERP system, but the operation has not yet been started or planned in detail.
DISPATCHED The operation has been dispatched to a specific workplace
SETUP The operation has been logged on to a workplace and this workplace is set up for processing the operation.
PROCESSING The operation is being processed.
INTERRUPTED The operation was interrupted.
COMPLETED The operation was completed.
CLOSED The operation was completed and a final confirmation was sent to the ERP system.

2.5.3. Tutorials

2.5.3.1. Comparing Target and Actual Values

Compare the target setup time of an operations with both the setup phase duration from the resource operations/{operationId}/recordedOperationPhases and the setup time from operations/{operationId}/operatingStateSummary Determine if the target value of the setup time was abided or overstepped.

Solution: show/hide

Java

Todo

Not yet implemented.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
        IOperationClient operationClient = api.getOperationClient();

        GetOperationsRequest operationsRequest = new GetOperationsRequest();
        operationsRequest
            .embed()
            .specification(true);
        Page<OperationResponse> operations = operationClient.getOperations(operationsRequest);

        // Retrieve only one operation.
        OperationResponse operationResponse = operations
            .getResponse()
            .getElements()
            .get(0);

        String operationId = operationResponse
            .getProperties()
            .getId();

        OperationSpecificationPropertiesWSModel embedded = operationResponse
            .getSpecification()
            .getEmbedded();
        long targetSetupTime = embedded.getTargetSetupTime() + embedded.getTargetTeardownTime();

        GetOperationOperatingStateSummaryRequest operatingStateSummaryRequest = new GetOperationOperatingStateSummaryRequest(operationId);
        OperationOperatingStateSummaryPage stateSummaryPage = operationClient.getOperatingStateSummary(operatingStateSummaryRequest);
        long actualSetupTime = stateSummaryPage
            .getResponse()
            .getProperties()
            .getSetupTime();

        GetOperationRecordedOperationPhasesRequest phasesRequest = new GetOperationRecordedOperationPhasesRequest(operationId);
        OperationRecordedOperationPhasePage operationPhasePage = operationClient.getRecordedOperationPhases(phasesRequest);

        OperationRecordedOperationPhasesResponse response = operationPhasePage.getResponse();
        long actualSetupPhaseDuration = response
            .getProperties()
            .getSetupPhaseDuration();

        if (actualSetupTime <= targetSetupTime) {
            System.out.println("The setup time is within its target value.");
        } else {
            System.out.println("Setup time has been overstepped!");
        }

        if (actualSetupPhaseDuration == targetSetupTime) {
            System.out.println("Target setup time and setup phase duration are identical!");
        } else {
            System.out.println("Target setup time and setup phase duration are NOT identical");
        }

/../_code/java/src/main/java/com/forcam/apps/ComparingTargetAndActualValues.java

2.5.3.2. Calculation of the Key Performance Indicators

2.5.3.2.1. Calculation of the Setup Time of a Workplace and an Operation

The setup time is calculated from the sum of all operating states that belong to the setup time base. The total is calculated for each workplace within the considered period.

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
        //        final GetOperatingStateSummaryRequest stateSummaryRequest = new GetOperatingStateSummaryRequest(mWorkplaceUUID); //FIXME inconsistent naming.
        //        final WorkplaceOperatingStateSummaryResponse stateSummaryResponse = mWorkplaceClient.getOperatingStateSummary(stateSummaryRequest);
        //        final long summarySetupTime = stateSummaryResponse
        //            .getProperties()
        //            .getSetupTime();
        //
        //        final GetWorkplaceRecordedOperatingStatesRequest operatingStatesRequest = new GetWorkplaceRecordedOperatingStatesRequest(mWorkplaceUUID);
        //        final RecordedOperatingStateCollectionResponse stateCollectionResponse = mWorkplaceClient.getRecordedOperatingStates(operatingStatesRequest);
        //
        //        long recordedSetupTime = 0L;
        //        for (OperatingStateRecordWSModel record : stateCollectionResponse
        //            .getProperties()
        //            .getElements()) {
        //            long duration = record
        //                .getTimePeriod()
        //                .getDuration(); //FIXME duration is not properly calculated because, if the setup is still in progress the end date does not get set!
        //            recordedSetupTime += duration;
        //        }

/../_code/java/src/test/java/com/forcam/durations/workplace/SetupTimeTestExecutable.java

The setup time can also be calculated for an operation. Note that if the operation was setup and processed at several workplaces, the setup times of all workplaces at which the operation was executed must be totaled.

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
        //        final GetOperationOperatingStateSummaryRequest stateSummaryRequest = new GetOperationOperatingStateSummaryRequest(mOperationUUID);
        //        final OperationOperatingStateSummaryResponse stateSummaryResponse = mOperationClient.getOperatingStateSummary(stateSummaryRequest);
        //        final long summarySetupTime = stateSummaryResponse
        //            .getProperties()
        //            .getSetupTime();
        //
        //        final GetOperationRecordedOperatingStatesRequest operatingStatesRequest = new GetOperationRecordedOperatingStatesRequest(mOperationUUID);
        //        final RecordedOperatingStateCollectionResponse stateCollectionResponse = mOperationClient.getRecordedOperatingStates(operatingStatesRequest);
        //
        //        final long recordedSetupTime = stateCollectionResponse
        //            .getProperties()
        //            .getElements()
        //            .stream()
        //            .mapToLong(record -> record
        //                .getTimePeriod()
        //                .getDuration())
        //            .sum();

/../_code/java/src/test/java/com/forcam/durations/operation/SetupTimeTestExecutable.java

2.5.3.2.2. Calculation of the Execution Time of an Operation

The execution time is the sum of the durations of all setup phases and processing phases of the operations.

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
        //        final GetOperationRecordedOperationPhasesRequest operationPhasesRequest = new GetOperationRecordedOperationPhasesRequest(mOperationUUID);
        //        final OperationRecordedOperationPhasesResponse recordedOperationPhasesResponse = mOperationClient.getRecordedOperationPhases(operationPhasesRequest);
        //
        //        final long executionTime = recordedOperationPhasesResponse
        //            .getProperties()
        //            .getExecutionTime();
        //
        //        final long setupPhaseDuration = recordedOperationPhasesResponse
        //            .getProperties()
        //            .getSetupPhaseDuration();
        //        final long processingPhaseDuration = recordedOperationPhasesResponse
        //            .getProperties()
        //            .getProcessingPhaseDuration();
        //
        //        final long actualExecutionTime = processingPhaseDuration + setupPhaseDuration;

/../_code/java/src/test/java/com/forcam/durations/operation/ExecutionTimeTestExecutable.java

2.5.3.2.3. Calculation of the Processing Time of an Operation

The processing time of an operation is the execution time minus the setup times.

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
        //        final GetOperationOperatingStateSummaryRequest stateSummaryRequest = new GetOperationOperatingStateSummaryRequest(mOperationUUID);
        //        final OperationOperatingStateSummaryResponse stateSummaryResponse = mOperationClient.getOperatingStateSummary(stateSummaryRequest);
        //        final OperatingStateSummaryPropertiesWSModel properties = stateSummaryResponse.getProperties();
        //
        //        final long summaryProcessingTime = properties.getProcessingTime();
        //
        //        final long executionTime = properties.getExecutionTime();
        //        final long setupTime = properties.getSetupTime();
        //
        //        final long actualProcessingTime = executionTime - setupTime;

/../_code/java/src/test/java/com/forcam/durations/operation/ProcessingTimeTestExecutable.java

2.5.3.2.4. Calculation of the Occupancy Time of a Workplace

The occupancy time of a workplace is calculated from the total of all execution times of all operations that were executed at this workplace within the considered period.

Todo

Implement using workplaces/{workplaceId}/recordedOperationPhases

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
        //        final GetWorkplaceRecordedOperatingStatesRequest operatingStatesRequest = new GetWorkplaceRecordedOperatingStatesRequest(mWorkplaceUUID);
        //        final RecordedOperatingStateCollectionResponse operatingStateCollectionResponse = mWorkplaceClient.getRecordedOperatingStates(operatingStatesRequest);
        //
        //        final WorkplaceOperatingStateSummaryResponse operatingStateSummaryResponse = mWorkplaceClient.getOperatingStateSummary(new GetOperatingStateSummaryRequest(
        //            mWorkplaceUUID));
        //
        //        final Long expectedOccupancyTime = operatingStateSummaryResponse
        //            .getProperties()
        //            .getOccupancyTime();
        //
        //        //TODO: get all operations that have been executed at this workplace within a specified time period.
        //        //FIXME: the above mentioned action cannot be easily achieved, because there is no such interface.
        //        fail(); //TODO remove me once implemented.
        //
        //        final Long actualOccupancyTime = 0L;

/../_code/java/src/test/java/com/forcam/durations/workplace/OccupancyTimeTestExecutable.java

2.5.3.2.5. Comparison of the originally planned operating times with the times subsequently declared as scheduled operating times

Note

The duration of the scheduled operating time may differ from the originally scheduled operating time, for example, because a previously unplanned business meeting took place that is not intended to have any effect on the availability of the workplaces and is therefore not assigned to the time base “scheduled operating time”.

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
        final WorkplaceOperatingStateSummaryPage stateSummaryResponse = mWorkplaceClient.getOperatingStateSummary(new GetOperatingStateSummaryRequest(
            mWorkplaceUUID));
        final Long scheduledOperatingTime = stateSummaryResponse
            .getResponse()
            .getProperties()
            .getScheduledOperatingTime();

        final WorkplaceScheduledOperatingTimesCollectionPage operatingTimesCollectionResponse = mWorkplaceClient.getScheduledOperatingTimes(new GetWorkplaceScheduledTimesRequest(
            mWorkplaceUUID));
        //FIXME throws 'Unexpected internal server error'
        long originallyScheduledOperatingTime = 0L;
        for (TimePeriodWSModel timePeriodWSModel : operatingTimesCollectionResponse
            .getResponse()
            .getProperties()
            .getElements()) {
            long duration = timePeriodWSModel.getDuration();
            originallyScheduledOperatingTime += duration;
        }

/../_code/java/src/test/java/com/forcam/durations/workplace/ScheduledOperatingTimeTestExecutable.java

2.5.3.3. Querying the Key Performance Indicators

FORCE Bridge already provides all required KPIs for the OEE of an operation. Those indicators can be retrieved as shown in the following examples:

Operation

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
            Page<OperationResponse> operationResponsePage = operationClient.getOperations(new GetOperationsRequest());

            operationResponsePage
                .streamForward()
                .map(OperationResponse::getProperties)
                .map(OperationPropertiesWSModel::getId)
                .forEach(operationId -> {

                    GetOperationOperatingStateSummaryRequest operatingStateSummaryRequest = new GetOperationOperatingStateSummaryRequest(operationId);
                    GetOperationQuantitySummaryRequest quantitySummaryRequest = new GetOperationQuantitySummaryRequest(operationId);

                    // Retrieving the operating state summary and quantity summary of an operation
                    try {
                        OperationOperatingStateSummaryPage operatingStateSummaryResponse = operationClient.getOperatingStateSummary(operatingStateSummaryRequest);
                        OperatingQuantitySummaryCollectionPage quantitySummaryCollectionResponse = operationClient.getQuantitySummary(quantitySummaryRequest);

                        final double availability = operatingStateSummaryResponse
                            .getResponse()
                            .getProperties()
                            .getProcessAvailability();

                        final double performance = quantitySummaryCollectionResponse
                            .getResponse()
                            .getProperties()
                            .getPerformance();

                        final double qualityRate = quantitySummaryCollectionResponse
                            .getResponse()
                            .getProperties()
                            .getQualityRate();

                        double overalEquipmentEfficency = availability * performance * qualityRate;

                    } catch (ForceAPIException e) {
                        e.printStackTrace();
                    }
                });

/../_code/java/src/main/java/com/forcam/apps/OperationSummaries.java

Workplace

Solution: show/hide

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
            final Page<WorkplaceResponse> workplaceResponsePage = workplaceClient.getWorkplaces(new GetWorkplacesRequest());

            workplaceResponsePage
                .streamForward()
                .map(WorkplaceResponse::getProperties)
                .map(WorkplacePropertiesWSModel::getId)
                .forEach(workplaceId -> {
                    final GetOperatingStateSummaryRequest operatingStateSummaryRequest = new GetOperatingStateSummaryRequest(workplaceId);
                    final GetWorkplaceQuantitySummaryRequest workplaceQuantitySummaryRequest = new GetWorkplaceQuantitySummaryRequest(workplaceId);

                    // Retrieving the operating state summary and quantity summary of a workplace
                    try {
                        final WorkplaceOperatingStateSummaryPage operatingStateSummaryResponse = workplaceClient.getOperatingStateSummary(
                            operatingStateSummaryRequest);

                        final WorkplaceQuantitySummaryCollectionPage quantitySummaryCollectionResponse = workplaceClient.getQuantitySummary(
                            workplaceQuantitySummaryRequest);
                    } catch (ForceAPIException e) {
                        LOGGER.error(e.getMessage());
                    }
                });

/../_code/java/src/main/java/com/forcam/apps/WorkplaceSummaries.java

Calculating the Overall Equipment Efficiency

Todo

Implement example calculating the OEE for both operation and workplace!

Footnotes

[1]Capital commitment costs are costs for fixed and current assets tied up in the company, which therefore cannot be used profitably elsewhere.