Giter Site home page Giter Site logo

opencyphal / specification Goto Github PK

View Code? Open in Web Editor NEW
41.0 16.0 13.0 4.52 MB

The Cyphal specification documents are maintained here.

Home Page: https://opencyphal.org/specification

License: Creative Commons Attribution 4.0 International

TeX 82.67% Shell 0.13% PostScript 14.21% Python 2.99%
uavcan can-bus canbus communication-protocol aerospace robotics unmanned-aerial-vehicle drone drones open-standard

specification's Introduction

Cyphal specification

CI Forum

The sources of the Cyphal specification and other related documents are contained here.

When cloning this repository, don't forget to initialize the Git submodules: git submodule update --init --recursive.

Governance

The Cyphal specification is community-managed and completely open. Anyone can propose changes but only Cyphal maintainers may commit changes to this repository where the contents of the HEAD revision of the primary branch constitutes the latest version of the specification in-effect.

Request For Comments (RFC) Process

Changes to the specification shall use the following, community-driven RFC process:

  1. An RFC is posted on the OpenCyphal forum's specification section with the details of the proposed change. The title of this post should start with "RFC: " to indicate it is the start of a proposed change to the specification.
  2. RFCs will remain on the forum for at least 10 days to ensure interested parties have time to discover and review them.
  3. After some discussion and review by the community, the RFC is either accepted or rejected by at least one OpenCyphal maintainer.
  4. Once accepted the RFC is implemented in the specification as a pull-request and is considered adopted once the PR has been merged.

Editing guide

Style

Follow the Zubax LaTeX guide: https://kb.zubax.com/x/IYEh. Do not edit the document without the spell checker.

Write in American English.

Critical definitions (behaviors, constraints, assumptions, etc.) shall be written in the main body of the document. Optional content (clarifications, examples, elaborations) is placed either into footnotes or into blue remark boxes which can be defined using \begin{remark}...\end{remark}.

Never address the reader directly. Do not hesitate to use passive voice. For example, instead of "you can find the data type X here", say "the data type X can be found here".

Follow RFC2119.

Do not use title case. Headings and captions are to be written in regular sentence case. Generally, capitalized words can only be used in the beginning of a sentence and in proper names.

Do not put a full stop after a caption unless it contains any other punctuation or is more than one sentence long.

Always insert a non-breakable space before reference: refer to section~\ref{sec:chapter_section}.

When referring to a category of identifiers, put a hyphen before "ID"; for example: "node-ID" is correct, "node ID" is not.

Avoid introduction of new acronyms unless you really must. It is better to say "transfer-ID" or "data type hash" rather than TID or DTH. Excessive reliance on acronyms may impede comprehension.

Rigging

In order to refer to a DSDL definition, use macro \DSDLReference{}. To include a DSDL definition or a namespace index, use macro \DSDL{}. Refer to the existing usages for an example.

Structure and cross-referencing

Each chapter is located in a dedicated directory, whose name is a single lowercase word. The main file of the chapter is located in a file under the same name as the directory. For example: chapter/chapter.tex (where "chapter" is the chapter name placeholder).

When defining a new label, you must use the prefix following the pattern kind:chapter, where:

  • "kind" is the kind of the labeled item, such as fig, table, or sec;
  • "chapter" is the name of the directory where the chapter is contained.

The label that contains only the prefix points to the chapter itself using the kind sec. For example, if the chapter is named "Transport layer", its label would be sec:transport.

Items contained inside the chapter (sections, figures, tables) are named using free form appended to the prefix. For example, one could refer to a figure contained inside the chapter "Chapter" as fig:chapter_my_figure.

The above rules are crucial to follow to keep cross-references usable. Without strict conventions in place, they quickly become unmanageable.

Source formatting

  • One level of nesting shall be indented with 4 spaces. Tabs shall not be used anywhere in the source.
  • There shall be no more than 120 characters per line.
  • There shall be exactly one blank line at the end of the file.
  • There shall be no more than one consecutive blank line.
  • There shall be at most one chapter per source file.
  • There shall be one blank line above and below a section header, unless the section header is at the top of the source file.
  • Multi-line content enclosed in curly braces should be indented.
  • If a list item spills on the next line, the spilled text should be indented on the same level with \item.
\begin{itemize}
    \item This list item is sufficiently long to exceed the limit of 120 characters per line,
    so it has to spill onto the next line.
    The spilled part is indented correctly.

    \item Another item.
\end{itemize}

% The next line contains a comment to remove the whitespace in the beginning of the footnote.
Regulated non-standard definitions\footnote{%
    I.e., public definitions contributed by vendors and other users
    of the specification, as explained in section~\ref{sec:basic_data_type_regulation}.
} are not included in this list.

Tools

Compiling

A GNU/Linux-based operating system is assumed. The described instructions may be valid for other operating systems but this is not guaranteed.

In order to compile the document, install TeX Live (Ubuntu packages: texlive-full and lyx) and the Python packages listed in requirements.txt.

When done, run ./compile.sh.

Using texer

You can use our texer container to build the specification if you don't want to setup your own build environment. Please consult with the CI/CD workflow to find out which container version should be used. To enter the container from a local shell, go roughly like this:

docker run -it --rm -v $(pwd):/repo -e LOCAL_USER_ID=`id -u` ghcr.io/opencyphal/texer:te22.4.1 bash

IDE setup

First, ensure that you can compile the document as described above. Do not proceed further until that requirement is satisfied.

Use Visual Studio Code with the recommended extensions for editing. More info in the Zubax Knowledge Base.

L33t IDE Setup

If you want to use our texer container with vscode then install the "ms-vscode-remote.vscode-remote-extensionpack" and Docker. When you open vscode in this repository it should prompt you to "open this folder in container?". Otherwise F1 or CMD+SHIFT+P and select Remote-Containers: Reopen Locally. Once within the container you can simply F1 or CMD+SHIFT+P and LaTeX Workshop: Build LaTeX project to build the specification PDF.

The above may not work if you are running an OSS build of VSCode (e.g., from Arch AUR). It is recommended to use the official binaries from Micro$oft.

specification's People

Contributors

cafung-aws avatar coderkalyan avatar finwood avatar iberri avatar kjetilkjeka avatar pavel-kirienko avatar thirtytwobits avatar valeriikim avatar veronistar avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

specification's Issues

Allow different data types under the same port-ID as long as they are semantically compatible and mutually bit-compatible

Consider replacing this in section 3.8.3.3:

A port identifier of a given kind (subject or service) shall only be used with one major version of one data type in a given UAVCAN network.

Allow data types to be different as long as they are semantically compatible and mutually bit-compatible. See the rationale here https://forum.uavcan.org/t/uavcan-v1-0-and-ardupilot/671/8?u=pavel.kirienko:

image

The "minted" environment breaks page rules

Wherever the minted environment spans across a page break, the bottom page rule gets mangled. On the following screenshot this can be seen on the right side page, where the minted block is carried over to the next page (not shown):

image

Specification update effort (tracking issue)

Set up chktex

The LaTeX Workshop extension for VSCode supports chktex natively, and we should also run it in the CI.

Future: Support for sparse matrices in the protocol

At the moment, UAVCAN does not support sparse matrices at the protocol level, but rather delegates the issue to the user via matrix packing recommendations.

Native support for sparse matrices will remove the work of ensuring correct packing/unpacking from applications, which will likely have positive effect on simplicity and reliability.

The feature can be probably added in a backward-compatible way. It has not been included in the first revision of the specification due to the following:

  • Lack of support for CAN FD severely limits the bandwidth, so the applications are unlikely to exchange large matrices over UAVCAN.
  • The concept is not clearly defined yet.

There is an experimental branch in the pyuavcan repository, that contains a simple modification to the DSDL parser that enables support for matrices. It is based on two new syntax constructs:

  • type[R,C] field_name for a dense matrix, where R,C stands for the number of rows and columns;
  • type[<=R,C] field_name for a sparse matrix, R,C as above.

Explicit structuring

As mentioned in the post about meta-transport, highly hierarchical definitions are hard to view because the representation of namespace members is inherently flat which does not reflect the data structure.

Fixed port-IDs make top-level types very salient. It is also natural since a nested type does not need to have a fixed port-ID. This solution is unavailable for top-level types that don't have a fixed port-ID, such as in the linked case; an alternative is to simply add a special character pattern, such as an underscore, in place of the fixed port-ID. For example, a DSDL file Frame.1.0.uavcan would become _.Frame.1.0.uavcan. Example:

image

Alternatively, non-top-level types could be named starting with . like .Error.1.0.uavcan. That would make them hidden on Unix-like systems which is interesting.

These are very easy to implement but they are probably not the best possible solutions; other suggestions are welcome.

Migration guide from v0 to v1.0

To help system architects that are evaluating a change from v0 to v1 of the protocol we should provide a section of the document that details the differences and describes strategies for migrating existing components.

DSDL compatibility analysis

I've open this issue to discuss how changes to data types should be handled. This issue is a follow up on OpenCyphal/public_regulated_data_types#35, #5 and #6 but tries to isolate the compatibility discussion without blending it together with other review related items.

I will attempt to keep the text under the line updated to reflect the consensus of the discussion. The initial text is based on previous discussion and (where there are little discussion) my first instincts. Please criticize so we can improve upon it.


Compatibility

Compatibility is a relationship that message definition A can have with message definition B. If A is compatible with B and B is compatible with A we say they are mutually compatible. The different forms of compatibility is defined below.

Bit compatibility

A structure definition A is bit-compatible with a structure definition B if any valid encoded representation of B is also a valid encoded representation of A.

Semantic compatibility

A data structure definition A is semantically compatible with a data structure definition B if an application that correctly uses A exhibits a functionally equivalent behavior to an application that correctly uses B, and A is bit-compatible with B.

Code compatibility

We say that A is code compatible with B if valid use of code generated from B also is valid use of code generated from A with the same spec-adhering compiler.

For a compiler to be spec-adhering it must generate compatible code if:

  • All variable names that exists in B must also exist in A. They must also have the same type.
  • All const names that exists in B must also exist in A. They must also have the same type.

ID compatible

We say that A is ID compatible with B If B has a default ID, and A has exact same default ID or B does not have a default ID.

Compatibility guarantees

  • For definitions with different major version numbers, no compatibility guarantees are given.
  • For definitions with major version equal 0, no compatibility guarantees are given.
  • For definitions with major version not equal 0 and identical path the version with the highest version number will have the following compatibilities with the other version.
    • Bit compatibility
    • Semantic compatibility
    • Code compatibility
    • ID compatible

Mutability guarantees

All definitions are immutable. This means that after a definition is published a new definition with the same namespace and name must have a higher version number. There are a few exceptions:

  • Whitespace formating is allowed to change on published types
  • Comments are allowed to change on published types, as long as this doesn't affect semantic compatibility.
  • Version 0.0 is not considered in any way immutable and may change in any way it might please.

Open questions

  • How do we express deprecation?
  • Should all definitions with major version == 0 be considered mutable or only 0.0?
  • In the specification semantic compatibility implies bit compatibility. Should this be the rule, or should it be orthogonal concepts?

Data type extensibility

Thanks to the explicit syntax-semantics separation, type extensibility is less important for UAVCAN v1 than it is for some other protocols, such as v0 or MAVLink. However, it does not mean that it is not a major enabler for the long-term stability of the ecosystem.

We should explore the possible approaches to this problem and consider implementing one in a future minor revision of the protocol after v1.0, possibly v1.1.

I think we should be able to come up with a more rigorous and strongly-typed solution than naive field injection at the end. I have been thinking about the idea of polymorphism and publisher-subscriber type covariance for months, but the idea is still too vague for a constructive discussion, largely because I am still focused on more immediate issues. The discussion started by @tridge about the adoption of v1 in ArduPilot induced me to post a very brief and highly incomplete description of my ideas in that thread on the forum.

New proposals are welcome.

Allow multidimensional arrays

Multidimensional arrays are currently prohibited. They were avoided mostly due to the issues with byte alignment in variable-length arrays where the width of the length prefix is not a multiple of 8 bits. Since in UAVCAN v1 we require that implicit fields be always standard-size (8/16/32/64), it is now possible to allow multidimensional arrays without sacrificing data alignment.

One issue that has to be considered is how to introduce multidimensional arrays into the grammar while avoiding left recursion. This is because the DSDL syntax is defined through a PEG grammar which does not allow left recursion.

https://github.com/UAVCAN/pydsdl/blob/f53eb68f7c403fe27db5f8ff18e45289b6e14cae/pydsdl/grammar.parsimonious#L32-L41

Continuous integration

We need to set up a CI to automatically build the spec doc and upload the resulting PDF somewhere. Ideally, for pull requests, the resulting PDF should be attached to a comment after every build. Travis supposedly can be configured to do that, see https://damien.pobel.fr/post/github-api-from-travisci/. Although I'm not sure if it's possible to upload an attachment using that API.

Would somebody like to volunteer?

Migration strategy from v0 to v1

While the two versions of the protocol can co-exist successfully on the same bus (thanks to the Toggle bit measures we've taken), supporting both versions in the same implementation concurrently can be challenging, especially after our big redesign of the standard data type definitions has landed (it's not even proposed yet, working on that).

With that in mind, I would like to revisit the question of migrating deployed nodes from v0 to v1. As I see it, we have two options:

  • Amend the current implementations (Libuavcan, Libcanard, Pyuavcan, probably also uavcan.rs, although I recall @kjetilkjeka was planning to skip v0 completely) to make them support both v0 and v1. Let applications choose which version of the protocol to use by configuring their implementations at run time.
  • Make current implementations compatible with v1 only, disregarding v0 completely. Let applications carry two implementations, for v0 and v1 separately, and let them select which one to use at run time.

Seeing that the set of fielded nodes is still relatively small and that the old and the new sets of standard data type definitions are likely to end up drastically different, I am inclined to prefer the second option. Its advantage is that it requires much less workload from the library maintainers (us). The disadvantage is that the memory footprints will rise considerably until v0 is phased out completely (although for some this could be a motivation for speedier migration to v1).

Legal statement

Currently, the legal statement says this, which is not exactly correct:

UAVCAN is an interface standard open to everyone. No copyrights are reserved and no licensing is necessary for its implementation, distribution, or use. In no event shall the authors of the standard be liable for any damage arising, directly or indirectly, from its use.

A better wording should be found. The objectives are the following:

  • We want the spec and related docs to be free and open in the spirit of CC-BY-4.0 except that the "No additional restrictions" limitation should be lifted.
  • The liability disclaimer should be there.

Review chapters 1, 2, 3, 4, 6

The spec draft is ready except for the chapter 5 (Application layer). The work on the application layer is blocked by the lack of the new standard data type set, so that seems to be the next thing to do.

The document has been restructured rather considerably compared to the v0 spec published on the website. The new structure provides dedicated chapters for the transport layer, the application layer, and the physical layer. Also, per Kjetil's suggestion, CAN-specific information has been extracted into two well-isolated sections (one for the transport layer and the other for the physical layer), allowing for future support of other transports.

The CAN FD physical layer compatibility recommendations are missing. They are going to remain this way until we've ran some tests with CAN FD in the lab here; nevertheless, relevant discussions and suggestions are highly welcome.

The current draft could probably use some refinement in the following areas (help needed):

  • The specification of the DSDL grammar (sections 3.2, 3.3, 3.4) is rather haphazard. I believe it could greatly benefit from a complete rewrite from scratch. The main reason it ended up in this state is that the early draft was updated and amended in various ways multiple times until the current edition was settled upon. Now, having the design solidified, is a good opportunity to rework it into a proper specification. It is not a high priority task but is something I could use help with.
  • Section 4.3 (transport layer - transfer reception) could be incomplete or hard to understand. Transfer reconstruction is probably the hardest part of the protocol to implement right, so it is important to ensure that this part is comprehensible and is unambiguous.

Here is the latest draft (built from the current master): UAVCAN_Specification.pdf

I think as we are slowly approaching completion of the document I should stop cowboying and begin using a more disciplined approach to editing with feature branches, especially if you're going to edit the document alongside.

Setup CI

use our new texer container to build in Buildkite with PR validation builds.

Deprecation of DSDL definitions

Split out the deprecation discussion into this thread (why do we always seem to wander off topic)

The state of the discussion when split up

Pavel:

I have added a @deprecated keyword to the current draft a couple of weeks ago; it's supposed to be translated into language-specific deprecation markers, e.g. [[deprecated]] in C++ or DeprecationWarning in Python.

Kjetil:

How do we express deprecation?

Let's address this concern before moving on to the bigger concerns.

I have added a @deprecated keyword to the current draft a couple of weeks ago; it's supposed to be translated into language-specific deprecation markers, e.g. [[deprecated]] in C++ or DeprecationWarning in Python.

That's nice. I was playing around with a similar idea myself. What i was thinking about was adding
@lifecycle <pre-release|released|deprecated|removed>, this way we can add a new type without releasing it, yank a buggy type and deprecate old types. This is how i vision it would work.

  • Pre-realease - do not generate code for this definition unless some dangerous keyword is presented.
  • Released - As normal (as it currently works)
  • Deprecated - Issue a warning that the type is deprecated and will be removed in the future.
  • Removed - Issue an error that this type has been through the deprecation process and is no longer usable.

Even if we initially only supported deprecated It would allow us to add other lifecycle items (like removed) later on without making a new directive. Both our solutions would of course require the directive related to deprecated to be an exception to the immutability guarantees together with comments and whitespaces (which is of course totally fine).

Pavel:

I like the flexibility argument, but I have two questions:

  1. What's the point of the removed option if the definition can be just physically removed to the same effect?
  2. pre-release goes against the versioning guarantees that once something is published it can't be removed or changed without a proper deprecation process. If you want tentative volatile definitions, use version 0. I think we can make this work but that would be at the cost of extra complexity in the specification, so I am against it.

If the two options mentioned above are removed, we're back to just deprecated and released. I think the meaning of the keyword @lifecycle might be slightly less transparent than @deprecated, i.e. somebody who is not familiar with the UAVCAN specification might fail to understand what it means; @deprecated seems more approachable. Also, most published data type definitions will be in the release stage, meaning that it would make sense to assume release by default if not specified, so @lifecycle release becomes redundant.

I suggest keeping @deprecated.

Protocol update effort (tracking issue)

This is an attempt of gathering references to everything concerned by the new protocol. The list will be edited to be kept updated. To keep this issue helpfull instead of just becoming yet another place to discuss things, please keep specialized discussion in the relevant issue.

Administriva

Core protocol

  • Decide what to do with TAO
  • Decide how ID fields should look like
  • Decide how dsdl version info should be conveyed over the wire
  • Decide where the tail byte should be put in the existence of padding
  • Decide where CRC should be put in the existence of padding
  • Settle on whether CRC should include data type signature (or other forms of compatibility analyzis).
    • Transfer CRC should not include any compatibility checks
  • Settle on how the protocol version should be conveyed over the wire
    • Initial value of the toggle bit and a designated bit in the CAN ID (for CAN transports)

DSDL

  • What to do with the old compatibility concepts (normalization and dsdl signatures)
    • Signatures and normalization will be removed as a concept.
  • Figure out how we handle deprecations of definitions.
    • Directive @deprecated (#10)
  • Figure out if we should do anything to namespacing of dsdl
    • Domain-specific namespaces are considered unnecessary #3
  • Figure out what limitations we should put on code compatibility
    • Follow the discussion (#9)

DSDL string type

We will need native support for strings in UAVCAN v1.1 or later to avoid ambiguity like:

uint8[<=100] text

Backport the LaTeX style fixes from zubaxdoc.cls

This is what the spec should be formatted like when built correctly:

image

This is what I'm getting after downloading build artifacts from GitLab:

image

Section headers are offset from the left for some reason, which breaks alignment and makes the doc look sloppy. I think it's important that we get consistent results on local machines and from the CI, otherwise, we might accidentally publish a bad doc.

DSDL enumeration type

In Cyphal v1.1 or later we will need native support for enumeration types to improve type safety. This could be implemented through an additional directive like (this is not a formal proposal):

@enumeration
uint11 FIRST = auto
uint11 SECOND = auto

Proposed: New High-Level Definition of UAVCAN

image

Changes:

  1. Core data types are distinct and required.
  2. Standard data types (e.g. equipment) are distinct and optional.
  3. Custom data types are first class members of the specification.
  4. The interface between the serialization of data types and the transport layer is well-defined.

Item 4 was controversial from the google group start of this proposal but I still think there is value to allowing for a different data serialization layer to sit on top of some UAVCAN implementations (e.g. using libuavcan but not DSDL). I'd like to at least propose it for the record here in our specification repository.

Rigorous definition of semantic compatibility and bit compatibility

So I was writing the new spec doc and got stuck at the semantic and binary compatibility part. I'm leaving the lab right now with the intention of getting back to this first thing in the morning. @kjetilkjeka if you happened to have good definitions at hand, please share here.

This is what I ended up drafting so far:

\section{Data type compatibility and versioning}\label{sec:dsdl_versioning}

\subsection{Rationale}

As can be seen from the preceding sections,
the concept of \emph{data type} is a cornerstone feature of UAVCAN,
which sets it apart from many competing solutions.

In order to be able to interoperate successfully,
all nodes connected to the same bus must use compatible definitions of all employed data types.
This section is dedicated to the concepts of \emph{data type compatibility}
and \emph{data type versioning}.

A \emph{data type} is a named set of data structures defined in DSDL.
As has been explained above, in the case of message data types,
the set consists of just one data structure, whereas in the case of service data types
the set is a pair of request and response data structures.

Data type definitions may evolve over time as they are refined to better address the needs of their applications.
In order to formalize the data type evolution process with respect to the data type compatibility concerns,
UAVCAN introduces two concepts: \emph{semantic compatibility} and \emph{binary compatibility},
which are discussed below.

\subsection{Semantic compatibility}

\subsection{Binary compatibility}

Review the data type compatibility rules

Semantic compatibility is hard to determine automatically. Consider replacing semantic compatibility with a stricter alternative similar to polymorphic compatibility. This will make type punning impossible.

Redundant interfaces

@pavel-kirienko I have a couple of questions regarding the redundant interfaces.

  1. Do we have to require the users to let the first one time out before using the next one. Wouldn't an implementation where the interface where the message is received first on was used and then detection of a lost interface could be done even after the message was received on the "backup" interface.
  2. Do we need every node to use the same interface as number 1. and number 2. If we have nodes that didn't require redundancy wouldn't it be perfectly fine to split them on the two interfaces for load sharing reasons?

Fixed-point scalar types

@jschall once proposed to add those to the set of native DSDL types:

Can we use a floating point standard that matches IEEE 754 for 16, 32, 64 and 128-bit floats, but also provides for arbitrary bit lengths of floating point fields? I've got a spot where I'd like to use a 24-bit float, but there isn't really any support for it.
Actually what I really want to use here is fixed point Q16.8 - because I want uniform precision for this field. This keeps coming up, again and again and again, and I'd really like built-in support for it.
I can't make it a 32-bit float without spilling into another CAN frame

To which I said:

while I do like the idea in general, it seems like too much work right now, and besides there are questions on how to represent fixed-point numbers in generated DSDL classes. In Python there is support for fixed-point arithmetics in the standard library; but what about libuavcan. We'll have to either cast fixed-point numbers to floats, which pretty much defeats the purpose, or we'll need to code up custom fixed-point arithmetic classes (I know that many modern MCU support fixed-point in hardware, but the solution has to be generic). Overall I'm not sure if this feature is worth the extra complexity, at least right now.

This issue is to attract relevant discussion and feedback.

In this thread over there there was also a related discussion on how to represent the elements of rotation quaternions in the most efficient and usable way; fixed-point types could be applied there greatly: OpenCyphal/public_regulated_data_types#34

Define and Utilize Domain-Specific Namespaces

Domain-Specific Namespaces are sets of pre-defined messages/data-types for various types of Unmanned Autonomous Vehicles. To start with the standard should define the following DSNs:

  • core – Domain-agnostic data types supporting standard functions.
  • aero - Existing non-protocol data-types would live in this set.
  • marine – data-types for autonomous boats or submarines.
  • space – data-types for satellites and other spacecraft.
  • ground - For autonomous rovers, cars, or other land-based vehicles.

Review of the chapters 1, 2, and 3

Here comes an early draft for an early review. This PDF is compiled directly from the current master: UAVCAN_Specification.pdf

I would like @kjetilkjeka and @thirtytwobits to have a critical look. I am going to review everything once again when the content is finished to fix the remaining styling and wording issues.

The DSDL chapter is rather different from what is published on the website right now: TAO is gone, and the serialization section is moved up.

Add section numbers to pdf bookmarks

It'd be helpful to have the section numbers in the index. As the below image shows, it's not easy to do something like "go to section 3" without them:

Screen Shot 2019-04-16 at 10 21 48 AM

Replace "message broadcasting" with "message publication"

We need to replace "message broadcasting" with "message publication", because "broadcasting" does not suit the purpose well; after all, we are not addressing all existing nodes in the network; rather, we are allowing nodes to opt-in into receiving our data.

I already changed this in all chapters of the specification except the DSDL chapter, which is currently being edited by @kjetilkjeka.

CAN ID bit layout Figure 4.3

Figure 4.3 Shows the CAN ID bit layout.

There's is a typo in the first table table stating "Service, not message" whereas it's a Message, thus it should note "Message, not service"

Application-level functions: sensor timestamping

About a year ago there was a thread on the ArduPilot forum about sensor lags and related issues. From that thread I learned that certain concepts need to be spelled out in the specification:

  • How timestamping should be used instead of sensor lag estimates.
  • How sensor feed timestamping should take into account the own data processing latency on the local node.

Formal mechanism for migrating a message definition between namespaces (renaming)

Context: https://forum.uavcan.org/t/uavcan-v1-0-and-ardupilot/671

@thirtytwobits: Pavel, what do you think of defining a formal mechanism for migrating a message definition to a different namespace while maintaining compatibility with the existing one? Ultimately names shouldn’t matter on the wire so the only thing that prevents this is a lookup that can tolerate duplicate definitions when the duplicates are compatible.

@pavel-kirienko: As I just posted above, nothing prevents one from migrating a data type from one namespace into another (unless you are using an experimental transport that uses the data type hash), but I don’t think the use cases where this would be actually needed are common.

@tridge [new inputs here, update your models]: the reason for moving it is social/political. The original messages are in the namespaces of startups that don’t necessarily want their name to be ensconced forever in the message used across the industry. When they develop the message to solve a problem they are not thinking ahead to when they want it to get into an upstream implementation, they are just trying to hit a deadline for a shipping product. Later when they start caring about working with others we want to move responsibility for the message into a longer term organisation namespace.

This issue is the result of the above exchange. We need to mention in the specification that it's legal to rename a data type, including its relocation into a different namespace. Right now it's semi-illegal.

Note to our future selves: this change invalidates the proposal for the data type hash that I introduced here: https://forum.uavcan.org/t/alternative-transport-protocols/324. New proposals are welcome.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.