e3fee2cf46
Prior to this commit, the Odoo documentation was mainly split between
two repositories: odoo/odoo/doc and odoo/documentation-user. Some bits
of documentation were also hosted elsewhere (e.g., wiki, upgrade, ...).
This was causing several problems among which:
- The theme, config, Makefile, and similar technical resources had to
be duplicated. This resulted in inconsistent layout, features, and
build environments from one documentation to another.
- Some pages did not fit either documentation as they were relevant
for both users and developers. Some were relevant to neither of the
two (e.g., DB management).
- Cross-doc references had to be absolute links and they broke often.
- Merging large image files in the developer documentation would bloat
the odoo/odoo repository. Some contributions had to be lightened to
avoid merging too many images (e.g., Odoo development tutorials).
- Long-time contributors to the user documentation were chilly about
going through the merging process of the developer documentation
because of the runbot, mergebot, `odoo-dev` repository, etc.
- Some contributors would look for the developer documentation in the
`odoo/documentation-user` repository.
- Community issues about the user documentation were submitted on the
`odoo/odoo` repository and vice-versa.
Merging all documentations in one repository will allow us to have one
place, one theme, one work process, and one set of tools (build
environment, ...) for all of the Odoo docs.
As this is a good opportunity to revamp the layout of the documentation,
a brand new theme replaces the old one. It features a new way to
navigate the documentation, centered on the idea of always letting the
reader know what is the context (enclosing section, child pages, page
structure ...) of the page they are reading. The previous theme would
quickly confuse readers as they navigated the documentation and followed
cross-application links.
The chance is also taken to get rid of all the technical dangling parts,
performance issues, and left-overs. Except for some page-specific JS
scripts, the Odoo theme Sphinx extension is re-written from scratch
based on the latest Sphinx release to benefit from the improvements and
ease future contributions.
task-2351938
task-2352371
task-2205684
task-2352544
Closes #945
140 lines
4.4 KiB
ReStructuredText
140 lines
4.4 KiB
ReStructuredText
|
|
==================
|
|
Internet of Things
|
|
==================
|
|
|
|
IoT Drivers allow any Odoo module to communicate in real-time with any device
|
|
connected to the IoT Box. Communication with the IoT Box goes both ways, so the
|
|
Odoo client can send commands to and receive information from any of the
|
|
supported devices. To add support for a device, all we need is a `Driver`.
|
|
|
|
At each boot, the IoT Box will load all of the Drivers that can
|
|
be located on the connected Odoo instance. Each module can contain a
|
|
`drivers` directory, whose content will be copied to the IoT Box.
|
|
|
|
Detect Devices
|
|
==============
|
|
|
|
The `addons/hw_drivers/controllers/driver.py` file contains a Manager that is
|
|
in charge of the devices. The Manager maintains a list of connected devices
|
|
and associates them with the right Driver.
|
|
|
|
Supported devices will appear both on the IoT Box Homepage that you can access
|
|
through its IP address and in the IoT module of the connected Odoo instance.
|
|
|
|
Driver
|
|
------
|
|
|
|
Once the Manager has retrieved the list of detected devices, it will loop
|
|
through all of the Drivers that have the same connection type and test their
|
|
respective `supported` method on all detected devices. If the supported method
|
|
of a Driver returns `True`, an instance of this Driver will be created for the
|
|
corresponding device.
|
|
|
|
Creating a new Driver requires:
|
|
|
|
- Extending `Driver`
|
|
- Setting the `connection_type` class attribute.
|
|
- Setting the `device_type`, `device_connection` and `device_name` attributes.
|
|
- Defining the `supported` method
|
|
|
|
.. code-block:: python
|
|
|
|
from odoo.addons.hw_drivers.controllers.driver import Driver
|
|
|
|
class DriverName(Driver):
|
|
connection_type = 'ConnectionType'
|
|
|
|
def __init__(self, device):
|
|
super(NewDriver, self).__init__(device)
|
|
self._device_type = 'DeviceType'
|
|
self._device_connection = 'DeviceConnection'
|
|
self._device_name = 'DeviceName'
|
|
|
|
@classmethod
|
|
def supported(cls, device):
|
|
...
|
|
|
|
Communicate With Devices
|
|
========================
|
|
|
|
Once your new device is detected and appears in the IoT module, the next step
|
|
is to communicate with it. Since the box only has a local IP address, it can
|
|
only be reached from the same local network. Communication, therefore, needs to
|
|
happen on the browser-side, in JavaScript.
|
|
|
|
The process depends on the direction of the communication:
|
|
- From the browser to the box, through `Actions`_
|
|
- From the box to the browser, through `Longpolling`_
|
|
|
|
Both channels are accessed from the same JS object, the `DeviceProxy`, which is
|
|
instantiated using the IP of the IoT Box and the device identifier.
|
|
|
|
.. code-block:: javascript
|
|
|
|
var DeviceProxy = require('iot.widgets').DeviceProxy;
|
|
|
|
var iot_device = new DeviceProxy({
|
|
iot_ip: iot_ip,
|
|
identifier: device_identifier
|
|
});
|
|
|
|
Actions
|
|
-------
|
|
|
|
Actions are used to tell a selected device to execute a specific action,
|
|
such as taking a picture, printing a receipt, etc.
|
|
|
|
.. note::
|
|
It must be noted that no “answer” will be sent by the box on this route,
|
|
only the request status. The answer to the action, if any, has to be
|
|
retrieved via the longpolling.
|
|
|
|
An action can be performed on the DeviceProxy Object.
|
|
|
|
.. code-block:: javascript
|
|
|
|
iot_device.action(data);
|
|
|
|
In your driver, define an `action` method that will be executed when called
|
|
from an Odoo module. It takes the data given during the call as argument.
|
|
|
|
.. code-block:: python
|
|
|
|
def action(self, data):
|
|
...
|
|
|
|
Longpolling
|
|
-----------
|
|
|
|
When any module in Odoo wants to read data from a specific device, it creates a
|
|
listener identified by the IP/domain of the box and the device identifier and
|
|
passes it a callback function to be called every time the device status
|
|
changes. The callback is called with the new data as argument.
|
|
|
|
.. code-block:: javascript
|
|
|
|
iot_device.add_listener(this._onValueChange.bind(this));
|
|
|
|
_onValueChange: function (result) {
|
|
...
|
|
}
|
|
|
|
In the Driver, an event is released by calling the `device_changed` function
|
|
from the `event_manager`. All callbacks set on the listener will then be called
|
|
with `self.data` as argument.
|
|
|
|
.. code-block:: python
|
|
|
|
from odoo.addons.hw_drivers.controllers.driver import event_manager
|
|
|
|
class DriverName(Driver):
|
|
connection_type = 'ConnectionType'
|
|
|
|
def methodName(self):
|
|
self.data = {
|
|
'value': 0.5,
|
|
...
|
|
}
|
|
event_manager.device_changed(self)
|