1、Download the buring tool：

• Be sure to install the driver first. The burning tool link contains driver DriverAssitant ziitant package, extract it and click DriverInstall.exe to install the driver.

2、Start Burn：

• Connect one end of the data cable to the OTG of the motherboard and the other end to the computer. Note that before burning, the power should be turned off. Press and hold the boot_key button to burn when the power is turned on.

• Open the development tool in the compressed package, click Upgrade firmware first, then click firmware and select good firmware, and finally click upgrade to start burning.

• The state of the burning process, there will be a progress display.

• When changing the system platform (such as switching from Android to Linux), it may fail to burn. At this time, open the development tool, click advanced functions first, and then click into Maskrom to switch the burning mode and then burn the system。

3、Finish burning：

• There is no need for any operation in the process of burning. After successful burning, the right box will show that the device restarts automatically and the burning is complete.

1.IO - Control Node：ls /sys/class/io_control -l

2.IO - Corresponding form as follows：

3.IO control method：

• Output low level：

echo 0 >/sys/class/io_control/gpio_op0

*Output high level：

echo 1 >/sys/class/io_control/gpio_op0

*View input level：

cat /sys/class/io_control/gpio_ip0

1. Serial port definition reference：

• Interface definition

2. A serial port device node system corresponding to the table：

3. CuTecom test serial port to COM3 loopback test, for example

• Refer to step 1 ~ 2 sub COM3 TX and RX (2 ~ 3 pin).
• Double-click the desktop CuteCom icon to open the APP, Device selection test port corresponding Device node (see step 2).
• Click Settings to set the serial port parameters, as shown in the picture below:

• Set up after click Open to Open the serial port, input characters in the input text input box, and press enter to send data:

4. Command line mode test serial port, the same COM3 loopback test, for example

Open the terminal and enter the following command to receive data:

com_recv /dev/ttyXRUSB2 115200

Open another terminal to send data:

com_send /dev/ttyXRUSB2 115200

The test result is given as：

1. Check the network card IP address, the system will default to get the dynamic IP address

#ifconfig -a 

2. Set the static IP address of the NIC

• Method 1 – Set up using graphical interface tools

Double-click the desktop icon：Advanced Network Configuration

• Method 2 – How to modify the configuration file:

vim /etc/network/interfaces

• After the modification is complete, enter restart to take effect.

1. Click the network icon in the lower right corner to browse the available WIFI routes:

• Enter your WIFI password and click connect

2. Method 2 – Connect to wifi from the command line

nmcli d wifi connect "SSID" password "PASSWROD"

1. The system has automatic dialing, Open the terminal and enter the command 4g to dial automatically:

root@rk3399:~# 4g

2. After the dial-up is complete, view the IP address:

3.Open a browser and browse any website.

4. The 5G test method is similar to 4G, and the command 5G can be automatically dialed:

root@rk3399:~# 5g

1.IO - Control Node：ls /sys/class/io_control -l

2.IO - Corresponding form as follows：

3.IO control method：

• Output low level：

echo 0 >/sys/class/io_control/gpio_op0

*Output high level：

echo 1 >/sys/class/io_control/gpio_op0

*View input level：

cat /sys/class/io_control/gpio_ip0

• Connect the horn to the SPK port on the board

1. Method ① – Use the SMPayer player delivered with the system and the audio test file to test the audio function

2. Method 2 – Using commands to play:

aplay  /nodka_test/LR_audio.wav  -D  hw:0,0

• Recording test

arecord -d 5 -f cd -r 44100 -c 2 -t wav test.wav  
aplay test.wav

1. The USB flash drive is automatically mounted to /media/disk

root@rk3399:~# df -h
File system        capacity  used  available used% Mount point
/dev/root        15G  3.6G   10G   27% /
devtmpfs        980M     0  980M    0% /dev
tmpfs           981M     0  981M    0% /dev/shm
tmpfs           981M  8.8M  972M    1% /run
tmpfs           5.0M  4.0K  5.0M    1% /run/lock
tmpfs           981M     0  981M    0% /sys/fs/cgroup
tmpfs           197M   16K  197M    1% /run/user/0
/dev/sda1        57G  2.7G   54G    5% /media/disk

* SDcard Automatic mounting：

root@rk3399:~# df -h
File system        capacity  used  available used% Mount point
/dev/root        15G  3.6G   10G   27% /
devtmpfs        980M     0  980M    0% /dev
tmpfs           981M     0  981M    0% /dev/shm
tmpfs           981M  8.8M  972M    1% /run
tmpfs           5.0M  4.0K  5.0M    1% /run/lock
tmpfs           981M     0  981M    0% /sys/fs/cgroup
tmpfs           197M   16K  197M    1% /run/user/0
/dev/mmcblk0p8   30G  3.8G   25G   14% /media/3699f79c-f05d-4948-89c9-04dc4b132a1f

umount：

umount /dev/mmcblk0p8

mount：

mount /dev/mmcblk0p8 /sdcard

1. Open the Bluetooth manager and search for nearby Bluetooth devices:

2. Select Bluetooth device, pair and then select Trust:

3. To set the Bluetooth connection type:

1. Run the evtest command to view all keys and input devices in the system:

root@rk3399:~# evtest 
No device specified, trying to scan all of /dev/input/event*
Available devices:
/dev/input/event0:	ff420030.pwm
/dev/input/event1:	USB Optical Wheel Mouse
/dev/input/event2:	SIGMACH1P USB Keyboard
/dev/input/event3:	rk29-keypad
/dev/input/event4:	SIGMACH1P USB Keyboard
Select the device event number [0-4]: 

2. Select a test key as prompted. For example, the RK3399 boot key is /dev/input/event3: rk29-keypad

The event number is 3：Pressing the key prints a value of 1,Releasing the key prints a value of 0,As shown below：

3. Customize the key function. The configuration file is

/etc/triggerhappy/triggers.d/example.conf

The key is the reboot function. It is also the default configuration of the system. You can customize the key as required。

KEY_VOLUMEUP    1   reboot

1. The system supports switching between different LCD screens using APP. Run the dis command to open the APP as shown in the following figure：

• Select the corresponding eDP/LVDS screen resolution and click Save. After the system restarts automatically, you can switch to the specified LCD:

2. Backlight brightness adjustment:

• Method 1: Click the following icon in the system tray at the lower right corner to open the backlight adjustment APP

• Method 2: Control driver application layer interface:

 echo 100 > /sys/class/backlight/backlight1/brightness  

(Note: The larger the value written, the greater the brightness，max_brightness 为250)

1. Power management Settings：

Press POWER to wake up after sleep 2. The power management function is not supported by all products. To customize the system, contact the service window personnel.

1.View the current system time:

[root@rk3399:~]# date
Wed Jun  8 15:54:09 CST 2022

2. To set the synchronization hardware clock:

[root@rk3399:/]# date -s "2022-06-08 17:01:01"
Wed Jun  8 17:01:01 CST 2022
[root@rk3399:/]# hwclock -w
[root@rk3399:/]# hwclock -r
Wed Jun  8 17:01:09 2022  0.000000 seconds

3. Power off for more than 5 seconds, and then turn it on to check whether the system time is saved:

[root@rk3399:/]# date 
 Wed Jun  8 17:02:30 CST 2022

Note: The system uses network time synchronization by default. The above RTC test needs to be conducted when the external network is disconnected. 4. Time zone setting

• Method 1 – Modify the link file, such as China, Shanghai:

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

To set other time zones, simply change Asia/Shanghai in the preceding command to the corresponding time zone city.

• Method 2 – Open preferences -&gt in sequence on the graphical interface; Time and date, select the time zone as shown below:

Close the window and run the date command to view the time zone change:

To view CPU information:

cat /proc/cpuinfo

Check the memory capacity:

free -h

View the available capacity of the EMMC

df -h

C The reference code is as follows：

#include <stdio.h> 
#include <stdlib.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <unistd.h> 
#include <string.h> 
static char gpio_path[100];
//Set the GPIO direction and high and low level
static int gpio_config(const char *file, const char *value) 
{ 
	char config_path[100]; 
	int len; 
	int fd; 
	sprintf(config_path, "%s/%s", gpio_path, file); 
	if (0 > (fd = open(config_path, O_WRONLY))) 
	{
		perror("open error"); 
		return fd; 
	} 
	len = strlen(value); 
	if (len != write(fd, value, len))
	{ 
		perror("write error"); 
		close(fd); 
		return -1; 
	} 
	close(fd); 
	return 0; 
} 
//Get the direction and level of GPIO
static int gpio_get(const char *file)
{ 
	char get_path[100]; 
	char buf[10]={"\0"};
	int len; 
	int fd; 
	sprintf(get_path, "%s/%s", gpio_path, file);
	if (0 > (fd = open(get_path, O_RDWR)))
	{
		perror("open error"); 
		return fd; 
	}
	if ( 0 > read(fd,buf,10))
	{
		perror("read error"); 
		return fd; 
	}
	printf("  %s : %s",file,buf);
	close(fd); 
	return 0; 
}
int main(int argc, char *argv[]) 
{ 
	 if (4 != argc) 
	{ 
		if (3 != argc)
		{
			fprintf(stderr, "set gpio out : %s <gpio> <out> <value>\n", argv[0]); 
			fprintf(stderr, "set gpio in  : %s <gpio> <in>\n", argv[0]); 
			exit(-1); 
		}
	}	 
	sprintf(gpio_path, "/sys/class/gpio/gpio%s", argv[1]); 
	if (access(gpio_path, F_OK)) 
	{ 
		printf("%s inexistence,export %s... \n",gpio_path,argv[1]);
		int fd; 
		int len; 
		if (0 > (fd = open("/sys/class/gpio/export", O_WRONLY))) 
		{
			perror("open error"); exit(-1); 
		} 
		len = strlen(argv[1]); 
		if (len != write(fd, argv[1], len)) 
		{
			perror("write error"); 
			close(fd);
			exit(-1); 
		} 
		close(fd);
	} 
	if (gpio_config("direction", argv[2])) 
		exit(-1);	
	if ( 0 == strcmp("out",argv[2] ) && argc == 4 )
	{
		if(gpio_config("value", argv[3]))
		exit(-1); 
	}
	printf("gpio_op%s:\n",argv[1]);	
	if (gpio_get("direction"))
		exit(-1);
	if (gpio_get("value"))
		exit(-1);
	 exit(0); 
}

Cross-compiled source code：

aarch64-linux-gnu-gcc -o a.out gpio.c

Copy the compiled gpio program to rk3399 motherboard using scp and perform the test:How to use:

0：./gpio 0 out 0

1：./gpio 0 out 1

Operating the test serial port of the UART in the system, using the COM2 test as an example:

COM2 The device node is：

/dev/ttyXRUSB1

C Reference UART high and low level input codes are as follows：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define UART_DEVICE     "/dev/ttyXRUSB1" //UART Device file name
 
int main(int argc, char *argv[])
{
 
    int fd, res;
    struct termios  oldtio, newtio;
    char  ch;
    char buf[256] = {0};
 
//-----------Open the uart device file------------------
    fd = open(UART_DEVICE, O_RDWR|O_NOCTTY);//No setting O_NONBLOCK。So here read and write are blocking operations
    if (fd < 0) {
        perror(UART_DEVICE);
        exit(1);
    }
    else
    	printf("Open %s successfully\n", UART_DEVICE);
 
//-----------Set operating parameters-----------------------	
    tcgetattr(fd, &oldtio);//Gets the current operation mode parameters
    memset(&newtio, 0, sizeof(newtio));
 
	//Baud rate =115200 Data bits =8 Enable data receiving 
    newtio.c_cflag = B115200|CS8|CLOCAL|CREAD;
    newtio.c_iflag = IGNPAR; 
 
    tcflush(fd, TCIFLUSH);//Clear the input and output buffers
    tcsetattr(fd, TCSANOW, &newtio);//Set a new operation parameter
 
//------------Send data to urat-------------------
    res=write(fd, "Begin Uart tx", 16);
    while(1) {
    	// Get the data from the console terminal and send it through the uart until it is received! Character
        while((ch=getchar()) != '!') {
            buf[0]=ch;
            res=write(fd, buf, 1);
        }
 
        buf[0]=ch;
        buf[1]=' ';
        res = write(fd, buf, 2);
        break;
    }
//-------------Receive data from the uart-------------------
    while(1) {
    	res = read(fd, buf, 255);//Here the program will hang until data is received from the uart (blocking operation)
    	if (res == 0) 
  			continue;
 
  		buf[res] = ' ';
  		printf("res = %d, buf = %s\n", res, buf);//Print out the characters received by the uart
  		if (buf[0] == '!')//uart received! Exit the while after the character
  			break;
  	}
//------------Close the uart device file and restore the original parameters--------
    close(fd);
    printf("Close %s\n", UART_DEVICE);
    tcsetattr(fd, TCSANOW, &oldtio); //Restore the original Settings
 
    return 0;
}
 
}

Cross-compile source code:

aarch64-linux-gnu-gcc -o uart uart.c

Copy the compiled program to 3399 motherboard using scp, and perform the test:

For details, see the method of operating a key in the system

/dev/input/event2

C The reference code is as follows:

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/input.h>
#include <sys/select.h>
#define INPUT_DEVICE "/dev/input/event2"
int main(int argc, char **argv){
	int fd;
	struct input_event event;
	ssize_t bytesRead;
	int ret;
	fd_set readfds;
	if ( 0 > (fd = open(INPUT_DEVICE,O_RDONLY)))
	{
		perror("open error"); 
		return fd; 
	}
	while(1){
		FD_ZERO(&readfds);
		FD_SET(fd,&readfds);
		ret = select(fd + 1, &readfds, NULL, NULL, NULL);
		if (ret == -1){
			fprintf(stderr,"select call on%s : an error ocurred",argv[1]);
		break;
		}	
		if(FD_ISSET(fd,&readfds)){
			bytesRead = read(fd, &event,sizeof(struct input_event));
			if(bytesRead == -1 )
				fprintf(stderr,"bytesRead :%ld : an error ocurred",bytesRead);
			}	
		if(event.type == EV_KEY && (event.value == 0 || event.value == 1))
		{
			printf("key %s\n",(event.value) ? "pressed" : "released");
		}
	}
	close(fd);
	return EXIT_SUCCESS;
}

Cross-compile source code:

 
aarch64-linux-gnu-gcc -o key key.c

Copy the compiled program to the r39s2 motherboard using scp, perform the test, press the key to print as follows:

• Display when the key is pressed：key pressed
• Display when the key is released：key released

* Host environment recommendation：Debian 10 x64 bit，

    
 The company has configured the QT compilation environment- Docker image:[[ftp://drv.nodka.com/arm_download/nodka_docker_qt_build_20230223.tar |  QT编译环境Docker]]
 ### load docker image 
 sudo docker load <nodka_docker_qt_build_20230223.tar
 
 ### Run the docker image,notice : /home/APP_PATH为QT-Directory where the application program resides
 sudo docker run --rm --mount type=bind,source=/home/APP_PATH,target=/mnt/ -i -t 09a37c1b2fc3 /bin/bash 

 ###  Compile the QT application
 cd  /mnt
 qmake
 make

* Refer to the steps for configuring the host cross-compilation environment：

1. Install the cross-compile toolchain：

  apt install -y crossbuild-essential-arm64
  

2. Copy /usr/lib/lib from the tablet system to the host /home/nodk/qt5/qt_sysroot directory

3. Configure the following environment variables

QTSYSROOT="/home/nodka/qt5/qt_sysroot"
QTPATH=$QTSYSROOT/usr/local/qt5.12-arm
  
LD_LIBRARY_PATH=$QTPATH/lib:$LIBRARY_PATH
LIBRARY_PATH=$QTPATH/lib:$LIBRARY_PATH
C_INCLUDE_PATH=$QTPATH/include:$C_INCLUDE_PATH
PATH=$QTPATH/bin:$PATH
  
PKG_CONFIG_PATH=$QTPATH/lib/pkgconfig:$PKG_CONFIG_PATH
  
export LD_LIBRARY_PATH
export LIBRARY_PATH
export C_INCLUDE_PATH
export CPLUS_INCLUDE_PATH
  
export PKG_CONFIG_PATH
export PATH

4. Compile APP

qmake
make

1. install

Go to the Qt official download page and select a version to download qt- creator-opensource-linux-x86_64-x.x.x.un. After the download is complete, run./xxxx.run on the terminal to run the installation.

2.configuration

After the installation is complete, start Qt Creator and open the menu Tools-> Option, find the Kits.

• configuration Qt Versions

Click the add button on the right and select qmake in the installation location of the Qt environment

qmake：

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

• configuration Compilers

Click the add button on the right to add the location of the gcc and g++ cross compiler

If crossbuild-essential arm64 is installed on the host, the compiler is under /usr/bin/

If you use a third-party cross-compiler, find the installation location and add it

If the target platform is Buildroot, you will need to use the compiler in the Buildroot Qt environment package

g++：/usr/bin/aarch64-linux-gnu-g++

gcc：/usr/bin/aarch64-linux-gnu-gcc

To facilitate debugging, configure Debeggers and Devices for online debugging:

• configuration Debuggers

Click the add button on the right to add gbd-multiarch: apt install -y gdb-multiarch

Check whether /usr/bin/gdbserver exists on the target. If not, install: apt install -y gdbserver. If not, install: apt install -y gdbserver (Buildroot comes with Buildroot)

Go back to Qt Creator on the host and click the add button on the right to add gdb

Select gdb-multiarch: /usr/bin/gdb-multierch on the host

• configuration Devices

Set the IP address and user name of the device (root). To facilitate debugging, set a static IP address on the device.

• configuration Kits

Add the configuration item set earlier to Kits.

If the target platform is an Ubuntu system, this step also requires adding the sysroot path

Docker English-Community supports the following versions of Ubuntu：

• Xenial 16.04(LTS)
• Bionic 18.04(LTS)
• Cosmic 18.04
• Disco 19.04
• Other newer versions…

The installation command is as follows：

curl -fsSL https://get.docker.com | bash -s docker --miror Aliyun

You can also use the domestic daocloud one-click install command：

curl -sSL https://get.daocloud.io/docker | sh

To test whether Docker is successfully installed, enter the following command and print the following information：

sudo docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete                                                                                                                                  
Digest: sha256:c3b4ada4687bbaa170745b3e4dd8ac3f194ca95b2d0518b417fb47e5879d9b5f
Status: Downloaded newer image for hello-world:latest


Hello from Docker!
This message shows that your installation appears to be working correctly.


To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.


To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash


Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/


For more examples and ideas, visit:
 https://docs.docker.com/get-started/

• OpenCL is supported by the system. Enter clinfo to view the details:

Terminal input ota for firmware online upgrade