sTPC-EXXX-3568B Series

sTPC-EXXX-3568B Series (Production Models: sTPC-E101-3568B / E121-3568B / E150-3568B / E156-3568B / E170-3568B / E215-3568B) is based on the Rockchip RK3568 platform, a Fanless ARM Touch Panel PC (PANEL PC), with screen sizes covering 10.1″ / 12.1″ / 15″ / 15.6″ / 17″ / 21.5″ in six specifications.

The unit combines an aluminum-magnesium alloy front frame with a fully sealed rear enclosure. The front holds a multi-point capacitive touch screen; the lower rear concentrates the power supply, serial port, USB, HDMI, Ethernet and other external interfaces; the antenna and SIM card are located on the upper rear. Two installation methods are supported, VESA mount and embedded (cutout) mounting, making the unit suitable for production line dashboards, equipment HMI, self-service query terminals and other industrial sites.

Product Features

• Supports Rockchip RK3568: 4 × Cortex-A55 @2.0GHz, 1 TOPS NPU
• Fully onboard I/O design, interfaces concentrated on the lower rear, maintenance requires no disassembly
• Fanless fully sealed structure, support for VESA / embedded mounting
• Android 11 and Ubuntu 20.04, dual OS optional

Model Naming Rules

Note: Specifications are subject to change without prior notice. Data in this section corresponds to specification sheet v1.3 (updated 2026-06-24).

Note: All models use a capacitive touch screen + 32GB onboard eMMC, in two memory configurations (2GB / 4GB); actual part numbers are listed in the table above; see 1.2, 2.3 for wide-range power input and interface group count differences of the 15″ model (E150).

The unit uses a flat-front + rear-cable-outlet design: the front holds only the touch screen and the aluminum-alloy front frame; the upper rear houses the antenna, SIM card slot and speaker connector area; the lower rear houses the external interface area (power supply, serial port, USB, HDMI, Ethernet port); the four corners have VESA mounting holes.

Unit Front	Perspective View
Front: Multi-Point Capacitive Touch Screen + Aluminum-Magnesium Alloy Front Frame	Perspective: Unit Structure and Rear Expansion Bay

Unit Rear	Interface Area (Front View)
Rear: VESA Holes + Interface Area	Interface Area: DC 12V / Serial Port / HDMI / Ethernet / USB Arranged in a Single Row

The external interfaces on the lower rear of the unit, from left to right, are: DC 12V → PWR / SYS indicator LEDs → Recover → Return → MIC → RS485 → RS232 → HDMI → LAN → USB3.0 → USB2.0; on the upper rear, from left to right: SIM card slot → 4G antenna → Wi-Fi / BT antenna → SPK speaker connector → GPIO breakout connector. Labels in the figure correspond one-to-one with the numbers in the table below; click an image to view the high-resolution version.

Interface Layout (Front View)	Interface Layout (Angled View)
Front View: External Interfaces Lined Up in a Row on the Lower Rear	Angled View: Positions of RS485 / SIM / Speaker / Antenna Connectors

Note: Quantities in the table are the maximum configuration for the series; the actual number of groups varies by model and configuration (the 10.1″ sample in the figure has one group each of RS485 and RS232). Wiring and device nodes follow the silkscreen labels on the unit; see 4.5 for the node mapping.

All external connectors on the unit are finished connectors; no bare board pin headers. The serial ports and speaker use pluggable terminal blocks with 3.5mm / 2.0mm pitch; align wiring with the silkscreen labels. Recommended wire gauge: 0.2 ~ 1.5mm²; strip length: 6 ~ 7mm.

DC 12V (5.5×2.1mm Barrel Connector)

RS485 (3.5mm 3P Terminal, 2 Groups: ttyS1 / ttyS3)

Half duplex; transmit/receive direction is switched automatically by hardware; no software RTS control is required.

RS232 (3.5mm 3P Terminal, 2 Groups: ttyS2 / ttyS4)

Full duplex; when connecting to external devices, cross R/T and share GND.

Note: The silkscreen suffix matches the device node number (A1 → ttyS1, R2 → ttyS2, A3 → ttyS3, R4 → ttyS4); therefore RS485 uses ttyS1 / ttyS3 and RS232 uses ttyS2 / ttyS4. Non-consecutive numbering is normal.

SPK (PH2.0-4P)

MIC (Ø3.5 phone jack)

USB

HDMI / LAN / SIM

GPIO (PH2.0-16P Terminal, Optional Breakout)

The unit GPIO is an optional breakout (rear GPIO connector / internal pin header); align wiring with the silkscreen labels on the unit.

GPO / GPI are fixed by hardware and cannot be swapped by software; the table below lists system-side GPIO numbers, which are a different concept from terminal pin numbers.

System GPIO Numbers

GPIO numbers are kernel gpiochip global numbers and may shift as a whole across firmware versions; unexported pins must be exported before use.

Dimension drawing for the 10.1″ model (unit: mm): unit 269 × 188 × 39, cutout 261±2 × 180±2, mounting holes 4 × Ø10, VESA holes 4 × M4 depth 6mm. For dimension drawings of other sizes, see pages 2~3 of the specification sheet.

Structural Description

• Enclosure material: aluminum-magnesium alloy front frame + metal rear enclosure, fanless and fully sealed
• Mounting: VESA bracket (4 × M4, depth 6mm) or embedded cutout mounting (clip-fixed)
• Cooling: natural cooling for the unit; reserve ≥ 50mm ventilation space at the rear

Android System

• Android 11 firmware (with root access): contact Sales / Technical Support for the download link

Linux System

• Ubuntu 20.04 firmware (with Qt 5.12.8, GStreamer): contact Sales / Technical Support for the download link
• Debian 11 firmware: provided separately per project requirements

Both tools are official Rockchip releases, uploaded as attachments on this site; download links are at the end of each item:

• USB Driver: After extraction, double-click DriverInstall.exe to complete the installation: DriverAssitant_v5.11 Driver Installation Package (9.4 MB)
• Flashing Tool: After extraction, double-click RKDevTool.exe to launch the tool: RKDevTool_Release_v3.32 Flashing Tool (5.5 MB)

Note: If the driver is not installed successfully, an unknown device appears in Device Manager; reinstall the driver before flashing.

Linux and Android use the same Rockchip tools for flashing; the unit requires no disassembly: connect via the USB3.0/OTG port and enter flashing mode via the Recover pinhole.

① Connect the OTG Port

Take a USB3.0 male-to-male cable; connect one end to the blue USB3.0/OTG port in the lower row of the rear interface area and the other end to a PC USB port:

② Install the Rockchip USB Driver

Enter the driver package directory and double-click DriverInstall.exe:

When the “Rockchip Driver Assistant” dialog appears, click “Install Driver” and wait for the progress bar to complete:

Note: If the device is not recognized due to a driver error or after switching PCs, click “Uninstall Driver” in Driver Assistant first, then click “Install Driver” again.

③ Open the Flashing Tool

Extract the tool package and double-click RKDevTool.exe:

④ Put the Unit into Loader Mode

Power off the unit first, hold the rear Recover hole with a pin without releasing, then connect DC 12V to power on, and release after about 2 seconds:

⑤ Confirm the Device Is Recognized

After entering Loader mode, check the status bar at the bottom of RKDevTool: No Devices Found means the unit is not recognized yet, while Found One LOADER Device means it is ready to flash:

If “No Devices Found” keeps showing, go back to step ④ and re-enter, or change the USB port and data cable.

⑥ Select Firmware and Upgrade

Switch to the “Upgrade Firmware” tab, first click “Firmware” to select update.img, then click “Upgrade”:

After flashing reaches 100%, the device reboots automatically; first boot takes about 30 ~ 60 seconds.

Note:

1. If the device is not recognized when switching from Android to Linux (or vice versa), run “Enter Maskrom” in “Advanced Features” and re-flash
2. Do not cut power or unplug the cable during flashing; otherwise the unit may fail to boot and must be re-flashed after re-entering Loader
3. Advanced users can flash via the upgrade_tool command line under Linux: sudo upgrade_tool uf update.img

The Android unit can be upgraded offline via USB drive without connecting to a PC. This section applies only to Android firmware; for the corresponding Linux procedure see 5.10, for OTA update see 4.13.

Choose one of the two firmware sources:

1. Obtain a ready-made update.img from SmartInc (see 3.1 for how to get it)
2. Build it yourself with the SDK: run a full build in the SDK root directory to generate the rockdev/Image-xxx/ directory, then run ./mkupdate.sh (or make otapackage)

# Build the full image
./build.sh updateimg
ls -lh rockdev/update.img

USB drive requirements: FAT32 format, available capacity ≥ 4GB (≤ 32GB recommended), place update.img in the root directory with the filename unchanged.

1. Copy update.img to the root directory of the USB drive
2. Insert the USB drive into a USB port on the unit (either USB3.0 / USB2.0 port works)
3. After the system detects the update package, confirm as prompted in the pop-up; keep the power supply on during the update, and the unit reboots automatically when done

Note: If no upgrade prompt appears after inserting the USB drive, first check the filename and USB drive format, then reboot the unit and retry; for Android OTA update see 4.13.

This chapter applies only to the Android system (Android 11). Equivalent functions under Linux (Ubuntu / Debian) are grouped in Chapter 5; interfaces, tools and commands are not mixed between the two chapters; Android application-layer API calls are all documented in 4.12.

1. Use a USB data cable to connect the USB3.0/OTG port of the unit (blue port on the lower row) to the PC
2. Under “Settings → About tablet”, tap “Build number” 7 times consecutively to enable Developer options
3. Enter “Developer options” and enable “USB debugging”
4. On the PC, run adb devices; on first connection, tap “Allow” in the pop-up on the unit

adb devices
# List of devices attached
# 0123456789ABCDEF	device

When the unit and PC are on the same network segment, debug wirelessly without a data cable.

adb connect 192.168.8.55:5555
adb devices

1. Go to “Settings → Network & Internet → WLAN” and turn on the switch
2. Select the target hotspot and enter the password (onboard 2.4G/5G dual-band, 802.11 a/b/g/n/ac)
3. After connecting, check the IP address in “Network details”
4. If the signal is weak, adjust the angle of the rear Wi-Fi/BT SMA antenna, or use a suction-cup antenna instead

adb shell dumpsys wifi | grep -i "curState"
adb shell ifconfig wlan0

The unit has a single network port (LAN, Gigabit auto-negotiation); under Android the device name is eth0. All commands below run in adb shell; changing settings requires su privileges.

View Device

ip link show

Usage (Dynamic IP)

su
ifconfig eth0 up
ifconfig eth0 dhcp      # Some firmware requires dhcpcd eth0 instead

Usage (Static IP)

su
ifconfig eth0 down
ifconfig eth0 192.168.8.55 netmask 255.255.255.0
ifconfig eth0 up

Test

ping -c 4 192.168.8.1

Note: To make a static IP take effect automatically at boot, configure a static eth0 address in the system, or set the Ethernet static IP via ConnectivityManager at the application layer.

The unit's 4G uses a Quectel EG800AK-C module (mounted on the 6A12-J carrier board); the system dials automatically after power-on, with no manual configuration required.

The unit supports only the 4G modules listed below; the USB ID is used to confirm in the board-side lsusb output whether the module is recognized:

4G Module

1. Attach the 4G antenna, and insert the SIM card into the socket with the notch facing outward and the chip facing the board
2. After power-on, confirm the SIM card is recognized in “Settings → Network & Internet → Mobile network”
3. Turn on mobile data; once the 4G icon appears in the status bar, you can access the Internet

adb shell lsusb
# Bus 002 Device 002: ID 2c7c:6002 Quectel Wireless Solutions Co., Ltd. EG800AK-C

Check Signal and Network Registration (AT Commands)

The module AT port is generally /dev/ttyUSB2 and requires root privileges:

echo -e "AT+CPIN?\r\n"   > /dev/ttyUSB2   # Check whether the SIM card is inserted properly
echo -e "AT+CSQ\r\n"     > /dev/ttyUSB2   # Signal strength, 0~99 is normal
echo -e "AT+COPS?\r\n"   > /dev/ttyUSB2   # Whether registered on the carrier network
echo -e "AT+CGREG?\r\n"  > /dev/ttyUSB2   # Whether the data network is ready

Note: Insert or remove the SIM card only with power off; hot-plugging may cause the module to be unrecognized, requiring a power cycle.

The unit provides 2 × RS485 and 2 × RS232; Android node and terminal definitions are as follows (the rear silkscreen label takes precedence):

Serial port testing under Android uses ComAssistant (a serial assistant app) throughout:

1. Install and open ComAssistant; on first run, grant storage and serial port device permissions
2. Select the target node in the device list: RS485 uses /dev/ttyS1 or /dev/ttyS3; RS232 uses /dev/ttyS2 or /dev/ttyS4
3. Set the parameters to 115200, 8 data bits, 1 stop bit, no parity (8N1)
4. Tap “Open serial port”, enter content in the send area and tap “Send”; during loopback or mutual transmission, observe the receive area at the same time

Note: ComAssistant requires Root privileges to access /dev/ttyS*; if opening fails, first run su and ls -l /dev/ttyS* in adb shell to check node permissions.

1. RS232 loopback: short R and T of the same 232 node with a jumper cap
2. RS232 — RS232 mutual transmission: cross wiring (R↔T, common GND)
3. RS232 — RS485 mutual transmission: via a 232-to-485 converter module
4. RS232 — RS232-to-USB — serial port assistant on the PC
5. RS485 — RS485-to-USB — serial port assistant on the PC
6. RS485 loopback: short A and B

Precautions

1. The unit has a 3.5mm 3P pluggable terminal (no DB9); use a crimp terminal or adapter cable. Adapter cable pinouts may differ between manufacturers; reversing A / B or R / T directly causes communication failure
2. RS485 is half-duplex; direction is switched automatically by hardware, so observe the frame interval when switching between transmit and receive

Do not open nodes directly via shell in the app; use the NodkaAPI uart_ interface (see 4.12.5):

NodkaAPI api = NodkaAPI.nodkaAPICreate(context);
api.uart_open("/dev/ttyS2", 115200);
api.uart_send("/dev/ttyS2", "hello".getBytes());
api.uart_receive("/dev/ttyS2", new UartReceiveDataCallback() {
    @Override
    public void onReceiveData(byte[] data) {
        // Process the received data
    }
});
api.uart_close("/dev/ttyS2");

The unit provides 2 × USB3.0 (lower row multiplexed with OTG) and 2 × USB2.0, plus SD card support.

USB Drive

1. Insert the USB drive; “USB storage device” appears on the left side of the file manager
2. If you can browse the USB drive contents after opening it, the drive is recognized correctly
3. Before unplugging, unmount it in “Settings → Storage” to avoid data corruption

adb shell ls /storage          # Mount points such as udisk0 or 91A3-2B1C are visible
adb shell lsusb

SD Card

adb shell ls /storage          # SD card mount points such as xxxx-xxxx are visible
adb shell dumpsys mount | grep -i mmc

Note: The OTG port in Device mode (flashing / ADB) cannot act as Host at the same time; before inserting a USB drive, confirm the system has exited flashing mode. For manual mounting under Linux see 5.5.

Unit audio is output via SPK (PH2.0-4P, 8Ω 6W) and input via MIC (Ø3.5); connect an external speaker when no built-in speaker is present.

Speaker Output Test

1. Connect an 8Ω speaker to the SPK terminal (L+ / L- / R+ / R-)
2. Open the built-in “Music” player to play the test audio, and press the volume keys to confirm the volume is adjustable and the left/right channels are normal
3. The test file is at /nodka_test/LR_audio.wav and can be played directly with the “Files” app

Microphone Recording Test

1. Insert a Ø3.5 microphone or use the onboard MIC
2. Open the built-in “Recorder” app, record about 5 seconds and play it back to confirm the audio is clear with no noise

View Audio Path

adb shell dumpsys media.audio_flinger | grep -i "Output thread"
adb shell getprop | grep -i audio

Note: If there is no sound, first confirm the SPK terminals L+ / L- / R+ / R- match the speaker wire sequence, then use adb shell tinymix to check whether the amplifier path is open. Under Linux, use aplay / arecord (see 5.1).

The unit supports simultaneous output to the internal screen + HDMI, up to 3840 × 2160 on HDMI.

Set HDMI Output

1. Connect an HDMI monitor and go to “Settings → Display → HDMI”
2. Select the resolution and refresh rate (1920 × 1080 @ 60Hz recommended) and confirm the image is stable with no flicker
3. Select the display mode: Mirror (Clone) or Extended (Expand)

View via Command Line

adb shell wm size
adb shell wm density
adb shell dumpsys display | grep -i "mDisplayId"

Note: In the app, use interfaces such as display_setScreenRotation / display_setScreenBrightness to control the display (see 4.12.3). Under Linux, use xrandr or weston.ini (see 5.6).

Return Button Test (getevent)

adb shell getevent -l
# /dev/input/event2: EV_KEY       KEY_BACK         DOWN
# /dev/input/event2: EV_SYN       SYN_REPORT       00000000
# /dev/input/event2: EV_KEY       KEY_BACK         UP

Pressing Return produces DOWN; releasing it produces UP, indicating that the button and driver are normal.

Return Button: Enter Flashing Mode

Hold the Return button, power on and release after 3 seconds to enter flashing mode, without using the Recover pinhole.

Recover Quick Self-Test

Hold the Recover pinhole with power off, then power on; a LOADER device appearing in RKDevTool indicates normal operation (see 3.3 for flashing steps).

Note: Recover is a pinhole structure; use a needle with diameter ≤ 1.5mm to avoid damaging the internal tact switch.

The unit has a multi-touch capacitive touch screen; the controller connects to the system via USB.

View Touch Device

adb shell getevent -pl /dev/input/event*
adb shell dumpsys input | grep -i -A2 "touch"

Line Drawing and Multi-Touch Detection

1. In “Settings → Developer options → Pointer location”, swipe a finger to see the X / Y coordinates and trace
2. Press and hold five fingers on the screen simultaneously and check whether multiple touch points are reported at the same time (multi-touch)
3. Tap once on each of the four corners and the center to confirm there is no offset and no dead zone (touch calibration data is written at the factory, so recalibration is generally unnecessary)

Note: If touch does not respond, first confirm the touch USB cable is connected to the mainboard, then use adb shell lsusb to check whether the touch controller device exists.

The unit's GPIO is an optional breakout (rear GPIO socket / internal pin header). For the odd/even pin orientation of the 16-pin terminal, system GPIO numbers and terminal mapping, see 2.3; these details are not repeated in this section.

Android apps operate via the NodkaAPI gpio_ interface without shell (see 4.12.4):

NodkaAPI api = NodkaAPI.nodkaAPICreate(context);
api.gpio_export(95);                  // Export the pin
api.gpio_direction(95, "out");        // Set as output
api.gpio_write(95, 1);                // Output high level
int v = api.gpio_read(95);            // Read back the level
api.gpio_unExport(95);                // Unexport the pin

Note: GPIO numbers are global kernel gpiochip numbers and may shift as a whole across firmware versions; run gpio_export first on unexported pins before operating. For Linux command-line (/sys/class/gpio) operations see 5.4.

For Android app development, hardware and system capabilities are wrapped as Java interfaces, so apps need not directly read/write /dev and /sys nodes. The Linux side does not provide this set of interfaces; use the command-line approach in Chapter 5.

Interface Source Package Download

AndroidAPI 1.5 Interface Source Package (18.7 MB)

The package contains AndroidAPI.jar, libandroid-jni.so, AndroidAPI-sources.jar, Javadoc documentation, the AndroidAPIDemo sample project and APK, the platform.jks signing file and readme.txt. Serial port, GPIO and system control interfaces require system signature or Root privileges.

Interface Categories

1. Create the instance in Application's onCreate

public class APIApplication extends Application {
 
    private NodkaAPI mNodkaAPI;
 
    @Override
    public void onCreate() {
        super.onCreate();
        mNodkaAPI = NodkaAPI.nodkaAPICreate(this);
    }
 
    public NodkaAPI getNodkaAPI() {
        return mNodkaAPI;
    }
}

2. Retrieve it in an Activity or Fragment

private NodkaAPI mNodkaAPI = APIApplication.getApplication().getNodkaAPI();

Note: Set android:name to APIApplication in AndroidManifest.xml; serial port, GPIO and system control interfaces require system signature or Root privileges.

See 4.11 for pin numbers.

See 4.5 for nodes and test methods.

OTA update on Android is performed by the preinstalled update app; the unit must be connected to the Internet first.

1. Open the app list and find “update”
2. Tap “UPDATE NOW” and follow the prompts to download and install
3. Keep the power supply and network connected during the update; the unit reboots automatically when done

The update icon in the app list:

SmartInc OTA update interface:

Note: This section covers Android online OTA update; for Android USB drive offline update, see 3.4; for Linux OTA update, see 5.10.

This chapter applies only to Linux systems (Ubuntu 20.04 / Debian 11, Buildroot for some projects). For the corresponding functions on Android, see Chapter 4.

Except for 5.11 Cross-compilation and 5.12.1 Docker Compilation, which run on the development host, all commands in this chapter are executed in the on-board terminal or via SSH. The criteria for buttons, indicator LEDs and the touch screen are the same as in Chapter 4 (see 4.9, 4.10) and are not repeated here. Sections from 5.8 onward are system customization items commonly used for factory projects.

aplay -l                                    # List sound cards and devices
aplay /nodka_test/LR_audio.wav -D hw:0,0    # Play via the specified sound card device
arecord -d 5 -f cd -r 44100 -c 2 -t wav test.wav
aplay test.wav

Volume adjustment:

alsamixer
amixer -c 0 set 'Playback' 80%

Note: Unit playback outputs from the SPK terminal (PH2.0-4P); connect an external 8Ω speaker. MIC uses the Ø3.5 interface.

View network ports

ifconfig -a
ip link show

Set a static IP via command line

1. Open the network configuration file with vim: vim /etc/network/interfaces

2. Modify the IP, netmask and gateway according to the on-site network (the unit has a single network port; configure only eth0)

auto lo
iface lo inet loopback
 
auto eth0
iface eth0 inet static
	address 192.168.2.110
	netmask 255.255.255.0
	gateway 192.168.2.1

3. Save and exit (press Esc in vim, type :wq), then reboot the system for the configuration to take effect.

Note: On Ubuntu 20.04, NetworkManager manages the network by default, so the configuration in /etc/network/interfaces may not take effect; in this case use the nmcli method in 5.2.2, or disable NetworkManager first and then use the method in this section.

Set DNS

vi /etc/resolv.conf
nameserver 114.114.114.114

Network priority

# Temporary change; the smaller the value, the higher the priority
sudo ifmetric eth0 100
 
# Permanent modification
sudo nmcli connection modify "Wired connection name" connection.autoconnect-priority 1
sudo nmcli connection modify "Wired connection name" ipv4.route-metric 100
sudo nmcli connection modify "Wired connection name" connection.autoconnect yes
sudo systemctl restart NetworkManager

Verification

ping -c 4 192.168.2.1
ping -c 4 www.baidu.com

Note: In the graphical interface (Debian desktop), set the IP, netmask and gateway directly in “About NetworkManager Applet → Edit Connections…”; when no existing connection is available, click + in the bottom right to create one.

Query and enable the wireless NIC

ifconfig -a          # Wireless NIC is usually wlan0
ifconfig wlan0 up    # Enable the wireless NIC
iw dev wlan0 scan    # Scan for hotspots to get SSID, signal strength, and encryption method

Connect to a wireless network

nmcli d wifi connect "SSID" password "PASSWORD"

Static IP

sudo nmcli connection modify NODKA ipv4.addresses 172.10.21.111/24                  # IP / subnet mask
sudo nmcli connection modify NODKA ipv4.gateway 172.10.21.1                         # Gateway
sudo nmcli connection modify NODKA ipv4.dns "114.114.114.114,61.177.7.1,8.8.8.8"    # DNS
sudo nmcli connection modify NODKA ipv4.method manual                               # Static
sudo nmcli device disconnect wlan0
sudo nmcli device connect wlan0

Dynamic IP (DHCP)

sudo nmcli connection modify NODKA ipv4.method auto
sudo nmcli connection modify NODKA ipv4.addresses ""    # Clear the static IP
sudo nmcli connection modify NODKA ipv4.gateway ""      # Clear the gateway
sudo nmcli connection modify NODKA ipv4.dns ""          # Clear DNS (optional)
sudo nmcli connection down NODKA
sudo nmcli connection up NODKA

Configure as an AP hotspot

IFNAME="wlan0"    # Wireless NIC node
CON_NAME="One"    # Hotspot name
 
nmcli con add type wifi ifname $IFNAME con-name $CON_NAME autoconnect yes ssid $CON_NAME
nmcli con modify $CON_NAME 802-11-wireless.mode ap 802-11-wireless.band bg ipv4.method shared
nmcli con up $CON_NAME

Note: If the signal is weak, adjust the angle of the rear Wi-Fi/BT antenna or use a suction-cup antenna instead; after connecting, use ip addr show wlan0 to view the assigned address.

On Linux, the serial port nodes are the same as on Android: RS485 is /dev/ttyS1 or /dev/ttyS3; RS232 is /dev/ttyS2 or /dev/ttyS4 (refer to the rear silkscreen label).

Test tools

1. GUI: CuteCom (sudo apt install cutecom); select /dev/ttyS2, 115200, 8N1, then open
2. Command line: built-in com_send / com_recv

# Send
com_send /dev/ttyS2 115200
# Receive (open another terminal)
com_recv /dev/ttyS2 115200

Read/write nodes directly

stty -F /dev/ttyS2 115200 cs8 -cstopb -parenb
echo "hello" > /dev/ttyS2     # Send
cat /dev/ttyS2                # Receive

Test method

For loopback, peer-to-peer and adapter wiring, see 4.5.2; these are OS-independent and are not repeated in this section.

Precautions

1. The unit uses a 3.5mm 3P pluggable terminal (no DB9); use with crimp terminals or an adapter cable; reversing the wire order (A / B, R / T) will directly cause communication failure
2. RS485 is half-duplex; direction is switched automatically by hardware, so observe the frame interval when switching between transmit and receive
3. If permission is denied, add the current user to the dialout group: sudo usermod -aG dialout $USER (takes effect after re-login)

On Linux, access is unified through /sys/class/gpio. For terminal pin assignment rules and system GPIO numbers, see 2.3; this section only provides the operation commands.

1. Check whether the relevant IO is exported

cd /sys/class/gpio
ls

2. Configure GPO (system configuration)

for i in {95,94,21,22,140,141}; do echo out >gpio$i/direction; done
for i in {13,14,96,93,108,107}; do echo out >gpio$i/direction; done

3. Set GPO high / low

Output high level:

for i in {95,94,21,22,140,141}; do echo 1 >gpio$i/value; done
for i in {13,14,96,93,108,107}; do echo 1 >gpio$i/value; done

Read back the current level:

for i in {95,94,21,22,140,141}; do cat /sys/class/gpio/gpio$i/value; done

Output low level:

for i in {95,94,21,22,140,141}; do echo 0 >gpio$i/value; done
for i in {13,14,96,93,108,107}; do echo 0 >gpio$i/value; done

4. Configure GPI (system configuration)

for i in {13,14,96,93,108,107}; do echo in >gpio$i/direction; done

5. Get GPI value

for i in {13,14,96,93,108,107}; do cat /sys/class/gpio/gpio$i/value; done
for i in {95,94,21,22,140,141,13,14,96,93,108,107}; do cat /sys/class/gpio/gpio$i/direction; done

Note: GPIO numbers follow the kernel's global gpiochip numbering and may shift as a whole across firmware versions; if the corresponding node does not exist under /sys/class/gpio, first run echo NUMBER > /sys/class/gpio/export to export it, then proceed.

USB drive detection

dmesg | tail -20     # After insertion, kernel messages show the device name sda / sda1
lsblk                # List block devices and mount points

Mount and unmount

mkdir -p /mnt/USB1
mount /dev/sda1 /mnt/USB1
df -h
umount /mnt/USB1

SD Card

fdisk -l                        # SD card device name is usually /dev/mmcblk1p1
mount /dev/mmcblk1p1 /mnt/sdcard
umount /mnt/sdcard

Note: ext4 / vfat can be mounted directly; NTFS requires ntfs-3g, exFAT requires exfat-fuse. See 4.6 for how to view the drives on Android.

The internal screen resolution is fixed by the model (see 1.3 Model and Configuration); HDMI external output can be adjusted with xrandr.

X11 desktop

xrandr                                             # List outputs and available modes
xrandr --output HDMI-1 --mode 1920x1080 --rate 60
xrandr -o left        # Rotate left 90°
xrandr -o right       # Rotate right 90°
xrandr -o inverted    # Flip 180°
xrandr -o normal      # Restore

Temporarily add a custom resolution

cvt 800 750
# 800x750 59.86 Hz (CVT) ... Modeline "800x750_60.00" 48.50 800 840 920 1040 750 753 763 779 -hsync +vsync
xrandr --newmode "800x750_60.00" 48.50 800 840 920 1040 750 753 763 779 -hsync +vsync
xrandr --addmode HDMI-1 800x750_60.00
xrandr --output HDMI-1 --mode 800x750_60.00

Wayland / Weston (when using a Wayland session)

Ubuntu 20.04 uses Xorg by default, so the xrandr method applies; if you switch to a Wayland session, xrandr is not supported under Wayland — edit /etc/xdg/weston/weston.ini:

[output]
name=HDMI-A-1
mode=1920x1080

Reboot the system or restart the weston service for the changes to take effect.

Dual display mode

For the definitions of the clone (mirror) and extended modes, see 4.8. On Linux, use the desktop display settings or xrandr to control the on/off and position of the two outputs.

sudo apt update && sudo apt install -y openssh-server
sudo systemctl enable --now ssh
ip addr show

Transfer from a PC:

scp ./update.img root@192.168.8.55:/home/root/

Graphical tools: WinSCP / FileZilla, protocol SFTP, port 22.

There are three methods, grouped by startup timing; choose as needed, and the methods can be combined: before login → at login → after entering the graphical interface. Place the same program in only one of them.

Suitable for background services that do not depend on the desktop and must run at boot.

1. Edit the /etc/rc.local file
2. Add the program call before exit 0
3. Save and exit (press Esc, type :wq and press Enter)

sudo vim /etc/rc.local
 
# Add before exit 0
/path/to/myprogram &
exit 0

Note: /path/to/myprogram is the full program path; the trailing & runs the program in the background; otherwise, it blocks the subsequent login process. The last line of the file must be exit 0 for the script to be executed.

Note: Ubuntu 20.04 does not enable /etc/rc.local by default; make sure rc-local.service is enabled. For systemd-only setups, use a custom service or the startup script in 5.8.3 instead.

It applies only to the current user and runs once the user has logged in.

1. Edit the user profile file ~/.profile
2. Append the startup command at the end of the file
3. Save and exit
4. Run source ~/.profile to apply the changes immediately

vim ~/.profile
 
# Append at the end of the file
/path/to/myprogram &
 
source ~/.profile

Note: ~/.profile applies only to the current user; to apply to all users, use /etc/profile instead.

Use this for applications that need to display a UI only after the desktop is up (e.g. a full-screen main program).

Debian (LXDE)

1. Edit the autostart file
2. Append the startup command at the end
3. Save and exit; reboot or re-login for the changes to take effect

vim /root/.config/lxsession/LXDE/autostart
 
# Append at the end
/path/to/myprogram > /dev/null 2>&1 &

Ubuntu

On Ubuntu, this is handled uniformly by a startup script; write the command into /nodka_test/autorun.sh (this script runs automatically after the desktop starts).

sudo vim /nodka_test/autorun.sh
 
# Append at the end
/path/to/myprogram > /dev/null 2>&1 &

Note: > /dev/null 2>&1 discards program output to avoid filling the partition with logs; & ensures background execution.

The LXDE panel (taskbar / menu bar) configuration is stored in:

$HOME/.config/lxpanel/LXDE/panels/panel

Open it with a text editor to add/remove plugins and adjust position and size; after editing, run lxpanelctl restart or log in again for the changes to take effect.

Default contents of the desktop autostart file /root/.config/lxsession/LXDE/autostart:

@lxpanel --profile LXDE
@pcmanfm --desktop --profile LXDE
@xscreensaver -no-splash
pulseaudio -D
/nodka_test/autorun.sh

To disable the desktop and show only the application UI, simply comment out the first three lines:

#@lxpanel --profile LXDE
#@pcmanfm --desktop --profile LXDE
#@xscreensaver -no-splash
pulseaudio -D
/nodka_test/autorun.sh

Note: After commenting out the panel and PCManFM, the desktop has no taskbar and no wallpaper icons, showing only the autostart program window; this is suitable for units shipped with a full-screen application.

The boot LOGO is stored in the resource partition. Execute steps ① ~ ⑥ in order in the Linux terminal on the unit (root privileges required): for steps requiring commands, the description corresponds to the code block immediately following; see the table below for the file location in step ④.

① Prepare the BMP image

Prepare a BMP image and set its size to the screen resolution (e.g. HDMI 1920×1080).

② Copy the bmpconvert tool and grant execute permission

Download the bmpconvert conversion tool (2.3 KB, unzip to get the script). Then unzip the tool and copy it to /usr/bin:

sudo cp bmpconvert /usr/bin/
sudo chmod +x /usr/bin/bmpconvert

③ Mount the resource partition

sudo mount /dev/block/by-name/resource /mnt

④ Place the boot LOGO file

Place the BMP image into /mnt with the file name corresponding to the screen type:

⑤ Convert Images with bmpconvert

For HDMI / eDP / LVDS screens, run:

sudo bmpconvert /mnt/logo.bmp
sudo bmpconvert /mnt/logo_kernel.bmp

For MIPI screens, use the corresponding file name instead:

sudo bmpconvert /mnt/logo_mipi.bmp
sudo bmpconvert /mnt/logo_kernel_mipi.bmp

Error handling: If step ⑤ produces the following output, the system only has python3 and lacks the python command:

root@rk3568: bmpconvert /mnt/logo.bmp
/usr/bin/env: 'python': No such file or directory
root@rk3568: bmpconvert /mnt/logo_kernel.bmp
/usr/bin/env: 'python': No such file or directory

Create the python symlink first, then rerun the two commands in step ⑤:

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.9 1
sudo bmpconvert /mnt/logo.bmp
sudo bmpconvert /mnt/logo_kernel.bmp

⑥ Reboot the system

sudo reboot

Note: logo.bmp is displayed during the U-Boot stage and logo_kernel.bmp during the kernel boot stage; replace both. Back up the original files under /mnt before making changes.

HDMI: Supported by default; default output 1920×1080, no configuration needed.

eDP / LVDS: The display parameters must match the panel. Run dis in the terminal to open the display settings interface, select the matching parameters and click Save; reboot to apply.

dis

Display Settings interface: Select parameters matching the panel and click Save.

Debian: Modify the Xorg Configuration

1. First use xrandr to check the screen node name (e.g. eDP-1, HDMI-1)
2. Edit /etc/X11/xorg.conf.d/20-modesetting.conf
3. Change the Option “Rotate” value and reboot

Section "Monitor"
    Identifier "eDP-1"              # Screen node name, query with xrandr
    Option "Rotate" "inverted"      # Rotation direction, see the table below
EndSection

Ubuntu: Use xrandr

xrandr --output HDMI-1 --rotate left       # Rotate left 90°
xrandr --output HDMI-1 --rotate right      # Rotate right 90°
xrandr --output HDMI-1 --rotate inverted   # Rotate 180°
xrandr --output HDMI-1 --rotate normal     # Restore default

Note: Add the rotation command to the end of /nodka_test/autorun.sh to apply it automatically at boot.

Touch Rotation

After screen rotation, touch coordinates will be misaligned; modify CalibrationMatrix in /usr/share/X11/xorg.conf.d/40-libinput.conf accordingly:

Section "InputClass"
    Identifier "libinput touchscreen catchall"
    Option "CalibrationMatrix" "-1 0 1 0 -1 1 0 0 1"
    MatchIsTouchscreen "on"
    MatchDevicePath "/dev/input/event*"
    Driver "libinput"
EndSection

The upgrade is performed by the on-board /usr/bin/ota script. Edit the script as needed, set the FTP address and account, place the corresponding firmware at the FTP download location, then run ota. The files to modify and the corresponding code are as follows.

① Edit the upgrade script /usr/bin/ota

sudo vim /usr/bin/ota

② Set the following three items in the script

URL=ftp://<firmware server address>
USERNAME=<username>
PASSWORD=<password>

③ Save and run the upgrade

ota

Follow the prompts to complete the upgrade.

Note: The server address, account and firmware directory are provided by us; do not power off during the upgrade; the device reboots automatically when complete.

Under Linux, the on-board /usr/bin/ota script performs the OTA update, with the USB drive as temporary firmware storage. Follow steps ① ~ ⑤ in order: for steps requiring commands, the description corresponds one-to-one with the code block immediately following it; ③④ are condition checks and require no commands.

① Unmount the USB drive

sudo umount /dev/sdb

② Format the USB drive as ext4

sudo mkfs.ext4 /dev/sdb

③ Confirm the system supports OTA update

The board must already have the /usr/bin/ota script (see 5.10.1 for script configuration).

④ Confirm USB drive specifications

The USB drive must be formatted as Linux ext4 with more than 8G of free space; otherwise the upgrade package cannot be written.

⑤ Plug in the network cable and USB drive, then run the upgrade

ota

Follow the prompts to complete the upgrade; do not power off during the process; the device reboots automatically when complete.

Note: /dev/sdb is a common device node for USB drives; the actual node depends on the lsblk output. This section describes the Linux OTA update (ext4, ≥8G, ota command); it is a separate process from the Android USB drive upgrade in 3.4 (FAT32, update.img) and the Android OTA update in 4.13; do not mix them.

On a Debian / Ubuntu host, a single command installs the aarch64 cross toolchain; then confirm the version with -v:

sudo apt install -y crossbuild-essential-arm64
aarch64-linux-gnu-gcc -v

For a specific version, download the corresponding toolchain from ARM (developer.arm.com/downloads/-/gnu-a), extract it, then add the bin directory to PATH:

export PATH=$PATH:/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu/bin/
aarch64-none-linux-gnu-gcc --version

Note: Write it to ~/.bashrc or /etc/profile to make it permanent; replace the path with the actual extraction directory.

Common cross-compilation toolchains and how to obtain them:

• aarch64-linux-gnu-gcc cross toolchain: Provided in the SDK prebuilts directory
• arm-linux-gnueabihf cross toolchain: For compiling 32-bit user-space programs
• x86 host arm64 cross-compilation toolchain: Released by ARM, for compiling aarch64 (arm64) programs on an x86_64 host

Download: gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu.tar.xz — Baidu Netdisk, extraction code hkku

Note: This toolchain requires no installation; extract it and add the bin directory inside the archive to PATH; call aarch64-none-linux-gnu-gcc when compiling.

Preinstalled environments: Debian 11 → Qt 5.15.2, Ubuntu 20.04 → Qt 5.12.8. Choose between the two methods as applicable.

Use a ready-made build image; the host does not need Qt installed, isolation is good, and it suits batch compilation.

1. Import the image
2. Start the container and mount the application directory to /mnt (replace source with the actual path)
3. Inside the container, enter /mnt and run qmake and make

sudo docker load < nodka_docker_qt_build_20230223.tar
 
sudo docker run --rm --mount type=bind,source=/home/APP_PATH,target=/mnt/ -i -t 09a37c1b2fc3 /bin/bash
 
cd /mnt
qmake
make

Note: The image is large and is provided separately by us; the container ID (09a37c1b2fc3) is taken from the actual docker images output.

1. Install Qt Creator

sudo apt-get install qtcreator
sudo apt-get install qt5-default

If qt5-default has been removed from the official repository, use the following set of dependencies instead:

sudo apt-get install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools qtcreator

2. Add qmake

Qt Creator → Tools → Options → Kits → Qt Versions → Add, select the on-board qmake:

/usr/local/qt5.12-arm/bin/qmake

Add the on-board qmake path in Qt Versions.

3. Configure the Cross-Compiler

In the same window, switch to Compilers → Add → GCC and add g++ and gcc respectively:

g++: /usr/bin/aarch64-linux-gnu-g++
gcc: /usr/bin/aarch64-linux-gnu-gcc

g++ compiler location:

gcc compiler location:

Add the cross-compiler; when the host has crossbuild-essential-arm64 installed, the compiler is under /usr/bin; with a third-party toolchain, enter its installation path.

4. Configure the Debugger (optional, for online debugging)

sudo apt install -y gdb-multiarch

The board must have /usr/bin/gdbserver; if not, install gdbserver (included in Buildroot, no installation needed). Add /usr/bin/gdb-multiarch in Debuggers in Qt Creator.

5. Configure Devices

Enter the board IP and username root; set a static IP for the board to avoid disconnections during debugging.

6. Configure Kits

Combine the Qt version, compiler, debugger and device above into one Kit. When the target system is Ubuntu, also fill in the sysroot path in the Kit.

In Kits, combine the Qt version, compiler, debugger and device.

The on-board VPU supports H.264 / H.265 hardware encoding and decoding; the system ships with GStreamer plugins and OpenGL ES / OpenCL runtime libraries.

GStreamer Encoding/Decoding

The system includes test scripts; run them directly to verify hardware decoding and encoding:

/rockchip-test/video/test_dec-gst.sh    # Hardware decode test
/rockchip-test/video/test_enc-gst.sh    # Hardware encode test

OpenGL ES

Use glmark2 to benchmark and verify the GPU:

glmark2-es2

WebGL

Open Chromium, enter the following address in the address bar, and check WebGL and hardware acceleration status:

chrome://gpu

OpenCL

clinfo

clinfo output: confirm platform, device and OpenCL version information.

This chapter covers query commands, which are basically the same under Android (adb shell) and in the Linux terminal; differences are noted in individual entries where applicable.

cat /sys/class/thermal/thermal_zone0/temp
# Output is in millidegrees Celsius; 45200 means 45.2℃

cat /proc/device-tree/serial-number
# On Android
getprop ro.serialno

cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies

free -h
cat /proc/meminfo | head -3

df -h
lsblk

ping -c 4 192.168.8.1
ping -c 4 www.baidu.com
ping -c 1 -W 1 8.8.8.8

# Check the system time
date
# Set the system time and write it to the RTC chip
sudo date -s "2025-04-08 17:01:01"
sudo hwclock -w
sudo hwclock -r

Verification: Power off and disconnect power for more than 5 seconds, then power on and use date to check whether the time is retained.

Note: Network time synchronization is enabled by default; perform the RTC test with the external network disconnected.

Time Zone Settings

ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
reboot

In the GUI, select the time zone under “Preferences → Time and Date”; to set another time zone, replace Asia/Shanghai in the command with the corresponding city.

For previous versions, contact Technical Support.

• Firmware, flashing tools, SDK and specifications: contact Sales or Technical Support
• When reporting an issue, provide: unit SN (see 6.2 for how to view it), system version, reproduction steps and screenshots
• If an exception occurs after modifying the system yourself, reflash the factory firmware first (see 3.3) before deciding whether it is a hardware issue