Руководство пользователя Arduino UNO Q

Узнайте об аппаратных и программных возможностях платы Arduino® UNO Q.

Автор: Christopher Méndez

Последняя редакция: 16.03.2026

Обзор 

Данное руководство пользователя проведёт вас через практическое изучение наиболее интересных возможностей Arduino UNO Q. С его помощью вы научитесь настраивать, конфигурировать и использовать эту плату Arduino.

Требования к оборудованию и программному обеспечению 

Требования к оборудованию 

(1x) UNO Q 2GB или UNO Q 4GB
Кабель USB-C® (1x)
Мультипортовый адаптер USB-C (донгл) с внешним питанием (1x)

Примечание

Вы можете использовать любой донгл USB-C с возможностью внешнего питания, кроме адаптеров Apple.

Требования к программному обеспечению 

Arduino App Lab 0.1.23+

Примечание

Вы также можете использовать Arduino IDE 2+ для программирования только микроконтроллерной (MCU) части вашего UNO Q.

Обзор продукта 

Arduino UNO Q открывает новый уровень производительности для экосистемы Arduino, сочетая мощные вычислительные возможности продвинутого микропроцессора (MPU) Qualcomm QRB2210, работающего под полноценной ОС Debian Linux с поддержкой upstream, и отклик в реальном времени выделенного микроконтроллера (MCU) STM32U585, выполняющего скетчи Arduino на базе Zephyr OS — всё на одном одноплатном компьютере.

Обзор архитектуры платы 

Arduino UNO Q сочетает высокопроизводительный MPU Qualcomm® QRB2210, работающий в полноценной среде Linux, с точностью реального времени MCU STMicroelectronics® STM32U585 (32-бит Arm® Cortex®-M33) — всё на одной компактной плате. Эта гибридная архитектура обеспечивает мощность и отзывчивость, необходимые для AIoT, машинного обучения и продвинутых приложений автоматизации.

Ниже представлен обзор основных компонентов платы, показанных на изображении выше:

Микропроцессор: Qualcomm® QRB2210 — четырёхъядерный процессор Arm® Cortex®-A53 с частотой 2.0 ГГц, оснащённый GPU Adreno™ 702 (845 МГц) для 3D-графики и двумя ISP, поддерживающими до 25 Мп при 30 fps. Работает под управлением Debian Linux OS с поддержкой upstream, что делает его идеальным для встроенного зрения и периферийных вычислений.
Микроконтроллер: MCU STM32U585 с ядром Arm® Cortex®-M33, работающим на частоте до 160 МГц, 2 МБ флеш-памяти и 786 КБ SRAM. Работает под управлением Zephyr OS, обеспечивая безопасную и эффективную платформу для низкопотребляющих встраиваемых приложений.
Беспроводная связь: Радиомодуль WCBN3536A обеспечивает двухдиапазонный Wi-Fi® 5 (2.4/5 ГГц) и Bluetooth® 5.1 с встроенными антеннами для надёжной беспроводной работы.
Память: Плата оснащена eMMC-хранилищем на 16 ГБ или 32 ГБ и LPDDR4 RAM на 2 ГБ или 4 ГБ, обеспечивая быстрый доступ к памяти и надёжное хранение для встраиваемых приложений.
Мультимедийный кодек: ANX7625 обеспечивает вывод видео и аудио через встроенный разъём USB-C, предоставляя высокоскоростной интерфейс для передачи изображения и звука во встраиваемых приложениях.
Управление питанием: UNO Q включает Qualcomm® PM4145 — интегральную микросхему управления питанием (PMIC), отвечающую требованиям постоянно подключённых IoT-устройств.

Распиновка 

Полная распиновка доступна для скачивания в формате PDF по ссылке ниже:

Полная распиновка UNO Q

Даташит 

Полный даташит доступен для скачивания в формате PDF по ссылке ниже:

Даташит UNO Q

Схемы 

Полные схемы доступны для скачивания в формате PDF по ссылке ниже:

Схемы UNO Q

STEP-файлы 

Полные STEP-файлы доступны для скачивания по ссылке ниже:

STEP-файлы UNO Q

Форм-фактор 

Arduino UNO Q имеет классический форм-фактор UNO, обеспечивающий совместимость с широким спектром шилдов UNO, разработанных нами и сообществом за всё время.

Первое использование 

Питание платы 

Arduino UNO Q может быть запитан от:

Кабеля USB-C®, обеспечивающего 5 В постоянного тока 3 А (не входит в комплект).
Внешнего источника питания +5 В постоянного тока, подключённого к пину 5V.
Внешнего источника питания +7-24 В постоянного тока, подключённого к пину VIN.

Совет

Нажмите здесь, чтобы узнать больше о спецификациях питания UNO Q.

Установка Arduino App Lab 

Arduino App Lab — это единая среда разработки, расширяющая классический опыт Arduino в мир высокопроизводительных вычислений. Arduino App Lab позволяет беспрепятственно комбинировать скетчи Arduino, скрипты Python и контейнеризированные Linux-приложения в единый рабочий процесс.

С помощью строительных блоков кода, называемых Bricks, предварительно настроенных моделей ИИ и интегрированной оркестрации, среда снижает сложность, позволяя создавать всё — от простых прототипов до продвинутых, вычислительно интенсивных приложений.

Arduino App Lab поставляется предустановленным на UNO Q и может использоваться в режиме одноплатного компьютера (SBC). Мы настоятельно рекомендуем вариант UNO Q с 4 ГБ RAM для лучшего автономного опыта.

Чтобы установить его на персональный компьютер для настройки PC Hosted, перейдите в раздел программного обеспечения на нашем официальном сайте, прокрутите до Arduino App Lab и выберите вариант для вашей ОС.

Сетевой режим 

Даже если вы настроили Arduino UNO Q как одноплатный компьютер, вы можете получить к нему удалённый доступ с персональной машины, используя десктопное приложение Arduino App Lab и Сетевой режим. Оба режима могут использоваться одновременно.

Когда вы откроете Arduino App Lab, ваша плата появится с тегом Network, если она может быть обнаружена в вашей локальной сети.
Нажмите на неё и введите пароль Linux для входа.
Теперь у вас будет удалённый доступ к плате.

С помощью этого метода вы можете получить доступ к UNO Q с любой машины в вашей локальной сети. Это позволяет использовать Arduino App Lab так, как если бы вы были подключены напрямую к плате, где вы можете разрабатывать и запускать приложения так же, как при подключении через USB-C®.

Сетевой режим использует обнаружение в локальной сети (mDNS) для автоматического поиска плат в той же сети. Некоторые сетевые конфигурации, такие как гостевой Wi-Fi, корпоративные или IoT-сети, VPN или строгие правила файрволла, могут предотвратить автоматическое обнаружение, даже если плата подключена к Wi-Fi.

Устранение проблем с обнаружением

Пользователи Windows: При первом запуске Arduino App Lab вы можете получить запрос от Windows Defender (или другого ПО безопасности) относительно mdns-discovery.exe. Вы должны разрешить этот доступ, чтобы плата могла быть обнаружена. Примечание: Запрос может не появиться на системах, где ранее уже запускалась Arduino IDE.
Настройки файрволла: Если плата не появляется, убедитесь, что ваш файрволл разрешает трафик на UDP-порту 5353, который необходим для обнаружения mDNS.

Примечание

Возможность доступа к плате через браузер, SSH или IP-адрес не гарантирует, что она появится в Сетевом режиме. Arduino App Lab использует обнаружение в локальной сети для автоматического отображения плат.

Настройка Linux-хоста (обязательно для пользователей Linux)

Если вы используете UNO Q с хост-машины на Linux, вам необходимо настроить разрешения USB-устройств для вашей учётной записи. Без правильных разрешений несколько операций могут завершиться неудачей, что приведёт к раздражающим ошибкам.

Когда Arduino App Lab пытается подключиться к плате через USB, подключение завершится неудачно без видимых ошибок. Вам может потребоваться проверить консоль DevTools, чтобы увидеть фактическое сообщение об ошибке о недостаточных разрешениях устройства.

Аналогично, если вы попытаетесь прошить новый образ на плату, процесс завершится со следующей ошибкой:

Та же ошибка возникнет при попытке связи с платой через ADB-команды, такие как adb shell.

Понимание разрешений 

По умолчанию USB-устройства в Linux доступны только пользователю root или пользователям в определённых группах. Когда UNO Q подключается к компьютеру, он создаёт файлы USB-устройств, обычно в каталоге:

/dev/bus/usb/

Для взаимодействия требуются права на запись.

UNO Q поддерживает два режима USB, каждый со своим USB-идентификатором. В обычном режиме плата использует USB VID 2341 и PID 0078.

Когда вам нужно прошить прошивку платы, она переходит в режим аварийной загрузки (EDL), который использует USB VID 05c6 и PID 9008. Оба режима требуют правильных разрешений для корректной работы.

Установка правил udev 

Правильный способ настройки необходимых разрешений для вашей учётной записи — через правила udev.

udev — это подсистема Linux, управляющая узлами устройств в каталоге /dev. Следующие правила udev предоставят вашей учётной записи доступ к UNO Q:

# Operating mode
SUBSYSTEMS=="usb", ATTRS{idVendor}=="2341", ATTRS{idProduct}=="0078", MODE="0660", TAG+="uaccess"
# EDL mode
SUBSYSTEMS=="usb", ATTRS{idVendor}=="05c6", ATTRS{idProduct}=="9008", MODE="0660", TAG+="uaccess"

Выполните эту команду для установки необходимых правил udev:

echo \
'# Operating mode
SUBSYSTEMS=="usb", ATTRS{idVendor}=="2341", ATTRS{idProduct}=="0078", MODE="0660", TAG+="uaccess"
# EDL mode
SUBSYSTEMS=="usb", ATTRS{idVendor}=="05c6", ATTRS{idProduct}=="9008", MODE="0660", TAG+="uaccess"' \
| \
  sudo \
    tee \
      "/etc/udev/rules.d/60-Arduino-UNO-Q.rules" \
&& \
sudo \
  udevadm control \
    --reload-rules \
&& \
sudo \
  udevadm trigger

Эта команда выполняет несколько операций последовательно. Сначала она создаёт файл правил и записывает правила udev в:

/etc/udev/rules.d/60-Arduino-UNO-Q.rules

Префикс 60- определяет порядок обработки правил, где меньшие числа означают более высокий приоритет. Файлы в каталоге /etc/udev/rules.d/ являются пользовательскими переопределениями, которые сохраняются при обновлениях системы.

Каждое правило сопоставляет USB-устройства на основе определённых критериев. Параметр SUBSYSTEMS=="usb" ограничивает применение правила только USB-устройствами.

Параметры ATTRS{idVendor} и ATTRS{idProduct} идентифицируют UNO Q по уникальным USB-идентификаторам производителя и продукта. Параметр MODE="0660" устанавливает разрешения файла устройства, позволяя владельцу и группе читать и записывать на устройство.

Параметр TAG+="uaccess" предоставляет доступ текущему вошедшему в систему пользователю через systemd-logind.

После создания файла правил команда перезагружает все правила udev, выполняя:

udevadm control --reload-rules

Это указывает udev перезагрузить все файлы правил без необходимости перезагрузки системы.

Команда udevadm trigger повторно обрабатывает все существующие устройства с новыми загруженными правилами, гарантируя, что любые текущие подключённые платы UNO Q получат правильные разрешения.

Проверка установки 

С помощью следующей команды проверьте, что правила установлены корректно:

cat /etc/udev/rules.d/60-Arduino-UNO-Q.rules

Она должна отобразить два правила udev, которые вы только что установили.

Чтобы проверить, обнаружен ли UNO Q, можно использовать следующую команду:

lsusb | grep -E "2341:0078|05c6:9008"

Когда плата подключена в рабочем режиме, вы должны увидеть вывод, подобный следующему:

Применение изменений 

После установки правил udev необходимо отключить и повторно подключить плату, чтобы изменения вступили в силу.

Отключите UNO Q от компьютера и подождите несколько секунд. Затем снова подключите плату. Новые разрешения будут применены автоматически при повторном подключении платы.

Если у вас были открыты какие-либо приложения при установке правил, такие как Arduino App Lab или терминал с ADB-командами, вам следует закрыть и перезапустить их после повторного подключения платы. Это позволит приложениям корректно обнаружить плату с новыми разрешениями.

Для ADB-команд можно использовать следующее:

adb devices

Эта команда отображает список всех устройств Android Debug Bridge, подключённых к вашей системе. Ваш UNO Q должен появиться в списке без сообщений об ошибках.

Следующая команда может быть использована для доступа к UNO Q:

adb shell

Альтернативный способ установки 

Вы можете использовать официальный скрипт post-install из репозитория Arduino Core Zephyr для автоматической настройки этих разрешений. Этот скрипт выполняет ту же установку правил udev, что и ручной метод, описанный выше.

Чтобы скачать и запустить скрипт post-install, перейдите в каталог Downloads и используйте wget для загрузки скрипта из репозитория:

cd ~/Downloads

wget https://raw.githubusercontent.com/arduino/ArduinoCore-zephyr/main/post_install.sh

chmod +x post_install.sh

sudo ./post_install.sh

Если wget недоступен в вашей системе, вы можете использовать curl вместо него:

cd ~/Downloads

curl -O https://raw.githubusercontent.com/arduino/ArduinoCore-zephyr/main/post_install.sh

chmod +x post_install.sh

sudo ./post_install.sh

sudo ~/.arduino15/packages/arduino/hardware/zephyr/<version>/post_install.sh

В качестве альтернативы вы можете клонировать весь репозиторий и запустить скрипт оттуда:

cd ~/Downloads

git clone https://github.com/arduino/ArduinoCore-zephyr.git

cd ArduinoCore-zephyr

chmod +x post_install.sh

sudo ./post_install.sh

При запросе введите свой пароль. Скрипт создаст файл правил udev, перезагрузит правила udev и применит их к любым текущим подключённым устройствам, так же как при ручном способе установки.

После запуска скрипта вы можете проверить установку с помощью той же команды, показанной в разделе ручной установки:

cat /etc/udev/rules.d/60-arduino-zephyr.rules

Обратите внимание, что скрипт создаёт файл с именем 60-arduino-zephyr.rules, а не 60-Arduino-UNO-Q.rules, но он содержит те же правила разрешений для обоих режимов работы.

После установки правил udev любым из способов отключите плату UNO Q от компьютера, подождите несколько секунд, затем подключите её снова. Это позволит применить новые разрешения. После повторного подключения вы можете перейти к следующим шагам процесса прошивки.

Пример Hello World 

Давайте запрограммируем UNO Q с классическим примером Hello World, типичным для экосистемы Arduino: скетч Blink. Мы используем этот пример, чтобы убедиться, что плата правильно подключена к Arduino App Lab.

Необходимые условия:

Arduino UNO Q
Кабель USB-C
Компьютер с доступом в интернет (режим PC-hosted)
Монитор, клавиатура, мышь и донгл USB-C (режим одноплатного компьютера)
Подключите UNO Q к компьютеру (если вы не в режиме одноплатного компьютера).

Откройте Arduino App Lab, он откроется в разделе Examples.

Откройте пример Blink LED (прочитайте документацию примера, чтобы понять, как работает приложение).
Нажмите кнопку Run в правом верхнем углу и дождитесь загрузки приложения.

Теперь вы должны увидеть, как красный светодиод встроенного RGB-светодиода включается на одну секунду, затем выключается на одну секунду, и так повторяется.

Примечание

Светодиод, управляемый в этом примере, контролируется микроконтроллером STM32 через скетч Arduino.

Запуск приложения при старте 

Вы можете настроить определённое приложение для автоматического запуска при каждом включении UNO Q. Это полезно для автономных проектов, где плата работает без подключения к компьютеру.

Примечание

Вы не можете назначить встроенный пример (Example) как стартовое приложение напрямую из пользовательского интерфейса. Сначала необходимо нажать Copy and edit app из примера или создать новое приложение (App) с нуля.

Откройте ваше пользовательское приложение (или копию примера).
Найдите кнопку Run в правом верхнем углу.
Нажмите стрелку (▼) рядом с кнопкой Run, чтобы открыть меню.
Переключите переключатель Run at startup в положение ON.

После настройки рядом с именем вашего приложения появится значок DEFAULT, указывающий, что оно будет запускаться автоматически при загрузке.

Использование CLI (продвинутый уровень)

Как альтернативу, вы можете установить приложение по умолчанию, используя интерфейс командной строки (CLI) внутри терминала UNO Q:

arduino-app-cli properties set default user:<NAME_OF_YOUR_APP>

Arduino IDE (бета)

Arduino UNO Q совместим со стандартной Arduino IDE, позволяя программировать плату с использованием привычного языка и экосистемы Arduino.

Важно

Arduino UNO Q имеет двухпроцессорную архитектуру. Arduino IDE нацелена на программирование только микроконтроллера UNO Q (STM32). Если вы хотите программировать микропроцессор Qualcomm, обратитесь к разделу Arduino App Lab.

Установка ядра UNO Q 

Для начала работы с платой вам необходимо сначала установить специальное ядро, поддерживающее архитектуру UNO Q (на основе Zephyr).

Откройте Arduino IDE.
Перейдите в Tools > Board > Boards Manager… или нажмите иконку Boards Manager в левой боковой панели.
В строке поиска введите UNO Q.
Найдите Arduino UNO Q Zephyr Core и нажмите Install.

Совет

Устранение неполадок: Если ядро не отображается в результатах поиска, вам может потребоваться добавить пакет вручную. Перейдите в File > Preferences и добавьте следующую ссылку в поле Additional Boards Manager URLs:

https://downloads.arduino.cc/packages/package_zephyr_index.json

Установите библиотеку Arduino_RouterBridge, перейдя в Library Manager в левом меню IDE. Установите её со всеми зависимостями.

Hello World (Blink)

После установки ядра вы можете проверить, что всё работает, загрузив классический скетч Blink.

Выберите плату: Перейдите в Tools > Board > Arduino UNO Q Board и выберите Arduino UNO Q.
Выберите порт: Подключите плату через USB-C. Перейдите в Tools > Port и выберите порт, соответствующий вашему UNO Q.
Откройте пример: Перейдите в File > Examples > 01.Basics > Blink.
Загрузите: Нажмите кнопку Upload (иконка стрелки вправо) на верхней панели инструментов.

IDE скомпилирует скетч и загрузит его на микроконтроллер STM32. Теперь вы должны увидеть, как красный светодиод встроенного RGB-светодиода включается на одну секунду, затем выключается на одну секунду, и так повторяется.

Встроенный пользовательский интерфейс 

Arduino UNO Q предлагает широкий набор пользовательских интерфейсов, делающих взаимодействие интуитивным и простым.

Матрица светодиодов 

Одна из ключевых особенностей платы — матрица синих светодиодов 8×13, управляемая микроконтроллером STM32 UNO Q.

Это универсальный дисплей, который можно использовать для отображения данных, индикаторов состояния, иконок или даже для создания простых анимаций и игр.

Вот список базовых примеров использования матрицы светодиодов. Для их тестирования выполните следующие шаги:

Подключите UNO Q к компьютеру (если вы не в режиме одноплатного компьютера).

Откройте Arduino App Lab, перейдите в My Apps и нажмите Create new app+.

Для тестирования каждого из приведённых ниже примеров необходимо создать новое приложение (App).

Рисование изображения 

Этот пример предназначен для рисования пользовательских кадров на матрице светодиодов, в частности логотипа Arduino.

Вы можете скопировать и вставить следующий пример в часть «sketch» вашего нового приложения в Arduino App Lab.

#include <Arduino_LED_Matrix.h>

uint8_t logo[104] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,1,1,1,0,0,0,1,1,1,0,0,
    0,1,0,0,0,1,0,1,0,0,0,1,0,
    1,0,0,0,0,0,1,0,0,1,0,0,1,
    1,0,1,1,1,0,1,0,1,1,1,0,1,
    1,0,0,0,0,0,1,0,0,1,0,0,1,
    0,1,0,0,0,1,0,1,0,0,0,1,0,
    0,0,1,1,1,0,0,0,1,1,1,0,0
};

Arduino_LED_Matrix matrix;

void setup() {
  matrix.begin();
  // display the image
  matrix.setGrayscaleBits(1);
  matrix.draw(logo);
}

void loop() {
}

В Arduino App Lab это должно выглядеть следующим образом:

Вы можете создать свой собственный кадр, создав массив по формату матрицы (8x13) с 1 и 0, как в примере выше:

Запустите приложение, нажав кнопку Run в Arduino App Lab, и вы должны увидеть, как матрица светодиодов отображает ваш кадр:

Регулируемые светодиоды 

Матрица светодиодов поддерживает 8 уровней яркости (3 бита), поэтому вы можете управлять яркостью каждого светодиода индивидуально.

Вы можете установить биты яркости функцией setGrayscaleBits(bits), как показано ниже:

matrix.setGrayscaleBits(3); // 3 бита дают 8 уровней яркости (0 до 7)

Стандартные инструменты конверсии в оттенки серого используют 256 уровней (8 бит), поэтому вы можете использовать и этот диапазон — он будет автоматически преобразован.

matrix.setGrayscaleBits(8); // 8 бит дают 256 уровней яркости (0 до 255)

Этот пример показывает поддерживаемые уровни яркости матрицы светодиодов.

Вы можете скопировать и вставить следующий пример в часть «sketch» вашего нового приложения в Arduino App Lab.

#include <Arduino_LED_Matrix.h>

uint8_t shades[104] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,
    1,1,1,1,1,1,1,1,1,1,1,1,1,
    2,2,2,2,2,2,2,2,2,2,2,2,2,
    3,3,3,3,3,3,3,3,3,3,3,3,3,
    4,4,4,4,4,4,4,4,4,4,4,4,4,
    5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7
};

Arduino_LED_Matrix matrix;

void setup() {
  matrix.begin();
  // display the image
  matrix.setGrayscaleBits(3);
  matrix.draw(shades);
}

void loop() {
}

Запустите приложение, нажав кнопку Run в Arduino App Lab, и вы должны увидеть, как матрица светодиодов отображает ваш кадр:

Работающий пример матрицы светодиодов с оттенками

RGB-светодиоды 

UNO Q оснащён 4 RGB-светодиодами. Два из них подключены и управляются микропроцессором Qualcomm, а остальные два — микроконтроллером STM32.

Светодиоды, управляемые MPU 

Светодиоды #1 и #2 управляются MPU.

Для управления этими светодиодами существует специальный LED-интерфейс в нашей ОС Linux — они могут управляться через /sys/class/leds из командной строки, используя SSH, соединение ADB с терминала ПК или через встроенное терминальное приложение Linux при использовании в режиме одноплатного компьютера:

echo 1    | tee /sys/class/leds/red:user/brightness   # установить HIGH/ON
echo 0    | tee /sys/class/leds/red:user/brightness   # установить LOW/OFF

Цветовые сегменты светодиодов определены следующим образом:

Светодиод 1:

Красный: red:user
Зелёный: green:user
Синий: blue:user

Светодиод 2:

Красный: red:panic
Зелёный: green:wlan
Синий: blue:bt

Примечание

Светодиод 2 используется для отображения состояния системы: PANIC, WLAN и BT. Но он также может управляться пользователем.

Вы также можете управлять этими светодиодами из Python-скрипта следующим образом. Не забудьте создать новое приложение (App) в Arduino App Lab, затем скопируйте и вставьте скрипт ниже в раздел python вашего приложения:

import time

from arduino.app_utils import App

LED1_R = "/sys/class/leds/red:user/brightness"
LED1_G = "/sys/class/leds/green:user/brightness"
LED1_B = "/sys/class/leds/blue:user/brightness"

LED2_R = "/sys/class/leds/red:panic/brightness"
LED2_G = "/sys/class/leds/green:wlan/brightness"
LED2_B = "/sys/class/leds/blue:bt/brightness"

def set_led_brightness(led_file, value):
    try:
        with open(led_file, "w") as f:
            f.write(f"{value}\n")
    except Exception as e:
        print(f"Error writing to {led_file}: {e}")

# turn off all LEDs
set_led_brightness(LED1_R, 0)
set_led_brightness(LED1_G, 0)
set_led_brightness(LED1_B, 0)
set_led_brightness(LED2_R, 0)
set_led_brightness(LED2_G, 0)
set_led_brightness(LED2_B, 0)

def loop():
    #blink the LED 1 RED segment
    set_led_brightness(LED1_R, 1)
    time.sleep(1)
    set_led_brightness(LED1_R, 0)
    time.sleep(1)

App.run(user_loop=loop)

Вы также можете управлять этими светодиодами, используя их специальный Linux-модуль Leds следующим образом:

# Аргументы соответствуют цветам R, G и B соответственно
Leds.set_led1_color(1,0,0) # Светодиод 1 красный
Leds.set_led2_color(1,0,0) # Светодиод 2 красный

Не забудьте создать новое приложение (App) в Arduino App Lab, затем скопируйте и вставьте скрипт ниже в раздел python вашего приложения:

import time
from arduino.app_utils import App
from arduino.app_utils import Leds

def loop():
    # Blink LED 1 in red
    # Turn on the LED red segment(1, 0, 0)
    Leds.set_led1_color(1,0,0)
    time.sleep(1)

    # Turn off the LED (0, 0, 0)
    Leds.set_led1_color(0,0,0)
    time.sleep(1)

App.run(user_loop=loop)

Светодиоды, управляемые MCU 

Светодиоды #3 и #4 управляются MCU.

Они могут управляться установкой состояния соответствующих GPIO с помощью функции digitalWrite как обычно.

Для их тестирования выполните следующие шаги:

Подключите UNO Q к компьютеру (если вы не в режиме одноплатного компьютера).
Откройте Arduino App Lab, перейдите в My Apps и нажмите Create new app+.

Вы можете скопировать и вставить следующий пример в часть «sketch» вашего нового приложения в Arduino App Lab.

void setup(){
  // Configure the pins as outputs
  pinMode(LED3_R, OUTPUT);
  pinMode(LED3_G, OUTPUT);
  pinMode(LED3_B, OUTPUT);
  // As they are active low, turn them OFF initially
  digitalWrite(LED3_R, HIGH);
  digitalWrite(LED3_G, HIGH);
  digitalWrite(LED3_B, HIGH);
}

void loop(){
  digitalWrite(LED3_R, LOW);  // Turn ON red segment
  digitalWrite(LED3_G, HIGH);
  digitalWrite(LED3_B, HIGH);
  delay(1000);
  digitalWrite(LED3_R, HIGH);
  digitalWrite(LED3_G, LOW);  // Turn ON green segment
  digitalWrite(LED3_B, HIGH);
  delay(1000);
  digitalWrite(LED3_R, HIGH);
  digitalWrite(LED3_G, HIGH);
  digitalWrite(LED3_B, LOW);  // Turn ON blue segment
  delay(1000);
}

Цветовые сегменты светодиодов определены следующим образом:

Светодиод 3:

Красный: LED3_R
Зелёный: LED3_G
Синий: LED3_B

Светодиод 4:

Красный: LED4_R
Зелёный: LED4_G
Синий: LED4_B

Важно

RGB-светодиоды имеют активный низкий уровень — это означает, что они включаются при логическом „0“.

Аппаратный интерфейс отладки UART 

UNO Q предоставляет выделенный низкоуровневый UART-интерфейс для отладки и системной диагностики. Этот интерфейс подключается напрямую к главной консоли SoC (TTY), позволяя наблюдать за логами загрузки и ядра, устранять системные неполадки или получать доступ к оболочке до того, как станут доступны сетевые службы, такие как SSH или ADB.

Этот интерфейс доступен через разъём JCTL на UNO Q. Обратитесь к разделу распиновки для получения деталей и следуйте примеру подключения выше для доступа.

Предупреждение

Этот интерфейс работает на логических уровнях 1.8 В и должен использоваться с совместимым USB-to-TTL преобразователем во избежание повреждения оборудования.

Необходимые условия 

USB-to-TTL преобразователь на 1.8 В (например, DSD Tech SH-U09C5)
Кабель USB-C для питания UNO Q
Программа-терминал (например, Tera Term)

Параметры UART:

Скорость передачи: 115200 бит/с
Логический уровень: 1.8 В

Эта консоль обеспечивает доступ к низкоуровневым системным сообщениям, выводимым загрузчиками (например, SPL и U-Boot), которые не видны через SSH или другие высокоуровневые интерфейсы. Например, она позволяет захватывать логи, связанные с согласованием доставки питания или инициализацией оборудования на ранних стадиях загрузки, предоставляя информацию, которая иначе недоступна.

Она может использоваться для входа в систему платы и взаимодействия с системой через оболочку. Используйте учётные данные Linux, настроенные в процессе первоначальной настройки платы, для аутентификации.

Кнопка питания 

UNO Q оснащён кнопкой питания, которую можно использовать для перезагрузки платы.

Длительное нажатие: Linux-часть платы перезагружается при нажатии кнопки более 5 секунд.

Примечание

Вам не нужно нажимать кнопку питания для включения платы — она загружается автоматически после подачи питания.

Разъём USB-C 

UNO Q оснащён разъёмом USB-C, который может использоваться для гораздо большего, чем просто программирование и питание платы.

Ниже приведена таблица с основными возможностями разъёма USB-C, расширяющими функциональность UNO Q.

Функция	Описание
Питание USB (Sink)	5 В пост. тока 3 А (15 Вт)
Стандарт USB	USB 3.1 Gen 1 (5 Гбит/с)
Дисплей через USB-C	DisplayPort

С помощью донгла USB-C (адаптера/хаба) вы также можете использовать следующие возможности:

Функция	Описание
Видеовыход	Поддержка HDMI
Видеовход	Поддержка USB-камеры
Аудио	USB или 3.5 мм гарнитура (динамик + микрофон)
Ethernet	Поддержка интернета через Ethernet
HID	USB-клавиатура/мышь и другие HID-устройства
Хранилище	Поддержка внешней карты microSD или USB-накопителя

Пины 

UNO Q оснащён двумя типами разъёмов: классическими колодками в стиле UNO сверху, предназначенными для прототипирования и отладки, обеспечивающими полную совместимость с шилдами Arduino UNO, и высокоскоростными колодками снизу, специально созданными для интеграции с носителями UNO Q.

Цифровые пины 

UNO Q имеет 47 цифровых пинов, управляемых микроконтроллером STM32, 22 из которых доступны через разъём в стиле UNO и 25 через разъём JMISC, распределённых следующим образом:

Пин микроконтроллера	Маппинг пинов Arduino	Функциональность пина
PB7	D0 / RX	GPIO / UART RX
PB6	D1 / TX	GPIO / UART TX
PB3	D2	GPIO
PB0	D3	GPIO / OPAMP OUT
PA12	D4 / FDCAN1_TX	GPIO / CAN Bus TX
PA11	D5 / FDCAN1_RX	GPIO / CAN Bus RX
PB1	D6	GPIO
PB2	D7	GPIO
PB4	D8	GPIO
PB8	D9	GPIO
PB9	D10 / SS	GPIO / SPI SS
PB15	D11 / MOSI	GPIO / SPI MOSI
PB14	D12 / MISO	GPIO / SPI MISO
PB13	D13 / SCK	GPIO / SPI SCK
PA4	D14 / DAC0	GPIO / ADC / DAC
PA5	D15 / DAC1	GPIO / ADC / DAC
PA6	D16	GPIO / ADC / OPAMP IN +
PA7	D17	GPIO / ADC / OPAMP IN -
PC1	D18 / SDA2	GPIO / ADC / I2C SDA
PC0	D19 / SCL2	GPIO / ADC / I2C SCL
PB11	D20 / SDA	GPIO / I2C SDA
PB10	D21 / SCL	GPIO / I2C SCL

Примечание

Обратите внимание, что пины D14–D19 также имеют аналоговые возможности.

Цифровые пины UNO Q могут использоваться как входы или выходы через встроенные функции языка программирования Arduino.

Настройка цифрового пина выполняется в функции setup() с помощью встроенной функции pinMode(), как показано ниже:

// Пин настроен как вход
pinMode(pin, INPUT);
// Пин настроен как выход
pinMode(pin, OUTPUT);
// Пин настроен как вход, внутренний подтягивающий резистор включён
pinMode(pin, INPUT_PULLUP);

Состояние цифрового пина, настроенного как вход, можно прочитать с помощью встроенной функции digitalRead(), как показано ниже:

// Читаем состояние пина, сохраняем значение в переменную state
state = digitalRead(pin);

Состояние цифрового пина, настроенного как выход, можно изменить с помощью встроенной функции digitalWrite(), как показано ниже:

// Включаем пин
digitalWrite(pin, HIGH);
// Выключаем пин
digitalWrite(pin, LOW);

Пример кода, показанный ниже, использует цифровой пин D5 для управления светодиодом и считывает состояние кнопки, подключённой к цифровому пину D4:

Пример подключения цифрового ввода-вывода

Создайте новое приложение в Arduino App Lab.

Установите библиотеку Arduino_RouterBridge, нажав Add Sketch Library и найдя её.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

#include <Arduino_RouterBridge.h>
// Define button and LED pin
int buttonPin = D4;
int ledPin = D5;

// Variable to store the button state
int buttonState = 0;

void setup() {
  // Configure button and LED pins
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);

  // Initialize Serial communication
  Monitor.begin();
}

void loop() {
  // Read the state of the button
  buttonState = digitalRead(buttonPin);

  // If the button is pressed, turn on the LED and print its state to the Serial Monitor
  if (buttonState == LOW) {
    digitalWrite(ledPin, HIGH);
    Monitor.println("- Button is pressed. LED is on.");
  } else {
    // If the button is not pressed, turn off the LED and print to the Serial Monitor
    digitalWrite(ledPin, LOW);
    Monitor.println("- Button is not pressed. LED is off.");
  }

  // Wait for 1000 milliseconds
  delay(1000);
}

Аналоговые пины 

UNO Q имеет хорошо знакомые аналоговые пины в разъёме JANALOG; подробнее ниже:

Аналого-цифровой преобразователь (АЦП)

В разъёме JANALOG UNO Q имеет 6 14-битных АЦП-пинов, распределённых следующим образом:

Пин микроконтроллера	Маппинг пинов Arduino	Функциональность пина
PA4	A0	GPIO / ADC / DAC
PA5	A1	GPIO / ADC / DAC
PA6	A2	GPIO / ADC / OPAMP IN +
PA7	A3	GPIO / ADC / OPAMP IN -
PC1	A4	GPIO / ADC / I2C SDA
PC0	A5	GPIO / ADC / I2C SCL

Аналоговые входные пины могут использоваться через встроенные функции языка программирования Arduino.

Разрешение АЦП UNO Q может быть настроено на 14, 12, 10 или 8 бит с помощью функции analogReadResolution(bits):

// Разрешение АЦП установлено на 14 бит (0 до 16383)
analogReadResolution(14);

Опорное напряжение АЦП по умолчанию составляет 3.3 В и может быть изменено программно с помощью функции analogReference() со следующими аргументами:

Аналоговое опорное напряжение (VREF+)	Аргумент	Источник
1.5 В	AR_INTERNAL1V5	Внутренний
1.8 В	AR_INTERNAL1V8	Внутренний
2.048 В	AR_INTERNAL2V05	Внутренний
2.5 В	AR_INTERNAL2V5	Внутренний
2 В ~ VDD	AR_EXTERNAL	Внешний

Примечание

Внешнее опорное напряжение может быть подано через пин AREF при использовании ссылки AR_EXTERNAL.

Для установки отличного от стандартного аналогового опорного напряжения смотрите следующий пример:

analogReference(AR_INTERNAL2V5);

Пример кода ниже считывает аналоговое входное значение с потенциометра, подключённого к A0, и отображает его в Serial Monitor. Для понимания правильного подключения потенциометра к UNO Q используйте следующее изображение как ссылку:

Создайте новое приложение в Arduino App Lab.

Установите библиотеку Arduino_RouterBridge, нажав Add Sketch Library и найдя её.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

#include <Arduino_RouterBridge.h>

int sensorPin = A0;   // select the input pin for the potentiometer

int sensorValue = 0;  // variable to store the value coming from the sensor

void setup() {
  Monitor.begin();
}

void loop() {
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin);

  Monitor.println(sensorValue);
  delay(100);
}

Цифро-аналоговый преобразователь (ЦАП)

UNO Q имеет два выхода ЦАП, распределённых следующим образом:

Пин микроконтроллера	Маппинг пинов Arduino	Функциональность пина
PA4	DAC0	GPIO / ADC / DAC
PA5	DAC1	GPIO / ADC / DAC

Цифро-аналоговые преобразователи UNO Q могут использоваться для вывода аналогового напряжения через встроенные функции языка программирования Arduino.

Разрешение выхода ЦАП может быть настроено от 8 до 12 бит с помощью функции analogWriteResolution() следующим образом:

// Разрешение ЦАП установлено на 12 бит (0 до 4095)
analogWriteResolution(12);  // введите желаемое разрешение в битах (8, 10, 12)

Для вывода аналогового напряжения через пин ЦАП используйте функцию analogWrite() с каналом ЦАП в качестве аргумента. Смотрите пример ниже:

analogWrite(DAC0, value);   // значение должно быть в диапазоне разрешения ЦАП (например, 0-4095 при 12-битном разрешении)

Примечание

Если в функцию analogWrite() передан обычный GPIO, на выходе будет ШИМ-сигнал.

Следующий скетч создаст синусоидальный сигнал 60 Гц на пине A0/DAC0 UNO Q:

Создайте новое приложение в Arduino App Lab.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

const float freq = 60.0f;
const int   N    = 256;     // 256 samples/cycle
const uint32_t Ts_us = (uint32_t)llroundf(1e6f / (freq * N));

uint16_t lut[N]; // store the sine wave here

void setup() {
  analogWriteResolution(12);

  for (int i = 0; i < N; ++i){
      lut[i] = 2048 + (1000.0 * sin(2 * PI * i / N));
  }
}

void loop() {
  static uint32_t t_next = micros();
  for (int i = 0; i < N; ++i) {
    analogWrite(DAC0, lut[i]);  // output the sine wave values
    t_next += Ts_us;
    while ((int32_t)(micros() - t_next) < 0) { /* spin */ }
  }
}

Выход ЦАП должен выглядеть следующим образом:

Пины ШИМ 

UNO Q имеет 6 пинов ШИМ (широтно-импульсной модуляции), распределённых следующим образом:

Пин микроконтроллера	Маппинг пинов Arduino	Функциональность пина
PB0	D3	GPIO / OPAMP OUT / PWM
PA11	D5 / FDCAN1_RX	GPIO / CAN Bus RX / PWM
PB1	D6	GPIO / PWM
PB8	D9	GPIO / PWM
PB9	D10 / SS	GPIO / SPI SS / PWM
PB15	D11 / MOSI	GPIO / SPI MOSI / PWM

Эта функциональность может использоваться со встроенной функцией analogWrite(), как показано ниже:

analogWrite(pin, value);

По умолчанию разрешение выхода составляет 8 бит, поэтому значение должно быть между 0 и 255. Для установки большего разрешения используйте встроенную функцию analogWriteResolution, как показано ниже:

// Разрешение ШИМ установлено на 10 бит (0 до 4095)
analogWriteResolution(10);

Вот пример создания ШИМ-сигнала с переменным коэффициентом заполнения:

Создайте новое приложение в Arduino App Lab.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

const int analogInPin = A0;  // Analog input pin that the potentiometer is attached to
const int pwmOutPin = D3;    // PWM output pin

int sensorValue = 0;  // value read from the pot
int outputValue = 0;  // value output to the PWM (analog out)

void setup() {
  // Define the PWM output resolution
  analogWriteResolution(10);  // 0 - 1023 -> 0 - 100% duty-cycle
  analogReadResolution(14);   // 0 - 16383
}

void loop() {
  // read the analog in value:
  sensorValue = analogRead(analogInPin);
  // map it to the range of the analog out:
  outputValue = map(sensorValue, 0, 16383, 0, 1024);
  // change the analog out value:
  analogWrite(pwmOutPin, outputValue);

  // wait 2 milliseconds before the next loop for the ADC
  // to settle after the last reading:
  delay(2);
}

Теперь вы можете управлять коэффициентом заполнения ШИМ-сигнала, поворачивая потенциометр.

Примечание

Частота ШИМ фиксирована на 500 Гц.

Коммуникация 

Этот раздел руководства пользователя охватывает различные протоколы связи, поддерживаемые Arduino UNO Q.

Bridge — библиотека удалённого вызова процедур (RPC)

Arduino UNO Q использует RPC (Remote Procedure Call) для обмена данными между Linux-стороной (Qualcomm MPU) и MCU STM32 реального времени. Этот механизм позволяет функциям, работающим на одном процессоре, вызываться прозрачно с другого, как если бы они были локальными вызовами.

Обзор 

Библиотека Bridge предоставляет коммуникационный слой, построенный поверх фреймворка Arduino_RPClite. Она управляет двунаправленным RPC-трафиком между MPU и MCU, обрабатывая привязку методов, переадресацию запросов и асинхронные ответы.

Сторона MPU (Qualcomm QRB, Linux): Выполняет сервисы более высокого уровня и может удалённо вызывать функции MCU.
Сторона MCU (STM32, Zephyr RTOS): Обрабатывает задачи, критичные по времени, и предоставляет функции MPU через RPC.

Arduino Router (инфраструктура)

Под капотом коммуникация управляется фоновой службой Linux, называемой Arduino Router (arduino-router).

В то время как библиотека Bridge — это то, что вы используете в своём коде, Router — это контроллер трафика, который делает это возможным. Он реализует сетевую звёздную топологию с использованием MessagePack RPC.

Ключевые особенности:

Многоточечная связь: В отличие от простой последовательной связи (которая обычно является точка-точка), Router позволяет нескольким Linux-процессам взаимодействовать с MCU одновременно (и друг с другом).
- Linux <-> MCU: Несколько Linux-процессов могут взаимодействовать с MCU одновременно (например, Python-скрипт читает датчики, а отдельное C++-приложение управляет моторами).
- Linux <-> Linux: Вы можете использовать Router для связи различных приложений, работающих на MPU. Например, Python-скрипт может предоставить RPC-функцию, которую другое Python- или C++-приложение вызывает напрямую, позволяя службам обмениваться данными без участия MCU.
Обнаружение сервисов: Клиенты (такие как ваш Python-скрипт или скетч MCU) «регистрируют» функции, которые хотят предоставить. Router ведёт каталог этих функций и маршрутизирует вызовы к правильному назначению.

Исходный код:

Конфигурация системы и аппаратные интерфейсы 

Router управляет физическим соединением между двумя процессорами. Важно знать, какие аппаратные ресурсы заняты Router, чтобы избежать конфликтов в ваших собственных приложениях.

Сторона Linux (MPU): Router занимает последовательное устройство /dev/ttyHS1.
Сторона MCU (STM32): Router занимает аппаратный последовательный порт Serial1.

Предупреждение

Зарезервированные ресурсы. Не пытайтесь открыть /dev/ttyHS1 (в Linux) или Serial1 (в Arduino/Zephyr) в своём собственном коде. Эти интерфейсы эксклюзивно заблокированы службой arduino-router. Попытка прямого доступа к ним приведёт к отказу Bridge.

Управление службой Router 

arduino-router автоматически запускается как системная служба. В большинстве случаев вам не нужно взаимодействовать с ним напрямую. Однако, если вы отлаживаете продвинутые проблемы или вам нужно перезапустить стек связи, вы можете управлять им через Linux-терминал:

Проверка состояния. Чтобы увидеть, работает ли router и подключён ли он:

systemctl status arduino-router

Перезапуск службы. Если связь кажется зависшей, вы можете перезапустить router без перезагрузки платы:

sudo systemctl restart arduino-router

Просмотр логов. Для просмотра логов в реальном времени при отладке (например, чтобы увидеть, отклоняются ли RPC-сообщения или отключился ли клиент):

journalctl -u arduino-router -f

Для захвата более подробной информации в логах вы можете добавить аргумент --verbose в конфигурацию systemd-службы.

Откройте файл службы для редактирования:

sudo nano /etc/systemd/system/arduino-router.service

Найдите строку, начинающуюся с ExecStart=, и добавьте --verbose в конец команды. Обновлённый файл службы должен выглядеть так:

[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

Вы должны перезагрузить демон systemd, чтобы изменения конфигурации вступили в силу.

sudo systemctl daemon-reload

Перезапустите Router:

sudo systemctl restart arduino-router

Просмотрите подробные логи:

journalctl -u arduino-router -f

Основные компоненты 

BridgeClass — основной класс, управляющий RPC-клиентами и серверами.

begin() — инициализирует bridge и внутренний последовательный транспорт.
call(method, args...) — вызывает функцию на стороне Linux и ожидает результат.
notify(method, args...) — вызывает функцию на стороне Linux без ожидания ответа (fire-and-forget).
provide(name, function) — предоставляет локальную функцию MCU стороне Linux. Примечание: Функция выполняется в фоновом RPC-потоке высокого приоритета. Делайте эти функции короткими и потокобезопасными.
provide_safe(name, function) — предоставляет локальную функцию MCU, но гарантирует её выполнение в контексте основного loop(). Используйте это, если ваша функция взаимодействует со стандартными Arduino API (такими как digitalWrite или Serial), чтобы избежать сбоев из-за конкурентного доступа.

Предупреждение

Не используйте Bridge.call() или Monitor.print() внутри функций provide(). Инициирование нового обмена данными во время ответа на текущий вызывает системные взаимоблокировки (deadlock).

RpcCall — вспомогательный класс, представляющий асинхронный RPC. Если вызвать его метод .result, он дождётся ответа, извлечёт возвращаемое значение и передаст коды ошибок при необходимости.

Monitor — библиотека включает предопределённый объект Monitor. Это позволяет стороне Linux отправлять текстовые потоки на MCU (действуя как виртуальный Serial Monitor) через RPC-метод mon/write.

Потоки и безопасность

Bridge использует мьютексы Zephyr (k_mutex) для гарантии безопасного конкурентного доступа при чтении/записи через транспорт. Обновления обрабатываются фоновым потоком, который непрерывно опрашивает запросы.
Входящие обновления: Обрабатываются выделенным фоновым потоком (updateEntryPoint), который непрерывно опрашивает запросы.
Безопасное выполнение: Механизм provide_safe подключается к основному циклу (__loopHook) для безопасного выполнения пользовательских обратных вызовов, когда процессор свободен.

Пример использования (Arduino App Lab)

Этот пример показывает, как сторона Linux (Qualcomm QRB) переключает светодиод на MCU (STM32), вызывая удалённую функцию через Bridge.

Создайте новое приложение в Arduino App Lab.

Скопируйте и вставьте примеры ниже в части «Python» и «sketch» вашего нового приложения соответственно.

Пример Linux (QRB) для вызова удалённой функции MCU

Этот Python-скрипт выполняется на QRB и вызывает RPC-функцию MCU set_led_state раз в секунду:

# main.py (QRB side)
from arduino.app_utils import *
import time

led_state = False

def loop():
    global led_state
    time.sleep(1)
    led_state = not led_state
    Bridge.call("set_led_state", led_state)

App.run(user_loop=loop)

Скрипт отправляет булево значение на MCU каждую секунду с помощью Bridge.call("set_led_state", <bool>).

MCU (STM32) — настройка Bridge

Этот скетч включает библиотеку Bridge и настраивает пин светодиода.

#include "Arduino_RouterBridge.h"

void setup() {
    pinMode(LED_BUILTIN, OUTPUT);

    Bridge.begin();
    Bridge.provide("set_led_state", set_led_state);
}

void loop() {
}

void set_led_state(bool state) {
    // LOW state means LED is ON
    digitalWrite(LED_BUILTIN, state ? LOW : HIGH);
}

Этот скетч регистрирует локальную функцию MCU set_led_state как RPC-сервис с именем "set_led_state", чтобы сторона Linux (QRB) могла вызывать её удалённо, как если бы она была локальной, с помощью Bridge.provide("set_led_state", set_led_state);.

Совет

Вы можете сделать то же самое в обратном направлении — Python-функции могут быть предоставлены скетчу MCU для локального использования.

После вставки Python-скрипта в файл Python вашего приложения и кода Arduino в скетч, вы можете запустить приложение и наблюдать, как светодиод #3 мигает красным каждую секунду.

Совет

В библиотеке Bridge RPC есть более продвинутые методы, которые вы можете открыть, тестируя различные встроенные примеры внутри Arduino App Lab.

Взаимодействие через Unix Socket (продвинутый уровень)

Linux-процессы обмениваются данными с Router через Unix Domain Socket, расположенный по адресу: /var/run/arduino-router.sock.

В то время как библиотека Bridge обрабатывает это автоматически, вы можете вручную подключиться к этому сокету для взаимодействия с MCU или другими Linux-сервисами, используя любой язык, поддерживающий MessagePack RPC (например, Python, C++, Rust, Go).

Пример использования (пользовательский Python-клиент)

Следующий пример демонстрирует, как управлять функцией MCU (set_led_state) из стандартного Python-скрипта, используя библиотеку msgpack без вспомогательных классов Arduino App Lab. Это полезно для интеграции функций Arduino в существующие Linux-приложения.

Необходимые условия:

Прошейте скетч MCU

Загрузите следующий код с помощью Arduino IDE или Arduino App Lab. Он регистрирует функцию, которую мы хотим вызвать.

#include "Arduino_RouterBridge.h"

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);

  Bridge.begin();
  // We use provide_safe to ensure the hardware call runs in the main loop context
  Bridge.provide_safe("set_led_state", set_led_state);
}

void loop() {
}

void set_led_state(bool state) {
  digitalWrite(LED_BUILTIN, state ? LOW : HIGH);
}

Установите зависимость Python

Установите библиотеку msgpack с помощью системного менеджера пакетов:

sudo apt install python3-msgpack

Создайте Python-скрипт

Создайте новый файл с именем msgpack_test.py:

nano msgpack_test.py

Добавьте содержимое скрипта

Скопируйте и вставьте следующий код. Этот скрипт вручную подключается к Unix-сокету Router и отправляет необработанный RPC-запрос.

import socket
import msgpack
import sys

# 1. Define the connection to the Router's Unix Socket
SOCKET_PATH = "/var/run/arduino-router.sock"

# 2. Parse command line arguments
# Default to turning LED ON (True) if no argument is provided
led_state = True

if len(sys.argv) > 1:
    arg = sys.argv[1]
    if arg == "1":
        led_state = True
    elif arg == "0":
        led_state = False
    else:
        print("Usage: python3 msgpack_test.py [1|0]")
        sys.exit(1)

print(f"Sending request to set LED: {led_state}")

# 3. Create the MessagePack RPC Request
# Format: [type=0 (Request), msgid=1, method="set_led_state", params=[led_state]]
request = [0, 1, "set_led_state", [led_state]]
packed_req = msgpack.packb(request)

# 4. Send the request
try:
    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
        client.connect(SOCKET_PATH)
        client.sendall(packed_req)

        # 5. Receive the response
        response_data = client.recv(1024)
        response = msgpack.unpackb(response_data)

        # Response Format: [type=1 (Response), msgid=1, error=None, result=None]
        print(f"Router Response: {response}")

except Exception as e:
    print(f"Connection failed: {e}")

Запуск примера

Теперь вы можете протестировать подключение, запустив скрипт из терминала и передав 1 (ON) или 0 (OFF):

python3 msgpack_test.py 1 # чтобы включить светодиод
# или
python3 msgpack_test.py 0 # чтобы выключить светодиод

Пример пользовательского Python для Router

SPI 

UNO Q поддерживает SPI-связь, что позволяет передавать данные между платой и другими SPI-совместимыми устройствами.

Пины, используемые в UNO Q для протокола связи SPI:

Пин микроконтроллера	Маппинг пинов Arduino
PB9	SS / D10
PB15	MOSI / D11
PB14	MISO / D12
PB13	SCK / D13

Обратитесь к разделу распиновки руководства пользователя для их определения на плате.

Включите библиотеку SPI в начале вашего скетча для использования протокола связи SPI. Библиотека SPI предоставляет функции для SPI-связи:

#include <SPI.h>

В функции setup() инициализируйте библиотеку SPI, определите и настройте пин выбора чипа (SS):

#define SS D10

void setup() {
  // Set the chip select pin as output
  pinMode(SS, OUTPUT);

  // Pull the SS pin HIGH to unselect the device
  digitalWrite(SS, HIGH);

  // Initialize the SPI communication
  SPI.begin();
}

Для передачи данных на SPI-совместимое устройство вы можете использовать команды из следующего примера:

Создайте новое приложение в Arduino App Lab.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

#include <SPI.h>

#define SS D10

void setup() {
  // Set the chip select pin as output
  pinMode(SS, OUTPUT);

  // Pull the SS pin HIGH to unselect the device
  digitalWrite(SS, HIGH);

  // Initialize the SPI communication
  SPI.begin();
}

void loop() {
  // Replace with the target device's address
  byte address = 0x35;
  // Replace with the value to send
  byte value = 0xFA;
  // Pull the SS pin LOW to select the device
  digitalWrite(SS, LOW);
  // Send the address
  SPI.transfer(address);
  // Send the value
  SPI.transfer(value);
  // Pull the SS pin HIGH to unselect the device
  digitalWrite(SS, HIGH);

  delay(2000);
}

Пример кода выше должен дать следующий результат:

I2C 

UNO Q поддерживает I2C-связь, что позволяет передавать данные между платой и другими I2C-совместимыми устройствами. Пины, используемые в UNO Q для протокола связи I2C:

Пин микроконтроллера	Маппинг пинов Arduino (Wire)	Пин микроконтроллера	Маппинг пинов Arduino (Wire1)
PB10	SCL / D21	PD12	I2C4_SCL (Qwiic)
PB11	SDA / D20	PD13	I2C4_SDA (Qwiic)

Обратитесь к разделу распиновки руководства пользователя для их определения на плате.

Для использования I2C-связи включите библиотеку Wire в начале вашего скетча. Библиотека Wire предоставляет функции для I2C-связи:

#include <Wire.h>

В функции setup() инициализируйте библиотеку I2C:

// Initialize the I2C communication
Wire.begin(); // I2C in UNO-style headers (D20, D21)
// or
Wire1.begin(); // I2C in Qwiic connector

Для передачи данных на I2C-совместимое устройство вы можете использовать команды из следующего примера:

Создайте новое приложение в Arduino App Lab.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

#include <Wire.h>

void setup() {
  // Initialize the I2C communication
  Wire.begin();
}

void loop() {
  // Replace with the target device's I2C address
  byte deviceAddress = 0x35;
  // Replace with the appropriate instruction byte
  byte instruction = 0x00;
  // Replace with the value to send
  byte value = 0xFA;
  // Begin transmission to the target device
  Wire.beginTransmission(deviceAddress);
  // Send the instruction byte
  Wire.write(instruction);
  // Send the value
  Wire.write(value);
  // End transmission
  Wire.endTransmission();

  delay(2000);
}

Пример кода выше должен дать следующий результат:

Qwiic 

Arduino UNO Q оснащён встроенным разъёмом Qwiic, обеспечивающим простое и безинструментальное решение для подключения I2C-устройств. Экосистема Qwiic, разработанная SparkFun Electronics, стала отраслевым стандартом для быстрого прототипирования с I2C-устройствами, позволяя подключать датчики, дисплеи и другую периферию без пайки и сложной проводки.

Ключевые преимущества системы Qwiic:

Подключение plug-and-play: Не нужны макетные платы, перемычки или пайка
Поляризованные разъёмы: Предотвращают случайное обратное подключение
Возможность последовательного подключения: Подключение нескольких устройств в цепочку
Встроенные подтягивающие резисторы: Не нужны внешние резисторы
Стандартная распиновка: Совместимость со всеми устройствами экосистемы Qwiic

Важно

Разъём Qwiic на UNO Q подключён к вторичной шине I2C (I2C4), которая использует объект Wire1, а не объект Wire. Обратите внимание, что разъём Qwiic работает только при 3.3 В.

Разъём Qwiic позволяет подключать узлы Modulino для разработки проектов без пайки.

Ознакомьтесь с нашим семейством Modulino, где вы найдёте разнообразные датчики и актуаторы для расширения ваших проектов.

UART 

Пины, используемые в UNO Q для протокола связи UART:

Пин микроконтроллера	Маппинг пинов Arduino
PB6	USART1_TX / D1
PB7	USART1_RX / D0

Обратитесь к разделу распиновки руководства пользователя для их определения на плате.

Для начала UART-связи необходимо сначала её настроить. В функции setup() установите скорость передачи (бит/с):

// Start UART communication at 115200 baud
Serial.begin(115200);

Для передачи данных на другое устройство через UART можно использовать функцию write():

// Transmit the string "Hello UNO Q"
Serial.write("Hello UNO Q");
Serial.write("\r\n"); // new line

Вы также можете использовать print и println() для отправки строки без символа новой строки или с символом новой строки:

// Transmit the string "Hello UNO Q"
Serial.print("Hello UNO Q");

// Transmit the string "Hello UNO Q" followed by a newline character
Serial.println("Hello UNO Q");

Для тестирования метода передачи UART используйте следующий пример — не забудьте создать новое приложение в Arduino App Lab, затем скопируйте и вставьте пример ниже:

void setup() {
  // Initialize the hardware UART at 115200 bps
  Serial.begin(115200);
}

void loop() {
  // Transmit the string "Hello UNO Q" followed by a newline character
  Serial.println("Hello UNO Q");
  delay(1000);
}

Вы должны получить следующее на пинах TX и RX вашей платы UNO Q (здесь используется логический анализатор для захвата данных):

Для чтения входящих данных можно использовать цикл while() для непрерывной проверки доступных данных и чтения отдельных символов. Код ниже сохраняет входящие символы в переменной String и обрабатывает данные при получении символа конца строки:

String incoming = "";

void setup() {
  // Initialize the hardware UART at 115200 baud
  Serial.begin(115200);
}

void loop() {
  while (Serial.available()) {
    char c = Serial.read();

    if (c == '\n') {
      // Echo the buffered message and add a newline
      Serial.println(incoming);

      // Clear for the next message
      incoming = "";
    } else {
      incoming += c;
    }
  }
}

С этим примером UNO Q будет отправлять обратно всё, что получит по UART.

От Serial к Monitor 

Из-за архитектуры UNO Q использование Serial не отображает данные в консоли Arduino App Lab, как вы могли бы ожидать.

Чтобы сделать отладку столь же простой, как на других платах Arduino, мы предоставляем объект Monitor, который вы можете использовать для вывода отладочных сообщений, показаний датчиков или любой другой информации непосредственно в консоль App Lab.

Примечание

Serial по-прежнему работает через UART, но его вывод не отображается в App Lab.

Вы можете добиться такого же поведения с минимальным условием: включите библиотеку Arduino_RouterBridge в ваш скетч.

#include <Arduino_RouterBridge.h>

void setup() {
  // Initialize the Monitor
  Monitor.begin();
}

void loop() {
  // Transmit the string "Hello UNO Q" followed by a newline character
  Monitor.println("Hello UNO Q");
  delay(1000);
}

Беспроводная связь 

UNO Q оснащён радиомодулем WCBN3536A, обеспечивающим двухдиапазонный Wi-Fi® 5 (2.4/5 ГГц) и Bluetooth® 5.1 для платы. Это обеспечивает беспроводное подключение для IoT и связи с периферийными устройствами.

Будь то подключение к локальной сети, загрузка данных в облако или связь с устройствами с поддержкой Bluetooth, такими как смартфоны и датчики, UNO Q предлагает гибкие и надёжные варианты для ваших проектов.

Wi-Fi®

Wi-Fi на UNO Q позволяет плате подключаться к локальным сетям или интернету для доступа к онлайн-сервисам, обновления программного обеспечения и связи с удалёнными серверами. Кроме того, Wi-Fi может быть настроен для предоставления интернет-соединения встроенному микроконтроллеру, позволяя обеим системам оставаться подключёнными без дополнительного сетевого оборудования.

С микропроцессора 

Если вы прошли первоначальную настройку Arduino App Lab, вы уже должны быть подключены к интернету. Тем не менее, вот краткое объяснение, как это сделать вручную.

Чтобы подключить UNO Q к интернету, просто перейдите в правый верхний угол и нажмите на иконку сети. Затем найдите доступные Wi-Fi® сети и выберите одну.

Или выполните следующую команду в терминале:

sudo nmcli d wifi connect <SSID> password <YOUR_PASSWORD>

Чтобы отключить UNO Q от текущей Wi-Fi сети, перейдите в то же место, где вы его подключали, нажмите на иконку сети в правом верхнем углу, а затем нажмите «Disconnect».

Или выполните следующую команду в терминале:

sudo nmcli d disconnect wlan0

Примечание

wlan0 — типичное имя Wi-Fi интерфейса, вы можете проверить своё, запустив nmcli device в терминале.

Если вы хотите забыть сохранённую сеть, чтобы она больше не подключалась автоматически, вы также можете выполнить:

sudo nmcli connection delete <SSID>

Подключения WPA2-Enterprise 

Для подключения к сети WPA2-Enterprise необходимо предоставить дополнительную конфигурацию аутентификации. Возможные конфигурации могут быть сложными; обратитесь к официальной документации для полного списка опций.

Например, вот конфигурация для Eduroam — международного сервиса Wi-Fi роуминга для пользователей в сфере исследований и образования.

nmcli con add \
  type wifi \
  connection.id Eduroam \
  wifi.ssid eduroam \
  wifi.mode infrastructure \
  wifi-sec.key-mgmt wpa-eap \
  802-1x.eap peap \
  802-1x.phase2-auth mschapv2 \
  802-1x.identity <your identity>

Вот другой пример с аутентификацией TTLS и PAP:

nmcli con add \
  type wifi \
  connection.id ExampleNetwork \
  wifi.ssid <your Wi-Fi SSID> \
  wifi.mode infrastructure \
  wifi-sec.key-mgmt wpa-eap \
  802-1x.eap ttls \
  802-1x.phase2-auth pap \
  802-1x.domain-suffix-match example.com \
  802-1x.identity <your identity>

Если вы предпочитаете не хранить пароль в открытом виде (особенно когда он содержит спецсимволы), вы можете использовать флаг --ask для интерактивного запроса пароля при подключении:

nmcli --ask con up <your network name>

С микроконтроллера 

Поскольку радиомодуль подключён к микропроцессору Qualcomm, нам нужен Bridge для предоставления связи микроконтроллеру.

Следующий пример получает время UTC через TCP с помощью RPC-вызовов сокетов и выводит его в Serial Monitor:

Создайте новое приложение в Arduino App Lab.

Установите библиотеку Arduino_RouterBridge, нажав Add Sketch Library и найдя её.

Скопируйте и вставьте пример ниже в часть «sketch» вашего нового приложения.

#include <Arduino_RouterBridge.h>

BridgeTCPClient<> client(Bridge);

void setup() {
  if (!Bridge.begin()) {
    while (true) {}
  }
  if (!Monitor.begin()) {
    while (true) {}
  }

  Monitor.println("TCP Daytime Demo started");
}

void loop() {
  Monitor.println("\nConnecting to time.nist.gov ...");

  if (client.connect("time.nist.gov", 13) < 0) {
    Monitor.println("Connection failed!");
    delay(5000);
    return;
  }

  Monitor.println("Connected, reading response...");
  String line;
  while (client.connected() || client.available()) {
    if (client.available()) {
      char c = client.read();
      if (c == '\n') break; // daytime sends one line
      if (c != '\r') line += c;
    }
  }

  Monitor.print("Server says: ");
  Monitor.println(line);

  client.stop();
  delay(10000);
}

После запуска откройте Serial Monitor в Arduino App Lab, и вы увидите время и дату, полученные с сервера time.nist.gov.

Bluetooth®

Bluetooth® позволяет UNO Q обмениваться данными с находящимися поблизости устройствами, такими как смартфоны, компьютеры или датчики. Его можно использовать для обмена данными, дистанционного управления или подключения к Bluetooth®-периферии, такой как клавиатуры, гарнитуры и последовательные устройства. В зависимости от настройки UNO Q может работать как Bluetooth®-периферийное устройство или хост, обеспечивая гибкую связь на коротких расстояниях для различных приложений.

Вы можете использовать функцию Bluetooth® из режима одноплатного компьютера, нажав на иконку Bluetooth в правом верхнем углу для управления.

Отсюда вы можете выполнять следующее:

Сканировать устройства
Сопрягаться с определённым устройством
Доверять устройствам
Отправлять файлы
Включать или выключать Bluetooth-соединение

Вы также можете управлять Bluetooth-соединением из терминала, используя bluetoothctl следующим образом:

bluetoothctl power on # включить Bluetooth
bluetoothctl power off # выключить Bluetooth

Вы можете войти в интерактивную оболочку менеджера Bluetooth, запустив bluetoothctl, и внутри выполнять специальные команды:

power on # включить Bluetooth
power off # выключить Bluetooth
scan on # начать поиск ближайших Bluetooth-устройств
scan off # остановить поиск устройств
connect <MAC_ADDRESS> # подключиться к устройству с указанным MAC-адресом

Вот пример того, как выглядит поиск Bluetooth-устройств из терминала: