<!doctype html>
<html data-n-head-ssr data-n-head="">
  <head data-n-head="">
    <title data-n-head="true">Eclipse unide - Protocol Version 3 release candidate</title><meta data-n-head="true" charset="utf-8"><meta data-n-head="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-n-head="true" data-hid="description" name="description" content="Eclipse Unide: Understand Industry devices"><link data-n-head="true" rel="icon" type="image/x-icon" href="/unide/favicon.ico"><base href="/unide/"><link rel="stylesheet" href="/unide/files/aacbf5835f7143d93ae2.css"><link rel="stylesheet" href="/unide/files/08ee945502042ce842dc.css">
  </head>
  <body data-n-head="">
    <div data-server-rendered="true" id="__nuxt"><!----><div id="__layout"><div><header class="nav-header"><div class="container"><nav class="navbar"><div id="navMenu" class="navbar-menu"><div class="navbar-start"><a href="/unide/" class="navbar-item">
      Home
    </a> <a href="/unide/proposal" class="navbar-item">
      Proposal
    </a> <a href="/unide/specification" class="navbar-item">
      Specification
    </a> <a href="/unide/blog" class="navbar-item is-active">
      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="article column is-8"><h1 class="title is-3">
    Protocol Version 3 release candidate
  </h1> <h2 class="subtitle is-6"><i class="fa fa-calendar"></i>  
    03/01/19
  </h2> <div class="content"><div><p>After a long discussion phase, the Production Performance Management Protocol version 3 is finally linked on the specification page. Special thanks to <a href="https://github.com/bgusach">bgusach</a>, <a href="https://github.com/bf-bryants">bf-bryants</a>, <a href="https://github.com/muelsen">muelsen</a> and <a href="https://github.com/alaendle">alaendle</a> for their contributions <a href="https://github.com/eclipse/unide/issues">via github issues</a>!</p>
<h1>The most important changes</h1>
<ul>
<li><code>context</code> section in <code>measurements</code><br>
The optional context section ccontains information on how to interpret the measurements. This includes
<ul>
<li>the field '<code>type</code>' (Number, String or Boolean value) indicates which format the <code>&lt;values></code> of a <code>series</code> have.</li>
<li>The <code>unit</code> key can be used to describe the unit of measurement. There are different understandings and standarizations for units ('C' stands for Coulomb, not Celsius), like <a href="https://en.wikipedia.org/wiki/International_System_of_Units">International System of Units</a>, <a href="https://tools.ietf.org/html/draft-ietf-core-senml-14#section-12.1">SenML</a>, <a href="https://www.iso.org/obp/ui/#iso:std:iso:80000:-1:ed-1:v1:en">ISO 80000-1:2009</a>, etc.. The <code>unit</code> key here is a string without further restriction. If that is needed, it can be specified via an URI in <code>namespace</code>.</li>
<li><code>namespace</code> may contain an URI to identify further detail on the values in this measurement section. This can be a description of units, lengths or naming conventions for measurement points, but also a reference to a semantic model.</li>
</ul>
</li>
<li><code>series</code> can contain other than numeric measurements<br>
if <code>context.type</code> contains any of 'BASE64', 'BOOLEAN', 'NUMBER', 'STRING', 'REF' or 'OTHER', the corresponding measurement in <code>series</code> are represented in this type ('REF', 'OTHER' and 'BASE64' are Strings). This way for example, even small base64 encoded binary data, as send from iolink devices, can be included. 'REF' could be used in multipart messages to reference to other sections or even external content.</li>
<li><code>mode</code> and <code>state</code> are introduced in <code>device</code> and replaces v2's <code>operationalMode</code>, which was found to not clearly diffentiate the functional mode and technical state.</li>
<li>A common <code>id</code> was used and replaces different spellings in <code>deviceID</code>, <code>partID</code>, <code>program.id</code>.</li>
<li><code>additionalData</code> in the various sections is used for any kind of not-specified data, that should be included in the telegram. Where v2's <code>metaData</code> had to be key/String pairs, <code>additionalData</code> can also be complex JSON objects.</li>
<li><code>time</code> field replaces the v2 <code>$_time</code> field, which is difficult to represent in some programming languages. Note that <code>time</code> is not an Integer anymore but a JSON number, to allow sub-millisecond values.</li>
<li>no more <code>shutoffValues</code> and <code>shutoffPhase</code><br>
<code>shutoffValues</code> can be expressed as specialValues with a meaningful <code>name</code>, <code>shutoffPhase</code> is the measurement with the latest timestamp <code>ts</code>.</li>
<li>a common definition.json schema is used for sections that are used in multiple telegrams. With the help of JSON schema 'anyOf', sections inherit and can extend from these base definitions.</li>
</ul>
<h1>Next steps</h1>
<p>The most recent updates and this post should finalize the v3 schema. Vetos with suggestions that find a consensus fairly soon after posting are stil accepted <a href="https://github.com/eclipse/unide/issues">via github issues</a>. Major changes and suggestions should rather be addressed to a v4.</p>
<p>The bindings and server should be updated to accept and validate v3 as well. After updating further dependencies, creating eclipse CQs and undergoing the release process, everything should be wrapped up in the unide release 0.3.0.</p>
</div></div> <div class="columns pageNav"><div class="column"><a href="/unide/blog/2018/9/4/Template-for-PPMP-transformation" class="button is-fullwidth"><span class="icon"><i class="fa fa-chevron-left"></i></span> <span>Use Cases: Template for transformation</span></a></div> <div class="column"><a href="/unide/blog/2019/11/26/Version-3-final" class="button is-fullwidth"><span>Protocol v3 final</span> <span class="icon"><i class="fa fa-chevron-right"></i></span></a></div></div></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/2019/11/26/Version-3-final">
        Protocol v3 final
      </a></li><li><a href="/unide/blog/2019/3/1/Version-3" class="nuxt-link-exact-active nuxt-link-active">
        Protocol Version 3 release candidate
      </a></li><li><a href="/unide/blog/2018/9/4/Template-for-PPMP-transformation">
        Use Cases: Template for transformation
      </a></li><li><a href="/unide/blog/2018/3/26/Release-0.2.0">
        Unide 0.2.0 released
      </a></li><li><a href="/unide/blog/2018/2/13/grinding-machine-scenario">
        Use Cases: Unide and the Eclipse Testbed
      </a></li></ul></div> <div class="blogArchives"><h4 class="subtitle is-5">
    Blog Archives
  </h4> <ul><li><a href="/unide/blog/2019/11">
        December 2019
      </a>
      (1)
    </li><li><a href="/unide/blog/2019/3" class="nuxt-link-active">
        April 2019
      </a>
      (1)
    </li><li><a href="/unide/blog/2018/9">
        October 2018
      </a>
      (1)
    </li><li><a href="/unide/blog/2018/3">
        April 2018
      </a>
      (1)
    </li><li><a href="/unide/blog/2018/2">
        March 2018
      </a>
      (2)
    </li><li><a href="/unide/blog/2018/1">
        February 2018
      </a>
      (1)
    </li><li><a href="/unide/blog/2017/10">
        November 2017
      </a>
      (2)
    </li><li><a href="/unide/blog/2017/6">
        July 2017
      </a>
      (2)
    </li><li><a href="/unide/blog/2017/3">
        April 2017
      </a>
      (1)
    </li><li><a href="/unide/blog/2016/9">
        October 2016
      </a>
      (4)
    </li></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>window.__NUXT__={layout:"sidebar",data:[{post:{name:"Version-3",content:"<p>After a long discussion phase, the Production Performance Management Protocol version 3 is finally linked on the specification page. Special thanks to <a href=\"https://github.com/bgusach\">bgusach</a>, <a href=\"https://github.com/bf-bryants\">bf-bryants</a>, <a href=\"https://github.com/muelsen\">muelsen</a> and <a href=\"https://github.com/alaendle\">alaendle</a> for their contributions <a href=\"https://github.com/eclipse/unide/issues\">via github issues</a>!</p>\n<h1>The most important changes</h1>\n<ul>\n<li><code>context</code> section in <code>measurements</code><br>\nThe optional context section ccontains information on how to interpret the measurements. This includes\n<ul>\n<li>the field '<code>type</code>' (Number, String or Boolean value) indicates which format the <code>&lt;values&gt;</code> of a <code>series</code> have.</li>\n<li>The <code>unit</code> key can be used to describe the unit of measurement. There are different understandings and standarizations for units ('C' stands for Coulomb, not Celsius), like <a href=\"https://en.wikipedia.org/wiki/International_System_of_Units\">International System of Units</a>, <a href=\"https://tools.ietf.org/html/draft-ietf-core-senml-14#section-12.1\">SenML</a>, <a href=\"https://www.iso.org/obp/ui/#iso:std:iso:80000:-1:ed-1:v1:en\">ISO 80000-1:2009</a>, etc.. The <code>unit</code> key here is a string without further restriction. If that is needed, it can be specified via an URI in <code>namespace</code>.</li>\n<li><code>namespace</code> may contain an URI to identify further detail on the values in this measurement section. This can be a description of units, lengths or naming conventions for measurement points, but also a reference to a semantic model.</li>\n</ul>\n</li>\n<li><code>series</code> can contain other than numeric measurements<br>\nif <code>context.type</code> contains any of 'BASE64', 'BOOLEAN', 'NUMBER', 'STRING', 'REF' or 'OTHER', the corresponding measurement in <code>series</code> are represented in this type ('REF', 'OTHER' and 'BASE64' are Strings). This way for example, even small base64 encoded binary data, as send from iolink devices, can be included. 'REF' could be used in multipart messages to reference to other sections or even external content.</li>\n<li><code>mode</code> and <code>state</code> are introduced in <code>device</code> and replaces v2's <code>operationalMode</code>, which was found to not clearly diffentiate the functional mode and technical state.</li>\n<li>A common <code>id</code> was used and replaces different spellings in <code>deviceID</code>, <code>partID</code>, <code>program.id</code>.</li>\n<li><code>additionalData</code> in the various sections is used for any kind of not-specified data, that should be included in the telegram. Where v2's <code>metaData</code> had to be key/String pairs, <code>additionalData</code> can also be complex JSON objects.</li>\n<li><code>time</code> field replaces the v2 <code>$_time</code> field, which is difficult to represent in some programming languages. Note that <code>time</code> is not an Integer anymore but a JSON number, to allow sub-millisecond values.</li>\n<li>no more <code>shutoffValues</code> and <code>shutoffPhase</code><br>\n<code>shutoffValues</code> can be expressed as specialValues with a meaningful <code>name</code>, <code>shutoffPhase</code> is the measurement with the latest timestamp <code>ts</code>.</li>\n<li>a common definition.json schema is used for sections that are used in multiple telegrams. With the help of JSON schema 'anyOf', sections inherit and can extend from these base definitions.</li>\n</ul>\n<h1>Next steps</h1>\n<p>The most recent updates and this post should finalize the v3 schema. Vetos with suggestions that find a consensus fairly soon after posting are stil accepted <a href=\"https://github.com/eclipse/unide/issues\">via github issues</a>. Major changes and suggestions should rather be addressed to a v4.</p>\n<p>The bindings and server should be updated to accept and validate v3 as well. After updating further dependencies, creating eclipse CQs and undergoing the release process, everything should be wrapped up in the unide release 0.3.0.</p>\n",url:"/blog/2019/3/1/Version-3",title:"Protocol Version 3 release candidate",date:new Date(15513984e5),tags:["v3"],prev:{url:"/blog/2018/9/4/Template-for-PPMP-transformation",title:"Use Cases: Template for transformation"},next:{url:"/blog/2019/11/26/Version-3-final",title:"Protocol v3 final"}}}],error:null,serverRendered:!0}</script><script src="/unide/files/a195a9468a7b0964153f.js" defer></script><script src="/unide/files/2918aa6661dd624eef70.js" defer></script><script src="/unide/files/c01c4654e10f48ab3d43.js" defer></script><script src="/unide/files/7267eda02aa7844877f4.js" defer></script>
  </body>
</html>
