+MIT License

+

+Copyright (c) 2019 The Mobility House

+

+Permission is hereby granted, free of charge, to any person obtaining a copy

+of this software and associated documentation files (the "Software"), to deal

+in the Software without restriction, including without limitation the rights

+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+copies of the Software, and to permit persons to whom the Software is

+furnished to do so, subject to the following conditions:

+

+The above copyright notice and this permission notice shall be included in all

+copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+SOFTWARE.

+recursive-exclude tests *

+recursive-include ocpp/v16/schemas *.json

+recursive-include ocpp/v20/schemas *.json

+.PHONY: help .check-pypi-envs .install-poetry update install docs tests build deploy

+

+.DEFAULT_GOAL := help

+

+export PATH := ${HOME}/.local/bin:$(PATH)

+

+IS_POETRY := $(shell pip freeze | grep "poetry==")

+

+CURRENT_VERSION := $(shell poetry version -s)

+

+help:

+	@echo "Please use 'make <target>', where <target> is one of"

+	@echo ""

+	@echo "  build                            builds the project .whl with poetry"

+	@echo "  deploy                           deploys the project using poetry (not recommended, only use if really needed)"

+	@echo "  help                             outputs this helper"

+	@echo "  install                          installs the dependencies in the env"

+	@echo "  release version=<sem. version>   bumps the project version to <sem. version>, using poetry;"

+	@echo "                                   Updates also docs/source/conf.py version;"

+	@echo "                                   If no version is provided, poetry outputs the current project version"

+	@echo "  test                             run all the tests and linting"

+	@echo "  update                           updates the dependencies in poetry.lock"

+	@echo ""

+	@echo "Check the Makefile to know exactly what each target is doing."

+

+

+.install-poetry:

+	@if [ -z ${IS_POETRY} ]; then pip install poetry; fi

+

+update: .install-poetry

+	poetry update

+

+install: .install-poetry

+	poetry install

+

+docs: .install-poetry

+	poetry run sphinx-build -b html docs/source docs/build

+

+format: .install-poetry

+	poetry run isort ocpp tests  && poetry run black ocpp tests

+

+tests: .install-poetry

+	poetry run black --check --diff ocpp tests

+	poetry run isort --check-only ocpp tests

+	poetry run flake8 ocpp tests

+	poetry run py.test -vvv --cov=ocpp --cov-report=term-missing tests/

+

+build: .install-poetry

+	poetry build

+

+release: .install-poetry

+	@echo "Please remember to update the CHANGELOG.md, before tagging the release"

+	@sed -i ".bkp" "s/release = '${CURRENT_VERSION}'/release = '${version}'/g" docs/source/conf.py

+	@poetry version ${version}

+

+deploy: update tests

+	poetry publish --build

+.. image:: https://github.com/mobilityhouse/ocpp/actions/workflows/pull-request.yml/badge.svg?style=svg

+   :target: https://github.com/mobilityhouse/ocpp/actions/workflows/pull-request.yml

+

+.. image:: https://img.shields.io/pypi/pyversions/ocpp.svg

+   :target: https://pypi.org/project/ocpp/

+

+.. image:: https://img.shields.io/readthedocs/ocpp.svg

+   :target: https://ocpp.readthedocs.io/en/latest/

+

+OCPP

+----

+

+Python package implementing the JSON version of the Open Charge Point Protocol

+(OCPP). Currently OCPP 1.6 (errata v4), OCPP 2.0 and OCPP 2.0.1 (Final Version)

+are supported.

+

+You can find the documentation on `rtd`_.

+

+Installation

+------------

+

+You can either the project install from Pypi:

+

+.. code-block:: bash

+

+   $ pip install ocpp

+

+Or clone the project and install it manually using:

+

+.. code-block:: bash

+

+   $ pip install .

+

+Quick start

+-----------

+

+Below you can find examples on how to create a simple OCPP 2.0 central system as

+well as an OCPP 2.0 charge point.

+

+.. note::

+

+   To run these examples the dependency websockets_ is required! Install it by running:

+

+   .. code-block:: bash

+

+      $ pip install websockets

+

+Central system

+~~~~~~~~~~~~~~

+

+The code snippet below creates a simple OCPP 2.0 central system which is able

+to handle BootNotification calls. You can find a detailed explanation of the

+code in the `Central System documentation`_.

+

+

+.. code-block:: python

+

+    import asyncio

+    import logging

+    import websockets

+    from datetime import datetime

+

+    from ocpp.routing import on

+    from ocpp.v201 import ChargePoint as cp

+    from ocpp.v201 import call_result

+    from ocpp.v201.enums import RegistrationStatusType

+

+    logging.basicConfig(level=logging.INFO)

+

+

+    class ChargePoint(cp):

+        @on('BootNotification')

+        async def on_boot_notification(self, charging_station, reason, **kwargs):

+            return call_result.BootNotificationPayload(

+                current_time=datetime.utcnow().isoformat(),

+                interval=10,

+                status=RegistrationStatusType.accepted

+            )

+

+

+    async def on_connect(websocket, path):

+        """ For every new charge point that connects, create a ChargePoint

+        instance and start listening for messages.

+        """

+        try:

+            requested_protocols = websocket.request_headers[

+                'Sec-WebSocket-Protocol']

+        except KeyError:

+            logging.info("Client hasn't requested any Subprotocol. "

+                     "Closing Connection")

+            return await websocket.close()

+

+        if websocket.subprotocol:

+            logging.info("Protocols Matched: %s", websocket.subprotocol)

+        else:

+            # In the websockets lib if no subprotocols are supported by the

+            # client and the server, it proceeds without a subprotocol,

+            # so we have to manually close the connection.

+            logging.warning('Protocols Mismatched | Expected Subprotocols: %s,'

+                            ' but client supports  %s | Closing connection',

+                            websocket.available_subprotocols,

+                            requested_protocols)

+            return await websocket.close()

+

+        charge_point_id = path.strip('/')

+        cp = ChargePoint(charge_point_id, websocket)

+

+        await cp.start()

+

+

+    async def main():

+        server = await websockets.serve(

+            on_connect,

+            '0.0.0.0',

+            9000,

+            subprotocols=['ocpp2.0.1']

+        )

+        logging.info("WebSocket Server Started")

+        await server.wait_closed()

+

+    if __name__ == '__main__':

+        asyncio.run(main())

+

+Charge point

+~~~~~~~~~~~~

+

+.. code-block:: python

+

+    import asyncio

+

+    from ocpp.v201.enums import RegistrationStatusType

+    import logging

+    import websockets

+

+    from ocpp.v201 import call

+    from ocpp.v201 import ChargePoint as cp

+

+    logging.basicConfig(level=logging.INFO)

+

+

+    class ChargePoint(cp):

+

+        async def send_boot_notification(self):

+            request = call.BootNotificationPayload(

+                charging_station={

+                    'model': 'Wallbox XYZ',

+                    'vendor_name': 'anewone'

+                },

+                reason="PowerUp"

+            )

+            response = await self.call(request)

+

+            if response.status == RegistrationStatusType.accepted:

+                print("Connected to central system.")

+

+

+    async def main():

+        async with websockets.connect(

+                'ws://localhost:9000/CP_1',

+                subprotocols=['ocpp2.0.1']

+        ) as ws:

+            cp = ChargePoint('CP_1', ws)

+

+            await asyncio.gather(cp.start(), cp.send_boot_notification())

+

+

+    if __name__ == '__main__':

+        asyncio.run(main())

+

+Debugging

+---------

+

+Python's default log level is `logging.WARNING`. As result most of the logs

+generated by this package are discarded. To see the log output of this package

+lower the log level to `logging.DEBUG`.

+

+.. code-block:: python

+

+  import logging

+  logging.basicConfig(level=logging.DEBUG)

+

+However, this approach defines the log level for the complete logging system.

+In other words: the log level of all dependencies is set to `logging.DEBUG`.

+

+To lower the logs for this package only use the following code:

+

+.. code-block:: python

+

+  import logging

+  logging.getLogger('ocpp').setLevel(level=logging.DEBUG)

+  logging.getLogger('ocpp').addHandler(logging.StreamHandler())

+

+License

+-------

+

+Except from the documents in `docs/v16` and `docs/v201` everything is licensed under MIT_.

+© `The Mobility House`_

+

+The documents in `docs/v16` and `docs/v201` are licensed under Creative Commons

+Attribution-NoDerivatives 4.0 International Public License.

+

+.. _Central System documentation: https://ocpp.readthedocs.io/en/latest/central_system.html

+.. _MIT: https://github.com/mobilityhouse/ocpp/blob/master/LICENSE

+.. _rtd: https://ocpp.readthedocs.io/en/latest/index.html

+.. _The Mobility House: https://www.mobilityhouse.com/int_en/

+.. _websockets: https://pypi.org/project/websockets/

+Getting started

+===============

+

+.. include:: ../../README.rst

+Central System

+==============

+

+The Open Charge Point Protocol defines two roles: the charge point (or the client) and the central

+server (or the server). The ocpp Python package can be used to model both sides of the connection.

+

+This document explains how to create a central system and how to model a charge

+point at server side. Most of the examples on this page use the `websockets`_

+library as implementation of the websockets layer. Note that package isn't

+required, other websocket implementations might work as well.

+

+

+Create a websocket server

+-------------------------

+

+The snippet below creates a very simple websocket server that listens at port 9000 for connections

+and that prints 'Charge point connected' for every new websocket connection made.

+

+.. code-block:: python

+

+   import asyncio

+   import websockets

+

+

+   async def on_connect(websocket, path):

+      await websocket.send('Connection made successfully.')

+      print(f'Charge point {path} connected')

+

+

+   async def main():

+      server = await websockets.serve(

+         on_connect,

+         '0.0.0.0',

+         9000,

+         subprotocols=['ocpp1.6']

+      )

+

+      await server.wait_closed()

+

+

+   if __name__ == '__main__':

+      asyncio.run(main())

+

+There are two things that requires a few words of explanation.

+

+* The `on_connect()` handler that is passed as a first argument to `websockets.serve()`_. This is

+  the handler that is executed on every new connection.

+

+  The handler is passed two arguments: an instance of `websockets.server.WebSocketServerProtocol`_

+  and the request URI. The request URI is used as identifier for the charge point that made the

+  connection. To quote a snippet from section 3.1.1 of the OCPP-J specification:

+

+	*"The charge point's connection URL contains the charge point identity

+	so that the Central System knows which charge point a Websocket connection

+	belongs to."*

+

+  The handler in this example sends a message to the client and prints a message to the console.

+

+

+* The `subprotocols` argument in `websockets.serve()` is used to configure the server that it

+  supports OCPP 1.6.

+

+After you've started the server you can connect a client to it by using the `websockets` interactive

+`client`_:

+

+

+.. code-block:: shell

+

+   $ python -m websockets ws://localhost:9000/test_charge_point

+   Connected to ws://localhost:9000/test_charge_point.

+   < Connection made successfully.

+   Connection closed: code = 1000 (OK), no reason.

+

+

+OCPP compliant handler

+----------------------

+

+.. note::

+

+   This document describes how to create an central system that supports OCPP

+   1.6. The ocpp Python package has support for OCPP 2.0 as well. This

+   documentation will be updated soon to reflect that. In the mean time please

+   consult the `examples/`_ to learn how to create an OCPP 2.0 central system.

+

+The websocket server created above is not very useful and only sends a non-OCPP compliant message.

+

+Remove the `on_connect()` handler from the code above and replace it by the following snippet.

+

+.. code-block:: python

+

+   from datetime import datetime

+

+   from ocpp.routing import on

+   from ocpp.v16 import ChargePoint as cp

+   from ocpp.v16.enums import Action, RegistrationStatus

+   from ocpp.v16 import call_result

+

+

+   class MyChargePoint(cp):

+       @on(Action.BootNotification)

+       async def on_boot_notification(self, charge_point_vendor, charge_point_model, **kwargs):

+           return call_result.BootNotificationPayload(

+               current_time=datetime.utcnow().isoformat(),

+               interval=10,

+               status=RegistrationStatus.accepted

+           )

+

+

+   async def on_connect(websocket, path):

+       """ For every new charge point that connects, create a ChargePoint instance

+       and start listening for messages.

+

+       """

+       charge_point_id = path.strip('/')

+       cp = MyChargePoint(charge_point_id, websocket)

+

+       await cp.start()

+

+

+The `on_connect()` handler has been updated and now creates a `MyChargePoint` instance and calls the

+`start()`_ coroutine.

+

+`MyChargePoint` subclasses from `ocpp.v16.ChargePoint`_. `ocpp.v16.ChargePoint` is the core of the

+ocpp package. This class implements the routing of messages coming from the client to the correct handler.

+It also will validate all messages that are being received or being send to the client and it

+implements flow control.

+

+Our `MyChargePoint` class uses the `@on()`_ decorator to implement a handler for 'BootNotification'

+requests. The `@on()` takes a string with the name of an action as only argument. Although not used

+in this example, the package also provides an `@after()`_ decorator that can be used the register a

+post request handler.

+

+According to the OCPP specification a payload of a BootNotification request must contain two

+required arguments, 'chargePointModel' and 'chargePointVendor', as well as an seven optional

+arguments. The handler reflects this by having two required arguments, `charge_point_vendor` and

+`charge_point_model`. The handler uses `**kwargs` for the optional arguments.

+

+The handler returns an instance of `ocpp.v16.call_result.BootNotificationPayload`_. This object

+is used to create a response that is send back to the client.

+

+.. note::

+

+   OCPP uses a camelCase naming scheme for the keys in the payload. Python, on

+   the other hand, uses snake_case.

+

+   Therefore this ocpp package converts all keys in messages from camelCase to

+   snake_case and vice versa to make sure you can write Pythonic code.

+

+

+Now start the websocket server again and connect a client to it as you did before. If the client is

+connected send this BootNotification to the central system:

+

+.. code-block:: shell

+

+	`[2, "12345", "BootNotification", {"chargePointVendor": "The Mobility House", "chargePointModel": "Optimus"}]`

+

+The server should respond and the you should see something like this:

+

+.. code-block:: shell

+

+   $ python -m websockets ws://localhost:9000/test_charge_point

+   Connected to ws://localhost:9000/test_charge_point.

+   > [2, "12345", "BootNotification", {"chargePointVendor": "The Mobility House", "chargePointModel": "Optimus"}]

+   < [3, "12345", {"currentTime": "2019-06-16T11:18:09.591716", "interval": 10, "status": "Accepted"}]`

+

+Congratulations! You've created a central system.

+

+You can find the source code of the central system created in this document in the `examples/`_

+directory.

+

+.. _client: https://websockets.readthedocs.io/en/stable/intro.html#one-more-thing

+.. _examples/: https://github.com/mobilityhouse/ocpp/blob/master/examples

+.. _ocpp.v16.call_result.BootNotificationPayload: https://github.com/mobilityhouse/ocpp/blob/3b92c2c53453dd6511a202e1dc1b9aa1a236389e/ocpp/v16/call_result.py#L28

+.. _ocpp.v16.ChargePoint: https://github.com/mobilityhouse/ocpp/blob/master/ocpp/v16/charge_point.py#L80

+.. _start(): https://github.com/mobilityhouse/ocpp/blob/3b92c2c53453dd6511a202e1dc1b9aa1a236389e/ocpp/v16/charge_point.py#L125

+.. _websockets: https://websockets.readthedocs.io/en/stable/

+.. _websockets.serve(): https://websockets.readthedocs.io/en/stable/api.html#module-websockets.server

+.. _websockets.server.WebsocketServerProtocol: https://websockets.readthedocs.io/en/stable/api.html#websockets.server.WebSocketServerProtocol

+.. _@on(): https://github.com/mobilityhouse/ocpp/blob/3b92c2c53453dd6511a202e1dc1b9aa1a236389e/ocpp/routing.py#L4

+.. _@after(): https://github.com/mobilityhouse/ocpp/blob/3b92c2c53453dd6511a202e1dc1b9aa1a236389e/ocpp/routing.py#L34

+# Configuration file for the Sphinx documentation builder.

+#

+# This file only contains a selection of the most common options. For a full

+# list see the documentation:

+# http://www.sphinx-doc.org/en/master/config

+

+# -- Path setup --------------------------------------------------------------

+

+# If extensions (or modules to document with autodoc) are in another directory,

+# add these directories to sys.path here. If the directory is relative to the

+# documentation root, use os.path.abspath to make it absolute, like shown here.

+#

+import os

+import sys

+

+sys.path.insert(0, os.path.abspath("../../"))

+

+

+# -- Project information -----------------------------------------------------

+

+project = "OCPP"

+copyright = "2023, Auke Willem Oosterhoff"

+author = "Auke Willem Oosterhoff"

+

+# The full version, including alpha/beta/rc tags

+release = "0.25.0"

+

+

+# -- General configuration ---------------------------------------------------

+

+# Add any Sphinx extension module names here, as strings. They can be

+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom

+# ones.

+extensions = ["sphinx.ext.autodoc"]

+

+# Add any paths that contain templates here, relative to this directory.

+templates_path = ["_templates"]

+

+# List of patterns, relative to source directory, that match files and

+# directories to ignore when looking for source files.

+# This pattern also affects html_static_path and html_extra_path.

+exclude_patterns = []

+

+master_doc = "index"

+

+# -- Options for HTML output -------------------------------------------------

+

+# The theme to use for HTML and HTML Help pages.  See the documentation for

+# a list of builtin themes.

+#

+html_theme = "alabaster"

+

+# Add any paths that contain custom static files (such as style sheets) here,

+# relative to this directory. They are copied after the builtin static files,

+# so a file named "default.css" will overwrite the builtin "default.css".

+html_static_path = ["_static"]

+.. OCPP documentation master file, created by

+   sphinx-quickstart on Tue May 28 20:40:32 2019.

+   You can adapt this file completely to your liking, but it should at least

+   contain the root `toctree` directive.

+

+.. include:: ../../README.rst

+

+Index

+-----

+

+.. toctree::

+   :maxdepth: 2

+

+   README

+   central_system

+import asyncio

+import logging

+from datetime import datetime

+

+try:

+    import websockets

+except ModuleNotFoundError:

+    print("This example relies on the 'websockets' package.")

+    print("Please install it by running: ")

+    print()

+    print(" $ pip install websockets")

+    import sys

+

+    sys.exit(1)

+

+from ocpp.routing import on

+from ocpp.v16 import ChargePoint as cp

+from ocpp.v16 import call_result

+from ocpp.v16.enums import Action, RegistrationStatus

+

+logging.basicConfig(level=logging.INFO)

+

+

+class ChargePoint(cp):

+    @on(Action.BootNotification)

+    def on_boot_notification(

+        self, charge_point_vendor: str, charge_point_model: str, **kwargs

+    ):

+        return call_result.BootNotificationPayload(

+            current_time=datetime.utcnow().isoformat(),

+            interval=10,

+            status=RegistrationStatus.accepted,

+        )

+

+

+async def on_connect(websocket, path):

+    """For every new charge point that connects, create a ChargePoint

+    instance and start listening for messages.

+    """

+    try:

+        requested_protocols = websocket.request_headers["Sec-WebSocket-Protocol"]

+    except KeyError:

+        logging.error("Client hasn't requested any Subprotocol. Closing Connection")

+        return await websocket.close()

+    if websocket.subprotocol:

+        logging.info("Protocols Matched: %s", websocket.subprotocol)

+    else:

+        # In the websockets lib if no subprotocols are supported by the

+        # client and the server, it proceeds without a subprotocol,

+        # so we have to manually close the connection.

+        logging.warning(

+            "Protocols Mismatched | Expected Subprotocols: %s,"

+            " but client supports  %s | Closing connection",

+            websocket.available_subprotocols,

+            requested_protocols,

+        )

+        return await websocket.close()

+

+    charge_point_id = path.strip("/")

+    cp = ChargePoint(charge_point_id, websocket)

+

+    await cp.start()

+

+

+async def main():

+    server = await websockets.serve(

+        on_connect, "0.0.0.0", 9000, subprotocols=["ocpp1.6"]

+    )

+

+    logging.info("Server Started listening to new connections...")

+    await server.wait_closed()

+

+

+if __name__ == "__main__":

+    # asyncio.run() is used when running this example with Python >= 3.7v

+    asyncio.run(main())

+import asyncio

+import logging

+

+try:

+    import websockets

+except ModuleNotFoundError:

+    print("This example relies on the 'websockets' package.")

+    print("Please install it by running: ")

+    print()

+    print(" $ pip install websockets")

+    import sys

+

+    sys.exit(1)

+

+

+from ocpp.v16 import ChargePoint as cp

+from ocpp.v16 import call

+from ocpp.v16.enums import RegistrationStatus

+

+logging.basicConfig(level=logging.INFO)

+

+

+class ChargePoint(cp):

+    async def send_boot_notification(self):

+        request = call.BootNotificationPayload(

+            charge_point_model="Optimus", charge_point_vendor="The Mobility House"

+        )

+

+        response = await self.call(request)

+

+        if response.status == RegistrationStatus.accepted:

+            print("Connected to central system.")

+

+

+async def main():

+    async with websockets.connect(

+        "ws://localhost:9000/CP_1", subprotocols=["ocpp1.6"]

+    ) as ws:

+

+        cp = ChargePoint("CP_1", ws)

+

+        await asyncio.gather(cp.start(), cp.send_boot_notification())

+

+

+if __name__ == "__main__":

+    # asyncio.run() is used when running this example with Python >= 3.7v

+    asyncio.run(main())

+import asyncio

+import logging

+from datetime import datetime

+

+try:

+    import websockets

+except ModuleNotFoundError:

+    print("This example relies on the 'websockets' package.")

+    print("Please install it by running: ")

+    print()

+    print(" $ pip install websockets")

+    import sys

+

+    sys.exit(1)

+

+from ocpp.routing import on

+from ocpp.v20 import ChargePoint as cp

+from ocpp.v20 import call_result

+

+logging.basicConfig(level=logging.INFO)

+

+

+class ChargePoint(cp):

+    @on("BootNotification")

+    def on_boot_notification(self, charging_station, reason, **kwargs):

+        return call_result.BootNotificationPayload(

+            current_time=datetime.utcnow().isoformat(), interval=10, status="Accepted"

+        )

+

+    @on("Heartbeat")

+    def on_heartbeat(self):

+        print("Got a Heartbeat!")

+        return call_result.HeartbeatPayload(

+            current_time=datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S") + "Z"

+        )

+

+

+async def on_connect(websocket, path):

+    """For every new charge point that connects, create a ChargePoint

+    instance and start listening for messages.

+    """

+    try:

+        requested_protocols = websocket.request_headers["Sec-WebSocket-Protocol"]

+    except KeyError:

+        logging.error("Client hasn't requested any Subprotocol. Closing Connection")

+        return await websocket.close()

+    if websocket.subprotocol:

+        logging.info("Protocols Matched: %s", websocket.subprotocol)

+    else:

+        # In the websockets lib if no subprotocols are supported by the

+        # client and the server, it proceeds without a subprotocol,

+        # so we have to manually close the connection.

+        logging.warning(

+            "Protocols Mismatched | Expected Subprotocols: %s,"

+            " but client supports  %s | Closing connection",

+            websocket.available_subprotocols,

+            requested_protocols,

+        )

+        return await websocket.close()

+

+    charge_point_id = path.strip("/")

+    cp = ChargePoint(charge_point_id, websocket)

+

+    await cp.start()

+

+

+async def main():

+    server = await websockets.serve(

+        on_connect, "0.0.0.0", 9000, subprotocols=["ocpp2.0"]

+    )

+

+    logging.info("Server Started listening to new connections...")

+    await server.wait_closed()

+

+

+if __name__ == "__main__":

+    # asyncio.run() is used when running this example with Python >= 3.7v

+    asyncio.run(main())

+import asyncio

+import logging

+

+try:

+    import websockets

+except ModuleNotFoundError:

+    print("This example relies on the 'websockets' package.")

+    print("Please install it by running: ")

+    print()

+    print(" $ pip install websockets")

+    import sys

+

+    sys.exit(1)

+

+

+from ocpp.v20 import ChargePoint as cp

+from ocpp.v20 import call

+

+logging.basicConfig(level=logging.INFO)

+

+

+class ChargePoint(cp):

+    async def send_heartbeat(self, interval):

+        request = call.HeartbeatPayload()

+        while True:

+            await self.call(request)

+            await asyncio.sleep(interval)

+

+    async def send_boot_notification(self):

+        request = call.BootNotificationPayload(

+            charging_station={"model": "Wallbox XYZ", "vendor_name": "anewone"},

+            reason="PowerUp",

+        )

+        response = await self.call(request)

+

+        if response.status == "Accepted":

+            print("Connected to central system.")

+            await self.send_heartbeat(response.interval)

+

+

+async def main():

+    async with websockets.connect(

+        "ws://localhost:9000/CP_1", subprotocols=["ocpp2.0"]

+    ) as ws:

+

+        cp = ChargePoint("CP_1", ws)

+

+        await asyncio.gather(cp.start(), cp.send_boot_notification())

+

+

+if __name__ == "__main__":

+    # asyncio.run() is used when running this example with Python >= 3.7v

+    asyncio.run(main())

+import asyncio

+import logging

+from datetime import datetime

+

+try:

+    import websockets

+except ModuleNotFoundError:

+    print("This example relies on the 'websockets' package.")

+    print("Please install it by running: ")

+    print()

+    print(" $ pip install websockets")

+    import sys

+

+    sys.exit(1)

+

+from ocpp.routing import on

+from ocpp.v201 import ChargePoint as cp

+from ocpp.v201 import call_result

+

+logging.basicConfig(level=logging.INFO)

+

+

+class ChargePoint(cp):

+    @on("BootNotification")

+    def on_boot_notification(self, charging_station, reason, **kwargs):

+        return call_result.BootNotificationPayload(