This page is referenced by:

• 1 media/px30.png 2026-05-02T19:39:23-07:00 Using Yocto on RK3566: Building a Custom Embedded Linux Platform 2 RK3566 is a widely used Rockchip ARM processor for embedded products that need Linux, Android, display output, network connectivity, storage, USB, audio, camera interfaces, and general-purpose I/O. It is commonly used in smart display terminals, industrial HMI panels, lightweight gateways, access control devices, medical terminals, retail equipment, and custom single-board computers. plain 2026-05-02T19:43:02-07:00

  RK3566 is a widely used Rockchip ARM processor for embedded products that need Linux, Android, display output, network connectivity, storage, USB, audio, camera interfaces, and general-purpose I/O. It is commonly used in smart display terminals, industrial HMI panels, lightweight gateways, access control devices, medical terminals, retail equipment, and custom single-board computers.

  For many RK3566-based products, a standard desktop Linux distribution is not the best choice. Production devices usually need a controlled software stack, stable boot process, customized drivers, long-term maintainability, secure update strategy, and a reproducible firmware build. Yocto is a strong solution for this type of embedded Linux development.

  Yocto is not a Linux distribution by itself. It is a build framework that allows engineers to create a customized Linux distribution for a target device. With Yocto, product teams can define exactly which packages, services, kernel configurations, device tree files, libraries, and applications are included in the final firmware image.
  
   

  What Is RK3566?

  RK3566 is a Rockchip SoC based on ARM architecture. It is designed for mid-range embedded applications where performance, cost, power consumption, and multimedia capability need to be balanced. It can run Linux or Android and is often used in display-oriented and connected embedded products.

  A typical RK3566 SBC may include DDR memory, eMMC storage, Ethernet, Wi-Fi, Bluetooth, USB, UART, I2C, SPI, GPIO, audio, MIPI DSI, LVDS, HDMI, MIPI CSI, and other interfaces depending on the board design. This makes it flexible enough for HMI panels, IoT gateways, control terminals, and smart device interfaces.

  RK3566 is not a high-end AI or workstation processor. Its value is in efficient embedded computing. It can support graphical interfaces, multimedia playback, network services, local storage, and hardware control while keeping the system cost reasonable.

  Why Use Yocto with RK3566?

  Yocto is useful for RK3566 projects because it gives engineers fine control over the complete Linux system. Instead of installing a generic distribution and removing unnecessary parts later, Yocto builds the firmware from a defined set of recipes, layers, and configurations.

  This approach is valuable for production products. Engineers can reproduce the same image across development, testing, and manufacturing. Package versions can be controlled. Security patches can be managed. Board-specific customization can be separated into layers. Product-specific applications can be integrated into the build process.

  For RK3566 products, Yocto can be used to build the bootloader, Linux kernel, device tree, root filesystem, graphics stack, network tools, display services, application runtime, and update components. It is especially suitable when the product has a long lifecycle and needs predictable software maintenance.

  Yocto vs Buildroot on RK3566

  Buildroot and Yocto are both used in embedded Linux projects, but they have different strengths. Buildroot is simpler and often faster to understand. It is a good option for small systems with limited package complexity and straightforward firmware requirements.

  Yocto is more complex, but it provides a stronger structure for long-term product development. It supports layered architecture, package management, SDK generation, image customization, reproducible builds, and better control over large software stacks.

  For a simple RK3566 device that only runs one small application, Buildroot may be enough. For an industrial HMI, gateway, medical terminal, or commercial device that needs long-term maintenance, multiple packages, security updates, and structured customization, Yocto is often more suitable.

  Typical Yocto Architecture for RK3566

  A Yocto project is usually organized with multiple layers. Each layer provides a different part of the system. For an RK3566 product, the project may include a base OpenEmbedded layer, a Poky layer, a Rockchip BSP layer, a graphics layer, a Qt or UI framework layer, and a product-specific layer.

  A typical layer structure may include:

  poky/
  meta-openembedded/
  meta-rockchip/
  meta-qt5/
  meta-product/
  build/

  The Rockchip layer provides board support, kernel configuration, bootloader integration, device tree files, and hardware-specific recipes. The product layer contains product-specific applications, configuration files, services, scripts, and image definitions.

  Keeping custom changes in a separate product layer is an important best practice. It avoids modifying upstream layers directly and makes future maintenance easier.

  Bootloader and Kernel Support

  RK3566 uses a boot process that involves Rockchip-specific boot components and U-Boot. In a Yocto-based project, the bootloader configuration must match the board hardware, storage layout, and flashing method.

  The Linux kernel is one of the most important parts of the RK3566 software stack. It provides drivers for display, touch, USB, Ethernet, Wi-Fi, audio, storage, camera, GPIO, I2C, SPI, UART, and other interfaces. Yocto can build the kernel from source and apply patches through recipes.

  Kernel configuration should be controlled carefully. Development builds may include more debugging options, while production builds should remove unnecessary features. Kernel patches should be tracked clearly so the team can understand what has been changed for the product.

  Device Tree Configuration

  Device tree is critical in RK3566 Linux development. It describes how the board hardware is connected to the SoC. If the device tree is wrong, the kernel may fail to initialize the display, touch panel, Ethernet PHY, Wi-Fi module, GPIO, regulators, audio codec, or other peripherals.

  Common RK3566 device tree work includes enabling UART ports, configuring I2C devices, adding touch controllers, defining display panels, setting backlight PWM, configuring MIPI DSI or LVDS, enabling Ethernet, configuring USB roles, adding audio codecs, and setting GPIO power control.

  In Yocto, board-specific device tree files can be managed through the BSP layer or product layer. Engineers may add patches or custom device tree sources through recipes. This keeps hardware configuration under version control and makes the firmware reproducible.

  Display Integration

  RK3566 is often used in products with TFT displays. Display integration is therefore a major part of many Yocto projects. Depending on the board design, the display may use MIPI DSI, LVDS, HDMI, RGB, or eDP.

  The display configuration must include panel timing, interface type, backlight control, power sequence, reset GPIO, enable GPIO, and driver compatibility. If the product uses a capacitive touch panel, the touch controller must also be configured correctly.

  Yocto can build graphical stacks such as Wayland, Weston, Qt, GTK, or other UI frameworks. For industrial HMI products, Qt is commonly used because it provides a mature framework for touch-based graphical applications. For lightweight products, a simpler framebuffer or DRM/KMS application may be enough.

  Touch Panel Support

  Many RK3566 devices use capacitive touch panels. Touch controllers are usually connected through I2C or USB. For I2C touch panels, the device tree must define the correct I2C address, interrupt GPIO, reset GPIO, and compatible driver.

  Touch panel configuration should also consider screen rotation, coordinate mapping, multi-touch behavior, and wake-up support. If the screen is used in portrait orientation, the touch coordinates must match the display orientation.

  In industrial products, touch performance should be tested inside the final enclosure. Cover glass thickness, grounding, metal frame design, cable routing, and electrical noise can all affect capacitive touch behavior.

  Networking and Connectivity

  RK3566 products often need Ethernet, Wi-Fi, Bluetooth, or other communication interfaces. Yocto allows engineers to include only the required network tools and services.

  For Ethernet, the device tree must correctly configure the MAC, PHY, clocks, reset GPIO, and pin control. For Wi-Fi and Bluetooth, the system may need kernel drivers, firmware files, regulatory database, wpa_supplicant, BlueZ, and network management tools.

  Production products should be tested for network recovery. The system should recover after cable unplug, router restart, DHCP failure, Wi-Fi signal loss, and server disconnection. Network reliability is especially important for gateways, smart terminals, and remote monitoring devices.

  Root Filesystem Design

  One of the main advantages of Yocto is precise root filesystem control. The final RK3566 image should include only the required packages and services. This reduces storage usage, boot time, attack surface, and maintenance complexity.

  A minimal RK3566 image may include BusyBox or core utilities, networking tools, device rules, firmware files, basic system services, and the product application. A more advanced image may include Qt, GStreamer, FFmpeg, SQLite, MQTT libraries, OpenSSL, Python, BlueZ, and update tools.

  Engineers should separate development images from production images. Development images may include debugging tools, SSH access, test scripts, and extra logs. Production images should be more restricted, smaller, and better controlled.

  Application Integration

  In Yocto, the product application can be added as a recipe. This allows the application to be built, installed, and packaged as part of the firmware image. The recipe can define source location, dependencies, build steps, install paths, and service files.

  For example, an industrial HMI application may be built with Qt and installed into the root filesystem. A systemd service can start the application automatically after boot. If the application crashes, systemd can restart it.

  [Unit]
  Description=RK3566 HMI Application
  After=network.target
  
  [Service]
  ExecStart=/usr/bin/hmi-app
  Restart=always
  RestartSec=2
  
  [Install]
  WantedBy=multi-user.target

  Automatic startup is important for dedicated devices. The product should boot directly into its main function instead of requiring manual operation from a Linux shell.

  Graphics Stack: Wayland, Weston, and Qt

  Many RK3566 Yocto products use Wayland and Weston as the display server environment. Qt applications can run on top of Wayland or use EGLFS depending on the configuration. The choice depends on product requirements and graphics driver support.

  Weston is useful for kiosk-style products where one application runs full screen. Qt is useful for industrial HMI and smart panels that need buttons, charts, animations, multiple pages, and touch interaction.

  Engineers should test graphics performance with the actual display resolution and application workload. UI smoothness depends on GPU driver support, memory bandwidth, rendering method, and application design.

  Camera and Multimedia Support

  Some RK3566 products require camera input, video playback, audio output, or media streaming. Yocto can include packages such as GStreamer, FFmpeg, ALSA, PulseAudio or PipeWire, V4L2 tools, and OpenCV depending on the project.

  Camera integration requires sensor driver support, device tree configuration, MIPI CSI or USB camera interface, and media pipeline testing. Video playback requires codec support and graphics integration.

  For products such as video intercoms, smart terminals, or multimedia HMI devices, camera and audio should be tested under long-term operation, not only during short demonstrations.

  Storage and Partition Design

  RK3566 SBCs commonly use eMMC storage for production products. Yocto can generate different filesystem formats and image layouts depending on the target design.

  A production system may use a read-only root filesystem with a separate writable data partition. This improves reliability because the core system files are protected from sudden power loss or accidental modification.

  For devices that store logs or user data, log rotation and cleanup policies are necessary. If the storage becomes full, the application may fail or the system may become unstable. Engineers should plan storage usage from the beginning.

  Firmware Update Strategy

  Firmware updates are important for RK3566 products deployed in the field. Yocto can be integrated with update systems such as RAUC, SWUpdate, or Mender depending on the project requirement.

  A good update system should handle failed downloads, interrupted updates, wrong firmware versions, and power loss during update. For critical products, an A/B partition scheme with rollback is recommended. If the new image fails to boot, the device can return to the previous working system.

  Update packages should be verified before installation. Secure update design is especially important for network-connected industrial and commercial devices.

  Security Considerations

  Embedded Linux devices are increasingly connected to networks, so security must be considered early. A production RK3566 Yocto image should remove unnecessary services, disable default accounts, restrict SSH access, protect credentials, and use secure communication.

  Yocto allows engineers to control exactly which packages and services are included. This helps reduce attack surface. Security patches can also be managed through the Yocto build system and layer maintenance process.

  If the device supports OTA updates, update images should be signed or verified. If the product stores user data, configuration files, or network credentials, these should be protected appropriately.

  Boot Time Optimization

  Many RK3566 products need to start quickly. Yocto helps because the image can be customized to remove unnecessary services and packages. Boot time can be improved by optimizing bootloader settings, kernel configuration, service startup order, root filesystem size, and application launch timing.

  For HMI products, the most important metric may be time to first usable screen. A splash screen can be shown early, while non-critical services start later. Network services should not block the main UI unless required.

  Boot time optimization should be measured repeatedly. Engineers should use boot charts, systemd-analyze, kernel logs, and application logs to identify slow steps.

  Production Testing

  A Yocto-based RK3566 product should include a clear production testing strategy. Factory tests may need to verify display, touch, Ethernet, Wi-Fi, Bluetooth, USB, audio, GPIO, UART, I2C, camera, eMMC, and power functions.

  Yocto can include a factory test application in a special production image. This test image can be used during manufacturing, while the final customer image can be flashed after testing or included as part of the same process.

  Serial number programming, MAC address writing, hardware revision detection, firmware version tracking, and aging tests should be part of the production workflow.

  Best Practices for RK3566 Yocto Projects

  A successful RK3566 Yocto project should follow several best practices.

  Keep board-specific changes in a custom layer instead of modifying upstream layers directly. Track kernel and device tree patches clearly. Separate development and production images. Use version control for all recipes, configuration files, and scripts.

  Test the actual display, touch panel, network module, camera, audio hardware, and enclosure early. Do not wait until the end of the project to bring up hardware interfaces.

  Define an update strategy before mass production. Plan security, storage layout, logging, factory testing, and recovery behavior from the beginning.

  Yocto has a learning curve, but it provides strong benefits when the product requires long-term software control and repeatable production builds.

  Conclusion

  Using Yocto on RK3566 is a practical approach for building customized embedded Linux products. RK3566 provides a balanced ARM platform for HMI panels, smart terminals, gateways, access control devices, medical interfaces, and industrial embedded products. Yocto provides the build framework needed to create a controlled, reproducible, and production-ready Linux system.

  A successful RK3566 Yocto project requires careful work on BSP integration, bootloader configuration, kernel patches, device tree, display support, touch panel setup, root filesystem design, application integration, update strategy, security, and production testing.

  For product teams that need long-term maintainability and precise control over the software stack, RK3566 with Yocto can provide a strong foundation for professional embedded Linux development.