Merge branch 'main' of https://github.com/arduino/docs-content into 91volt/nesso-n1-fix-cloud-editor-reference

Author: 91volt

content/hardware/02.uno/boards/uno-q/tutorials/01.user-manual/content.md

@@ -785,22 +785,109 @@ The `Bridge` library provides a communication layer built on top of the `Arduino
 - **MPU side (Qualcomm QRB, Linux)**: Runs higher-level services and can remotely invoke MCU functions.
 - **MCU side (STM32, Zephyr RTOS)**: Handles time-critical tasks and exposes functions to the MPU via RPC.
 
+#### The Arduino Router (Infrastructure)
+
+Under the hood, the communication is managed by a background Linux service called the Arduino Router (`arduino-router`).
+
+While the `Bridge` library is what you use in your code, the Router is the traffic controller that makes it possible. It implements a **Star Topology** network using MessagePack RPC.
+
+**Key Features:**
+
+- **Multipoint Communication:** Unlike simple serial communication (which is typically point-to-point), the Router allows multiple Linux processes to communicate with the MCU simultaneously (and with each other).
+
+  **Linux ↔ MCU:** Multiple Linux processes can interact with the MCU simultaneously (e.g., a Python® script reading sensors while a separate C++ application commands motors).
+
+  **Linux ↔ Linux:** You can use the Router to bridge different applications running on the MPU. For example, a Python script can expose an RPC function that another Python® or C++ application calls directly, allowing services to exchange data without involving the MCU at all.
+
+- **Service Discovery:** Clients (like your Python® script or the MCU Sketch) "register" functions they want to expose. The Router keeps a directory of these functions and routes calls to the correct destination.
+
+**Managing the Router Service**
+
+The arduino-router runs automatically as a system service. In most cases, you do not need to interact with it directly. However, if you are debugging advanced issues or need to restart the communication stack, you can control it via the Linux terminal:
+
+**Check Status** To see if the router is running and connected:
+```bash
+systemctl status arduino-router
+```
+**Restart the Service** If the communication seems stuck, you can restart the router without rebooting the board:
+```bash
+sudo systemctl restart arduino-router
+```
+**View Logs** To view the real-time logs for debugging (e.g., to see if RPC messages are being rejected or if a client has disconnected):
+```bash
+journalctl -u arduino-router -f
+```
+
+To capture more detailed information in the logs, you can append the `--verbose` argument to the systemd service configuration.
+
+- Open the service file for editing:
+  ```bash
+  sudo nano /etc/systemd/system/arduino-router.service
+  ```
+
+- Locate the line beginning with `ExecStart=` and append `--verbose` to the end of the command. The updated service file should look like this:
+
+  ```bash
+  [Unit]
+  Description=Arduino Router Service
+  After=network-online.target
+  Wants=network-online.target
+  Requires=
+
+  [Service]
+  # Put the micro in a ready state.
+  ExecStartPre=-/usr/bin/gpioset -c /dev/gpiochip1 -t0 37=0
+  ExecStart=/usr/bin/arduino-router --unix-port /var/run/arduino-router.sock --serial-port /dev/ttyHS1 --serial-baudrate 115200 --verbose # <--- ADD THIS
+  # End the boot animation after the router is started.
+  ExecStartPost=/usr/bin/gpioset -c /dev/gpiochip1 -t0 70=1
+  StandardOutput=journal
+  StandardError=journal
+  Restart=always
+  RestartSec=3
+
+  [Install]
+  WantedBy=multi-user.target
+  ```
+
+- You must reload the systemd daemon for the configuration changes to take effect.
+
+  ```bash
+  sudo systemctl daemon-reload
+  ```
+
+- Restart the Router:
+  
+  ```bash
+  sudo systemctl restart arduino-router
+  ```
+
+- View the verbose logs:
+  
+  ```bash
+  journalctl -u arduino-router -f
+  ```
+
 #### Core Components
 
-`BridgeClass`
-- Main class managing RPC clients and servers. Provides methods to:
-- Initialize the bridge (`begin()`)
-- Call remote procedures (`call()`)
-- Notify without waiting for a response (`notify()`)
-- Expose local functions for remote execution (`provide()`, `provide_safe()`)
-- Process incoming requests (`update()`)
+`BridgeClass` The main class managing RPC clients and servers.
+- `begin()`: Initializes the bridge and the internal serial transport.
+- `call(method, args...)`: Invokes a function on the Linux side and waits for a result.
+- `notify(method, args...)`: Invokes a function on the Linux side without waiting for a response (fire-and-forget).
+- `provide(name, function)`: Exposes a local MCU function to Linux. Note: The function executes in the high-priority background RPC thread. Keep these functions short and thread-safe.
+- `provide_safe(name, function)`: Exposes a local MCU function, but ensures it executes within the main `loop()` context. Use this if your function interacts with standard Arduino APIs (like `digitalWrite` or `Serial`) to avoid concurrency crashes.
+
+***__Warning:__ Do not use `Bridge.call()` or `Monitor.print()` inside `provide()` functions. Initiating a new communication while responding to one causes system deadlocks.***
 
+`RpcCall`
+- Helper class representing an asynchronous RPC. If its `.result` method is invoked, it waits for the response, extracts the return value, and propagates error codes if needed.
 
-`RpcResult`
-- Helper class representing the result of a remote call. It waits for the response, extracts the return value, and propagates error codes if needed.
+`Monitor` 
+- The library includes a pre-defined Monitor object. This allows the Linux side to send text streams to the MCU (acting like a virtual Serial Monitor) via the RPC method mon/write.
 
 **Threading and Safety**
 - The bridge uses Zephyr mutexes (`k_mutex`) to guarantee safe concurrent access when reading/writing over the transport. Updates are handled by a background thread that continuously polls for requests.
+- **Incoming Updates**: Handled by a dedicated background thread (`updateEntryPoint`) that continuously polls for requests.
+- **Safe Execution**: The provide_safe mechanism hooks into the main loop (`__loopHook`) to execute user callbacks safely when the processor is idle.
 
 #### Usage Example
 

content/hardware/09.kits/maker/nesso-n1/datasheet/datasheet.md

@@ -10,7 +10,11 @@ type: maker
 
 <p style="text-align: justify;">Arduino® Nesso N1 (hereafter Nesso N1) is a compact, all-in-one IoT development kit powered by the ESP32-C6 microcontroller, a single-core 32-bit RISC-V CPU running at up to 160 MHz. Designed for remote monitoring and automation applications, Nesso N1 combines multiple wireless protocols, such as Wi-Fi® 6, Bluetooth® 5.3, Thread®, and LoRa® into a sleek, portable form factor with an integrated 1.14" touch display and rechargeable 250 mAh battery. Built-in sensors include a 6-axis IMU, passive buzzer, and infrared transmitter, with expansion capabilities through Grove, Qwiic, and M5StickC HAT-compatible connectors.</p>
 
-<p style="text-align: justify;">Nesso N1 can be programmed using Arduino IDE, MicroPython, or UIFlow, and integrates seamlessly with Arduino Cloud for remote device management and data visualization. With comprehensive documentation, ready-to-use examples, and compatibility with Arduino Modulino® nodes and third-party accessories, Nesso N1 accelerates the development of connected devices for smart homes, industrial automation, and environmental monitoring.</p>
+<p style="text-align: justify;">Nesso N1 can be programmed using Arduino IDE, MicroPython, or UIFlow* (2.0), and integrates seamlessly with Arduino Cloud for remote device management and data visualization. With comprehensive documentation, ready-to-use examples, and compatibility with Arduino Modulino® nodes and third-party accessories, Nesso N1 accelerates the development of connected devices for smart homes, industrial automation, and environmental monitoring.</p>
+
+<div style="background-color: rgba(255, 193, 7, 0.2); border-left: 6px solid rgba(255, 152, 0, 1); margin: 20px 0; padding: 15px;">
+  <strong>* UIFlow v2.0 Support:</strong> UIFlow support is not yet available. Support will be available by the end of Q4 2025.
+</div>
 
 # Target Areas
 
@@ -350,21 +354,27 @@ Use the limits below to define the operating environment, thermal margins, and p
 
 <div style="page-break-after: always;"></div>
 
-## Device Operation
+### Programming Options
 
-### Getting Started - IDE
+Nesso N1 supports multiple programming methods:
 
-If you want to program your Nesso N1 while offline you need to install the Arduino® Desktop IDE **[1]**. To connect the Nesso N1 to your computer, you will need a Type-C® USB cable, which can also provide power to the board, as indicated by the green power LED (LED1).
+- **Arduino IDE** [1]
+- **MicroPython**
+- **UIFlow v2.0***
 
-### Getting Started - Arduino Cloud Editor
+<div style="background-color: rgba(255, 193, 7, 0.2); border-left: 6px solid rgba(255, 152, 0, 1); margin: 20px 0; padding: 15px;">
+  <strong>* UIFlow v2.0 Support:</strong> UIFlow support is not yet available. UIFlow v2.0 support is on the way for Nesso N1, with availability expected by the end of Q4 2025. This will provide a visual programming interface for rapid prototyping and educational applications.
+</div>
+
+## Device Operation
 
-All Arduino boards, including this one, work out-of-the-box on the Arduino® Cloud Editor **[2]**, by just installing a simple plugin.
+### Getting Started - IDE
 
-The Arduino Cloud Editor is hosted online, therefore it will always be up-to-date with the latest features and support for all boards. Follow **[2]** to start coding on the browser and upload your sketches onto your board.
+If you want to program your Nesso N1 while offline you need to install the Arduino® Desktop IDE **[1]**. To connect the Nesso N1 to your computer, you will need a Type-C® USB cable, which can also provide power to the board, as indicated by the green power LED (LED1).
 
 ### Getting Started - Arduino Cloud
 
-All Arduino IoT enabled products are supported on Arduino Cloud which allows you to log, graph and analyze sensor data, trigger events, and automate your home or business.
+All Arduino IoT enabled products are supported on Arduino Cloud **[2]** which allows you to log, graph and analyze sensor data, trigger events, and automate your home or business.
 
 ### Online Resources
 
@@ -492,14 +502,15 @@ Hereby, Arduino S.r.l. declares that this product is in compliance with essentia
 | No. | Reference                      | Link                                                                                     |
 |:---:|--------------------------------|------------------------------------------------------------------------------------------|
 |  1  | Arduino IDE (Desktop)          | [https://www.arduino.cc/en/Main/Software](https://www.arduino.cc/en/Main/Software)       |
-|  2  | Arduino IDE (Cloud)            | [https://create.arduino.cc/editor](https://create.arduino.cc/editor)                     |
+|  2  | Arduino Cloud                  | [https://cloud.arduino.cc/](https://cloud.arduino.cc/)                                   |
 |  3  | Arduino Nesso N1 Documentation | [https://docs.arduino.cc/hardware/nesso-n1/](https://docs.arduino.cc/hardware/nesso-n1/) |
 |  4  | Project Hub                    | [https://create.arduino.cc/projecthub](https://create.arduino.cc/projecthub)             |
 |  5  | Library Reference              | [https://github.com/arduino-libraries/](https://github.com/arduino-libraries/)           |
 |  6  | Arduino Store                  | [https://store.arduino.cc/](https://store.arduino.cc/)                                   |
 
 ## Document Revision History
 
-|  **Date**  | **Revision** | **Changes**   |
-|:----------:|:------------:|---------------|
-| 14/10/2025 |      1       | First release |
+|  **Date**  | **Revision** | **Changes**                           |
+|:----------:|:------------:|---------------------------------------|
+| 20/11/2025 |     1.1      | Added UIFlow v2.0 support information |
+| 14/10/2025 |      1       | First release                         |

content/hardware/11.accessories/modulino-nodes/modulino-thermo/datasheet/datasheet.md

@@ -111,9 +111,8 @@ These pads and the Qwiic connectors share the same I2C bus. You can optionally s
 ### I2C Address Reference
 | **Board Silk Name** | **Sensor** | **Modulino® I2C Address (HEX)** | **Editable Addresses (HEX)**             | **Hardware I2C Address (HEX)** |
 |---------------------|-----------|--------------------------------|------------------------------------------|--------------------------------|
-| MODULINO THERMO     | HS3003    | 0x44                           | Any custom address (via software config) | 0x44                           |
+| MODULINO THERMO     | HS3003    | 0x44                           | Custom address not supported | 0x44                           |
 
-**Note:** Default address is **0x44**. Adjustments may be made via software if multiple identical sensors are on the same bus.
 
 ## Device Operation
 The Modulino® Thermo node acts as an I2C target device on the Qwiic bus. Simply connect it via a Qwiic cable to the 3.3 V I2C interface of your microcontroller. Read humidity and temperature values via standard I2C transactions.
@@ -201,6 +200,7 @@ Operation is subject to the following two conditions:
 # Revision History
 | **Date**   | **Revision** | **Changes**          |
 | ---------- | ------------ | -------------------- |
+| 24/11/2025 | 5            | I2C information changed        |
 | 01/07/2025 | 4            | Certification        |
 | 17/06/2025 | 3            | Nomenclature updates |
 | 23/05/2025 | 2            | Power info           |