<?php
/**
 * Copyright (c) 2011, 2018 Eclipse Foundation.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * Contributors:
 *   Christopher Guindon (Eclipse Foundation) - Initial implementation
 *   Mike Milinkovich (Eclipse Foundation)
 *   Eric Poirier (Eclipse Foundation)
 *
 * SPDX-License-Identifier: EPL-2.0
 */
?>
<div id="maincontent">
  <div id="midcolumn">
    <h2>Charter</h2>
    <h4>January 1, 2019</h4>
    <h3>Introduction to IoT</h3>
    <p>Many industry domains such as smart metering, energy management, inventory control, fleet
      management, healthcare, and security have an inherent need for technology, products and
      solutions that interface physical world events from sensors, actuators and other types of
      devices, with Enterprise and Web applications. IoT technology enables these domains,
      supporting not only the devices and device networks, but also integration with a wide range of
      enterprise middleware and Web programming models.</p>
    <p>An IoT solution is generally composed of:</p>
    <ul>
      <li />
      <p>Physical assets and devices (sensors, actuators, controllers, LCD display, etc.)</p>
      <li />
      <p>IoT Gateway to manage assets and server communication. These include communication modules
        with wireless connectivity (GPRS, 3G, WiFi, Wimax, etc.)</p>
      <li />
      <p>Monitoring or other domain-specific server infrastructure, with which gateways,
        communication modules and assets in the field communicate.</p>
    </ul>
    <p>Usually, the IoT server infrastructure has to be interfaced with other information systems.
      Examples are telecom operators (e.g. SIM card subscription management or billing), and
      enterprise systems (e.g. cargo tracking and vehicle maintenance). An IoT server also needs to
      expose interfaces allowing third-party applications to access collected data, accept and
      process control functions, and to perform management and provisioning operations on modules
      and assets in the field.</p>
    <h3>Concerns Addressed by the Eclipse IoT Working Group</h3>
    <p>The objective of the IoT Working group is to encourage, develop, and promote open source
      solutions that can be used to overcome market inhibitors found in most IoT ecosystems, such
      as:</p>
    <ul>
      <li />
      <p>Fragmented market: wide range of embedded platforms, programming models, connection types,
        communication protocols.</p>
      <li />
      <p>No widely accepted IoT architectural guidelines.</p>
      <li />
      <p>Limited choices in accepted open, standard communication protocols to deal with IoT
        requirements and constraints such as; power, CPU, cost, connection availability, and
        bandwidth.</p>
      <li />
      <p>Unnecessarily tight coupling between applications, systems and communication interfaces.</p>
      <li />
      <p>Lack of Open Source IoT development solutions (development environment, development boards)</p>
      <li />
      <p>Lack of integration with open source Enterprise and Web development tools and environments.</p>
      <li />
      <p>Monolithic applications and lack of reusable software components (e.g. drivers,
        communication protocols)</p>
      <li />
      <p>High barrier of entry to developers who need to integrate IoT, Enterprise, and Web
        application systems. e.g. hardware and infrastructure costs, no relevant software
        engineering environment, proprietary interfaces, numerous and complex programming models.</p>
      <li />
      <p>Inadequate open source support for IoT-oriented middleware, including IoT integration with
        established middleware solutions.</p>
    </ul>
    <h3>Purpose and scope of the Working Group</h3>
    <p>The Eclipse Foundation is a place where people collaborate to deliver exemplary, extensible
      tools, frameworks and runtime components. The IoT Working Group aims at defining an open
      development environment and key runtimes for IoT solutions that will enable open solutions.
      The IoT Industry Working Group will address the following topics:</p>
    <ul>
      <li />
      <p>Development tools, including simulators/emulators</p>
      <li />
      <p>Reference architecture and programming model</p>
      <li />
      <p>Effective decoupling between applications, systems and communication interfaces</p>
      <li />
      <p>Open and standard communication protocols</p>
      <li />
      <p>Open and standard APIs (embedded &amp; server).</p>
      <li />
      <p>Frameworks and services for IoT gateways and IoT Cloud platforms</p>
      <li />
      <p>Communicate and evangelize the solutions produced by the IoT WG</p>
    </ul>
    <h3>Connections with other standards and industry groups</h3>
    <p>The IoT Industry Working Group will also work in collaboration with other IoT Industry Groups
      and Standards organizations in order to avoid fragmentation and duplication of effort,
      including groups like oneM2M, OASIS, OMA, IETF, IIC and others.</p>
    <h3>Work areas</h3>
    <p>The IoT Industry Working Group will work on the following topics:</p>
    <h4>IoT software components</h4>
    <p>The IoT Industry Working Group will identify and specify software components needed to
      efficiently develop IoT solutions (communication services, industrial protocol
      implementations).</p>
    <h4>IoT use cases</h4>
    <p>The IoT working group will identify and maintain common use cases that represent typical IoT
      environments. The goal is to highlight the capabilities and requirements that need to be
      standardized to ensure open interoperability, portability, reusability, and ease of
      integration.</p>
    <h4>Reference architecture</h4>
    <p>The IoT Industry Working Group will work on the definition of a set of architectural
      guidelines (&quot;IoT Blueprints&quot;) for IoT solutions, derived from the identified use
      cases.</p>
    <h4>IoT tooling</h4>
    <p>The IoT Industry Working Group will work on the requirements and specifications to support
      the integration of IoT tooling, with relevant Eclipse tooling that is used by developers of
      the Enterprise and Web applications who integrate with IoT embedded and server applications.</p>
    <h4>Open IoT Specifications and Standards</h4>
    <p>The IoT Industry Working Group will identify, reference and provide implementations of open
      specifications and standards that support the development and deployment of IoT solutions. The
      Working Group may also be responsible for defining compatibility test suites for IoT
      specifications and in some cases creating and maintaining an IoT specification.</p>
    <h4>APIs</h4>
    <p>The IoT Industry Working Group will work on the definition of Application Programming
      Interfaces both on the embedded and on the server-side in order to help increase the
      modularity, extensibility and effective decoupling of IoT solutions.</p>
    <h4>IoT software components repository</h4>
    <p>The IoT Industry Working Group will define the technical requirements for allowing the
      delivery of IoT-oriented software components (industrial protocol drivers, embedded devices
      models, code generators, etc.) via the Eclipse Marketplace.</p>
    <h4>IoT &quot;hacker place&quot; and sandbox</h4>
    <p>Because IoT development requires actual hardware, and likely prepaid airtime, in order to
      perform end-to-end experiments, the IoT Working Group may work on the definition of a
      so-called &quot;hacker place&quot;, which will take the form of a website easing the ordering
      of IoT developer kits (development boards, wireless sensors, 3G modems, etc.). The IoT Working
      Group will work together with the Eclipse Foundation and hardware providers to propose
      discounts on developer kits, airtime, etc.</p>
    <p>Developing and testing IoT integration with Enterprise and Web applications requires access
      to middleware, monitoring servers, enterprise servers and various Web application interfaces.
      The IoT Working Group will work to define and promote the availability of a
      &quot;sandbox&quot; of accessible server environments for the development, testing and
      integration of IoT systems with Enterprise, Web, and cloud-based software to developers using
      Eclipse IoT tools and runtimes.</p>
    <h4>Communication and Evangelism</h4>
    <p>The IoT Industry Working Group will work to communicate and evangelize the solutions
      developed by the IoT WG. The activities may include joint press releases, joint trade show
      participation, publishing white papers and/or preparing other content that communicates the
      vision and solutions of the WG.</p>
    <h3>Steering Committee Roles and Responsibilities</h3>
    <p>The Eclipse IoT Working Group will have a Steering Committee to help guide the strategy and
      operation of the working group. &nbsp;The Steering Committee will make decisions based on a
      simple majority vote of the committee members.</p>
    <p>The roles and responsibilities of the Steering Committee include:</p>
    <ul>
      <li />
      <p>Provide guidance and approval of the annual Eclipse IoT Working Group strategy, positioning
        and roadmap.</p>
      <li />
      <p>Approve the technical architecture and composition of any Eclipse IoT solution stack that
        is based on the overall roadmap.</p>
      <li />
      <p>Coordination and recruitment of resources to accelerate key project development and
        integration of the Eclipse IoT roadmap.</p>
      <li />
      <p>Coordinate Eclipse IoT Working Group membership recruitment</p>
      <li />
      <p>Approve Eclipse IoT Testbeds.</p>
      <li />
      <p>Approval of any Eclipse IoT documents, include technical architectures, blueprints, white
        papers&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</p>
      <li />
      <p>Elect a chair of the Eclipse IoT Working Group</p>
      <li />
      <p>Define the Eclipse IoT working group budget and annual fees.</p>
      <li />
      <p>Establish sub-committees of the Eclipse IoT Working Group, ex. Architecture and Technical
        Committee</p>
    </ul>
    <h3>Participation Guidelines - Membership</h3>
    <p>With the exception of Guest members as described below, an entity must be at least a
      Solutions Member of the Eclipse Foundation, have executed the Eclipse IoT Participation
      Agreement, and adhere to the requirements set forth in this Charter to participate.</p>
    <p>There are three classes of Eclipse IoT working group membership - Strategic, Participant, and
      Guest. Each of these classes is described in detail below.</p>
    <p>The participation fees associated with each of these membership classes is shown in the
      tables in Schedule A. These are annual fees, and are established by the Eclipse IoT Steering
      Committee, and will be updated in this charter document accordingly.</p>
    <p>The fees associated with membership in the Eclipse Foundation are separate from any working
      group membership fees, and are decided as described in the Eclipse Bylaws and detailed in the
      Eclipse Membership Agreement.</p>
    <h4>Strategic members</h4>
    <p>Strategic members are required to:</p>
    <ul>
      <li>
        <p>Be a Strategic, Enterprise or Solutions member of the Eclipse Foundation.</p>
      </li>
      <li>
        <p>Lead at least one Eclipse IoT project and contribute at least 4 FTE working on Eclipse
          IoT projects or Eclipse IoT Working Group activities. The activities can include 1)
          committers working on Eclipse open source projects that support the IoT roadmap, 2)
          creation of roadmaps and technical documents (including, for example, architectures,
          blueprints and best practices) supporting the WG work, 3) evangelism and community
          development for the WG and 4) other activities agreed to by the Steering committee.</p>
      </li>
      <li>
        <p>Strategic members may also be invited to join the Steering Committee if they demonstrate
          contributions to at least one Eclipse IoT project, and be approved by a simple majority of
          the existing Strategic members.</p>
      </li>
      <li>
        <p>Regularly participate in Working Group meetings and provide timely feedback on Working
          Group documents.</p>
      </li>
      <li>
        <p>Provide executive-level representation at quarterly Steering Committee meetings.</p>
      </li>
      <li>
        <p>Provide ongoing marketing and community development support to the Eclipse IoT community.</p>
      </li>
    </ul>
    <h4>Participant Members</h4>
    <p>Participant Members are required to:</p>
    <ul>
      <li>
        <p>Be an Eclipse Foundation member at the Strategic, Enterprise or Solution level.</p>
      </li>
      <li>
        <p>Regularly participate in the Working Group meetings.</p>
      </li>
    </ul>
    <p>Eclipse Foundation Associate Members may be invited by the Steering Committee to join and
      participate in the Working Group as Guest members.</p>
    <h3>Industry Working Group Process</h3>
    <p>
      The IoT Industry Working Group will follow the <a
        href="/org/workinggroups/industry_wg_process.php"
      >Eclipse Industry Working Group Process</a>.
    </p>
    <h3>Eclipse IoT Working Group Annual Participation Fees Schedule A</h3>
    <p>
      The following fees have been established by the Eclipse IoT Steering Committee.<br /> The
      following are the annual fees associated with each class of membership in the Eclipse IoT
      Working Group. &nbsp;All fees are in USD.
    </p>
    <p>The following requirements are included:</p>
    <ul>
      <li>
        <p>The fees for all classes of Eclipse IoT membership are $0 for calendar 2018.</p>
      </li>
      <li>
        <p>All members are required to execute the <a href="/org/workinggroups/documents/wgpa-eclipse-iot.pdf">Eclipse IoT Participation Agreement</a>.</p>
      </li>
    </ul>
    <h4>Eclipse IoT Strategic Member Annual Participation Fees</h4>
    <p>Steering Committee members are required to execute the <a href="/org/workinggroups/documents/wgpa-eclipse-iot.pdf">Eclipse IoT Participation Agreement</a>,
      and to begin paying the fees shown below effective January 1, 2019.</p>
    <table class="table table-stripped">
      <thead>
        <tr>
          <th>Corporate Revenue</th>
          <th>Annual Fees</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>
            <p>Annual Corporate Revenues greater than $250 million</p>
          </td>
          <td>
            <p>$50,000</p>
          </td>
        </tr>
        <tr>
          <td>
            <p>Annual Corporate Revenues greater than $100 million but less than or equal to $250
              million</p>
          </td>
          <td>
            <p>$30,000</p>
          </td>
        </tr>
        <tr>
          <td>
            <p>Annual Corporate Revenues greater than $50 million but less than or equal to $100
              million</p>
          </td>
          <td>
            <p>$15,000</p>
          </td>
        </tr>
        <tr>
          <td>
            <p>Annual Corporate Revenues greater than $10 million but less than or equal to $50
              million</p>
          </td>
          <td>
            <p>$10,000</p>
          </td>
        </tr>
        <tr>
          <td>
            <p>Annual Corporate Revenues less than or equal to $10 million</p>
          </td>
          <td>
            <p>$5,000</p>
          </td>
        </tr>
      </tbody>
    </table>
    <h4>Eclipse IoT Participant Member Annual Participation Fees</h4>
    <p>Participant Members pay no annual fees, but are required to execute the <a href=/org/workinggroups/documents/wgpa-eclipse-iot.pdf>Eclipse IoT Participation Agreement</a>.</p>
    <h4>Eclipse IoT Guest Members</h4>
    <p>Eclipse Foundation Associate Members may be invited by the Steering Committee to join and
      participate in the Working Group as Guest Members. Guest members pay no annual fees, but are
      required to execute the <a href="/org/workinggroups/documents/wgpa-eclipse-iot.pdf">Eclipse IoT Participation Agreement</a>.</p>
  </div>
</div>