DOCSEARCHbyAlgolia
Submit Docs

Luos Documentation

website·Indexed 33 days ago

https://www.luos.io/

Documentation for the Luos engine and Robus network, covering software node management, service creation, and message handling. Includes technical details on the Robus protocol (versions 3.0.0 and 3.1.0), topology management, transmission/reception, and the JSON API for interacting with gate services.

Tokens
97.1K
Snippets
327
Records
700
Agent score
66%

What's inside Luos

  1. Overview of Robus network layer for Luos

    Robus is a deterministic, real-time network layer designed for the Luos engine (separated as a package since version 3.0.0). It is optimized for low-cost, compact networks using raw half-duplex physical buses (such as OneWire, RS485, or MLVDS).

    Key capabilities include:

    • Multipoint communication
    • Deterministic topological detection
    • Message acknowledgement and timestamping
    • Low overhead (4 or 5 bytes on top of Luos)
    • High performance: approximately 700 kb/s on a 45Mhz MCU (requiring ~3.8K FLASH and 0.3K RAM).

  2. Overview of the Luos Bootloader system

    The Luos bootloader allows for remote firmware updates of nodes in a Luos network without requiring physical access or specialized programming tools. The system consists of three components: a CLI tool on a computer to manage updates, a gate service that translates CLI commands into Luos network commands, and bootloader code flashed onto each node. The update process uses a Publisher/Subscriber model where nodes subscribe to a specific topic to receive binary firmware data.

  3. Overview of Luos embedded software architecture

    Luos provides a modular software architecture and methodology for designing, testing, and deploying embedded applications. It applies the concept of microservices to embedded systems by encapsulating hardware and software functions into independent containers and APIs. This hardware abstraction allows developers to evolve products by function, simplify the creation of product lines, and capitalize on past developments without worrying about communication protocols between components.

  4. Overview of the Robus network protocol

    Robus is the native network protocol for the Luos engine, designed to route messages using the engine's own message structure. It is optimized for low memory footprint, controlled RAM consumption, and minimal CPU usage, making it suitable for low-cost, compact networks. The protocol is designed to be highly deterministic and real-time.

  5. Overview of the Luos Gate service

    The Gate is an embedded app service that translates Luos architecture data into a convenient format (usually JSON) for standard software. It allows developers to control embedded services from any machine using languages like Python (via Pyluos) or ROS. The Gate must be used in conjunction with a pipe driver service, which handles the physical communication layer (e.g., Serial, WiFi, Bluetooth, Lora).

  6. Overview of Luos distributed computing architecture

    Luos provides a framework that allows developers to split code into smaller pieces that can be executed across several microcontrollers. The system abstracts the physical location of the program, making it available on a network and removing the need for developers to manually implement inter-microcontroller communication. This approach mimics the behavior of a single CPU while distributing the workload across multiple hardware units to improve safety, speed, and maintainability.

  7. Overview of the Luos Engine

    The Luos engine is an embedded, lightweight, and real-time ANSI C code library used to manage services across nodes. It is not an operating system and can be used with or without one. It provides a simple API for creating, managing, and interacting with services. The engine is open-source under the Apache 2.0 license.

  8. Overview of Luos system architecture goals

    Luos provides a technology designed to connect every part and function of electronic devices into a single system image. The goal is to move away from vertical development toward a horizontal, collaborative model based on modularity. Key capabilities include:

    • Grouping functionalities into standard, easy-to-use coding objects.
    • Providing isolation between software and hardware to simplify the transition from prototype to industrial versions.
    • Optimizing process distribution across sub-assemblies and allowing the relocation of algorithms (e.g., to the cloud).
    • Supporting dynamic adaptation to the addition or removal of sub-assemblies (e.g., changing tools) for easier maintenance and evolution.

  9. Overview of the Luos embedded bootloader

    The Luos library provides a built-in bootloader designed to overcome the limitations of conventional MCU-specific bootloaders. It acts as a network orchestrator for systems composed of one or several boards, allowing firmware updates across different MCU brands without requiring individual physical access (such as JTAG or SWD) to every board in the system. Key features include:

    • Brand Agnosticism: Works the same way for any MCU supported by the Luos library.
    • Flexible Placement: The bootloader can be placed anywhere in the MCU's flash memory, removing constraints related to fixed memory maps.
    • Remote Updates: Enables updating a network of boards through a single access point rather than requiring a physical connection to each individual board.
    • Efficiency: Optimized for speed to reduce update duration, particularly for distributed systems with numerous boards running the same firmware during prototyping.

  10. Overview of Luos architecture and purpose

    Luos is a software library for embedded systems (supporting both bare metal and operating systems) that applies microservices architecture to electronic devices. It enables modularity in real-time electronics by encapsulating embedded applications into 'containers'. This allows developers to treat hardware functions (e.g., a camera or wheels) as reusable 'bricks' that can be plugged together and communicate with each other, moving away from traditional monolithic firmware development.

  11. Overview of Luos development and debugging tools

    Luos provides several tools to assist in the development and maintenance of embedded products:

    • Inspector: A debug interface used to log events across a product at a nanosecond scale to monitor system behavior.
    • Luos Manager: A tool for companies to manage hardware development, including bug tracking during development and post-production.
    • SAAS Tools: A registry for storing and sharing developed Luos services.

  12. Overview of Luos technology

    Luos is a software platform designed to shorten the time-to-market, reduce costs, and minimize the resources required to develop electronic devices and robots. It enables a microservices architecture for embedded systems, where each software function is treated as a microservice that may utilize hardware. The technology is designed to be chip-agnostic and focuses on modularity to simplify the development of complex electronic devices containing multiple microcontrollers.