<!DOCTYPE html>
<html data-n-head="" data-n-head-ssr>
  <head>
    <meta data-n-head="true" charset="utf-8"><meta data-n-head="true" content="width=device-width,initial-scale=1" name="viewport"><meta data-n-head="true" content="Eclipse Unide: Understand Industry devices" name="description" data-hid="description"><title data-n-head="true">Eclipse unide - Welcome</title><link href="/unide/favicon.ico" rel="icon" data-n-head="true" type="image/x-icon"><base href="/unide/"><link href="/unide/files/app.ce93f25ec8e6cdcb172e2896599524df.css" rel="stylesheet"><style data-vue-ssr-id="771fc815:0">body .sidebar div{margin-bottom:2em;font-size:.875em}body .sidebar div .subtitle{margin-bottom:.5rem}</style><style data-vue-ssr-id="d5b0f30e:0">@keyframes spinAround{0%{transform:rotate(0)}to{transform:rotate(359deg)}}header.nav-header{box-shadow:0 3px 5px 0 #ddd;margin-bottom:2em;padding-bottom:0}header.nav-header nav.navbar{display:flex;align-items:flex-end;border-bottom:5px solid #50237f}header.nav-header nav.navbar .navbar-burger{margin-left:0;height:auto}header.nav-header nav.navbar .navbar-burger span{height:2px;width:25px}header.nav-header nav.navbar .navbar-burger span:first-child{margin-top:-9px}header.nav-header nav.navbar .navbar-burger span:nth-child(3){margin-top:7px}header.nav-header nav.navbar .navbar-brand{align-self:stretch}header.nav-header nav.navbar .navbar-brand .navbar-item img{max-height:none;width:240px}header.nav-header nav.navbar .navbar-item,header.nav-header nav.navbar .navbar-link,header.nav-header nav.navbar .navbar-link a{color:#a7a7a7}header.nav-header nav.navbar .navbar-item.is-active,header.nav-header nav.navbar .navbar-item:hover,header.nav-header nav.navbar .navbar-link a.is-active,header.nav-header nav.navbar .navbar-link a:hover,header.nav-header nav.navbar .navbar-link.is-active,header.nav-header nav.navbar .navbar-link:hover{color:#78be20}header.nav-header nav.navbar .navbar-item:hover,header.nav-header nav.navbar .navbar-link a:hover,header.nav-header nav.navbar .navbar-link:hover{background-color:transparent;text-decoration:none;font-weight:700}header.nav-header nav.navbar .navbar-item .dropdown-trigger,header.nav-header nav.navbar .navbar-link .dropdown-trigger,header.nav-header nav.navbar .navbar-link a .dropdown-trigger{display:flex}@media screen and (min-width:1024px){.nav-header .container>.navbar .navbar-menu{margin-right:1rem}}@media screen and (max-width:1007px){header.nav-header nav.navbar{flex-direction:column;align-items:stretch}header.nav-header nav.navbar .navbar-menu{order:1;box-shadow:none}}@media screen and (min-width:1008px){nav.navbar .container .navbar-menu{height:40px}}</style><style data-vue-ssr-id="fc44206e:0">.recentPosts ul{list-style:none}</style><style data-vue-ssr-id="3dafb0ac:0">.blogArchives ul{list-style:none}</style><style data-vue-ssr-id="3fcbd066:0">@keyframes spinAround{0%{transform:rotate(0)}to{transform:rotate(359deg)}}.footer{font-size:.875em;border-top:1px solid #dbdbdb;padding-top:1.25rem;margin-top:1rem;padding:2rem 0}</style>
  </head>
  <body data-n-head="">
    <div id="__nuxt" data-server-rendered="true"><div class="nuxt-progress" style="width:0%;height:2px;background-color:#50237f;opacity:0"></div><div id="__layout"><div><header class="nav-header"><div class="container"><nav class="navbar"><div class="navbar-menu" id="navMenu"><div class="navbar-start"><a href="/unide/" class="navbar-item">
      Home
    </a><a href="/unide/proposal" class="navbar-item nuxt-link-exact-active is-active">
      Proposal
    </a><a href="/unide/specification" class="navbar-item">
      Specification 
    </a><a href="/unide/blog" class="navbar-item">
      Blog Archives
    </a><a href="/unide/faq" class="navbar-item">
      FAQ
    </a></div></div><div class="navbar-brand"><div class="navbar-burger burger"><span></span><span></span><span></span></div><a href="/unide/" class="navbar-item nuxt-link-active"><img src="logo.svg"></a></div></nav></div></header><div class="container"><div class="header clearfix"></div><div class="columns"><div class="proposal content column is-8"><h1>
  What is Unide?
  </h1><p>Noticeably in the recent years, there’s a continuous increase in demand, price pressure and complexity in manufacturing. Things need to move faster, be more flexible, and fulfill higher quality standards. Often, optimization in this regard is referred to as Production Performance Management (PPM). The basis for this optimization is information from the machines and devices related to a product, such as:<ul><li>Torque and angle for a tightening process<li>Influx / efflux of throttle plate test station<li>Energy consumption of spindles in a cutting process</ul><p>Nowadays, brand new machines and software are often shipped with powerful communication capabilities. For older machines, smaller factories and SMEs (Small and Medium Enterprises), it can be a challenge to catch up with the complex IT standards that come along. In fact, sometimes the hardware itself imposes limits.<p>Nevertheless, in a manufacturing environment, monitoring makes most sense if there are no blind spots. To achieve that, upgrading machines and software is one option, retrofitting another. For the latter, the hurdle should be as low as possible. Yet, there should be a few guidelines for a one-way exchange of the most necessary information (machine messages, measurements):<p>The structure of the data shall be:<ul><li>flexible enough to be carried via multiple protocols,<br>in order to not reinvent the wheel and leverage on existing technology<li>similar in each case,<br>to be able to use the same software to interpret the data<li>easily understandable,<br>so that implementation in a custom environment won’t be a hurdle<li>as simple as possible,<br>to not produce an opinionated framework<li>and yet containing enough information for the use cases,<br>to fulfill the functional requirements</ul><p>We decided the least common denominator of necessary information are the mandatory fields, common relevant information to be optional, and the possibility for further extension points through metadata.<h2>
    Industry benefits of Unide
  </h2><p>This open source project aims to make PPM affordable for smaller organizations by reducing cost and complexity of data communication. Through sample implementations of a simple information structure (Production Performance Management Protocol - PPMP) tailored to manufacturing environments, we want to encourage the community to use, share, and evolve this structure together.<p>PPMP has already been introduced as part of a PPM testbed at a medium-sized Bosch plant, working with many SMEs as partners and suppliers. Furthermore, this testbed aims to create an ecosystem which allows SMEs and larger companies to collaborate efficiently.<p>The PPMP takes an important role by ensuring interoperability between different types of devices and software. It is designed to gather and aggregate machine and sensor data from different devices. It focuses on defining the JSON payload which can be transferred via a variety of transports (REST, AMQP, MQTT). The primary goals of PPMP are:<ol><li>Integrating devices (across domains; e.g. manufacturing or energy) for data aggregation and gathering purposes<li>Providing a very lightweight and easy-to-use solution for small and medium-sized enterprises (SMEs)</ol><h1>
    Scope
  </h1><p>The Eclipse Unide project publishes the current version of Production Performance Management Protocol (PPMP) and develops simple server/client implementations. The implementations store the payloads in a database and displays them through a simple user interface. Everyone can then use these samples for their custom condition monitoring applications.<p>The project will contain:<p><em>PPMP Specification:</em><ul><li>Machine message and measurement interfaces<li>JSON based<li>Versioned</ul><p><em>Client:</em><ul><li>Chrome / nw.js App<li>For Industry Machines and Devices<li>Node.js/Python client running on Raspberry Pi</ul><p><em>Server:</em><ul><li>(REST) Server including persistence and simple data visualization<li>Multiple examples for different technologies</ul><h1>
    Description
  </h1><p>Eclipse Unide provides a lightweight Production Performance Management Protocol (PPMP) server-client implementations (using JSON, REST and other). The core of the protocol are two interface definitions:<ul><li>PPMP Measurement Interface: This is a public REST API with the purpose of receiving time series and machine data.<li>PPMP Messages Interface: This is a public REST API with the purpose of receiving machine messages.</ul><h1>
   Why Here?
  </h1><p>The PPMP extends the existing Eclipse IoT world by providing an easy and lightweight format for gathering data from industry sensors and machines, focusing on normalizing time series and alert messages. It can be transported by protocols like REST, AMQP, MQTT. As PPMP, these technologies do also not require complex and expensive middleware nor do their systems cause additional license fees. Eclipse is an excellent platform for developing PPMP sample implementations and evolving the format hands-on with the community. In fact, it could even join forces with existing Eclipse IoT projects like <a href="https://projects.eclipse.org/projects/iot.hono" target="_blank" rel="external">Hono</a>, <a href="https://www.eclipse.org/paho/" target="_blank" rel="external">Paho</a> or <a href="https://www.eclipse.org/kura/" target="_blank" rel="external">Kura</a>.<h1>Interested Parties</h1><ul><li><a href="https://www.contact-software.com" target="_blank" rel="external">CONTACT Software GmbH</a><li><a href="http://www.balluff.com/" target="_blank" rel="external">Balluff GmbH</a><li><a href="http://sap.com/" target="_blank" rel="external">SAP</a>, Industry Standards & Open Source<li><a href="http://www.tcs.com/" target="_blank" rel="external">Tata Consultancy Services</a>, Internet of Things Group<li><a href="http://www.3ds.com/" target="_blank" rel="external">Dassault Systèmes</a><li><a href="http://www.cadis-engineering.de/" target="_blank" rel="external">CADIS Service GmbH</a><li><a href="http://www.egt.de/" target="_blank" rel="external">EGT AG</a><li><a href="http://www.klw.com/" target="_blank" rel="external">KLW Karl Lutz GmbH</a><li><a href="http://www.rampf-gruppe.de/" target="_blank" rel="external">RAMPF Machine Systems GmbH & Co. KG</a><li><a href="http://www.schmalz.com/" target="_blank" rel="external">J. Schmalz GmbH</a><li><a href="https://www.bosch-si.com/" target="_blank" rel="external">Bosch Software Innovations GmbH</a></ul></div><div class="sidebar column is-3 is-offset-1"><div class="recentPosts"><h4 class="subtitle is-5">
    Recent Posts
  </h4><ul><li><a href="/unide/blog/2018/9/4/Template-for-PPMP-transformation">
        PPMP Use Cases: Template for PPMP transformation
      </a><li><a href="/unide/blog/2018/3/26/Release-0.2.0">
        Unide 0.2.0 released
      </a><li><a href="/unide/blog/2018/2/13/grinding-machine-scenario">
        PPMP Use Cases: Unide and the Eclipse Production Performance Management Testbed
      </a><li><a href="/unide/blog/2018/2/11/Transform-PPMP-with-camel">
        PPMP Use Cases: Simple Transformation with Apache Camel
      </a><li><a href="/unide/blog/2018/1/26/New-website">
        Updated Website
      </a></ul></div><div class="blogArchives"><h4 class="subtitle is-5">
    Blog Archives 
  </h4><ul><li><a href="/unide/blog/2018/9">
        October 2018
      </a>
      (1)
    <li><a href="/unide/blog/2018/3">
        April 2018
      </a>
      (1)
    <li><a href="/unide/blog/2018/2">
        March 2018
      </a>
      (2)
    <li><a href="/unide/blog/2018/1">
        February 2018
      </a>
      (1)
    <li><a href="/unide/blog/2017/10">
        November 2017
      </a>
      (2)
    <li><a href="/unide/blog/2017/6">
        July 2017
      </a>
      (2)
    <li><a href="/unide/blog/2017/3">
        April 2017
      </a>
      (1)
    <li><a href="/unide/blog/2016/9">
        October 2016
      </a>
      (4)
    </ul></div></div></div></div><footer class="footer"><div class="container"><div class="columns is-mobile is-multiline is-centered"><div class="column is-narrow"><a href="http://www.eclipse.org">Eclipse Foundation</a></div><div class="column is-narrow"><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></div><div class="column is-narrow"><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></div><div class="column is-narrow"><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></div><div class="column is-narrow"><a href="https://eclipse.org/security/">Security reports</a></div><div class="column is-narrow"><a href="http://www.eclipse.org/legal/">Legal</a></div></div></div></footer></div></div></div><script type="text/javascript">window.__NUXT__={layout:"sidebar",data:[{}],error:null,state:{},serverRendered:!0}</script><script defer src="/unide/files/manifest.743e36ec1ba98716cc6a.js"></script><script defer src="/unide/files/layouts_sidebar.d45435715b520199379d.js"></script><script defer src="/unide/files/pages_proposal.60a77f13238c99a592be.js"></script><script defer src="/unide/files/vendor.3960437a749191406982.js"></script><script defer src="/unide/files/app.45b9891348f7e815e8b8.js"></script>
  

