forlinx embedded's pages

LVDS Screen Logo Display Optimization

The LVDS display's driver, panel-lvds, is compiled as a module by default. During boot, module-type drivers are loaded later, causing the LVDS display to initialize later, and it takes around 20 seconds for the desktop to appear on the LVDS screen.

To initialize the LVDS display earlier, you need to compile the LVDS driver into the kernel, allowing it to initialize earlier.

The main modification can be made by compiling panel-lids.c directly into the kernel in the OK6254-C_defconfig file.

OK6254-linux-sdk/OK6254-linux-kernel/arch/arm64/configs/OK6254-C_defconfig
CONFIG_DRM_PANEL_LVDS=y

And then carry out full compilation and flashing. Start after burning, LVDS will display the penguin logo about 10 seconds after starting. Here is how to replace the penguin logo with other logos.

Replace Penguin Logo With Custom Logo

First, find the location of the penguin logo as follows:

The penguin logo image used on the TI AM6254 platform is called logo _ ti _ clut224.ppm. Here's how to replace the image with a custom logo.

Note: The logo resolution cannot exceed the resolution of the LVDS screen, and the background color should be black. Take 1280x800 as an example. Here is a 1280x800 resolution picture made by the drawing software under windows, preferably in PNG format. If it is a picture in other formats, please convert it to PNG format first and then perform the following operations. （myilogo.png）

Put it anywhere on the virtual machine, and convert it to the format needed, with the following command:

pngtopnm mylogo.png > my_linux_logo.pnm
pnmquant 224 my_linux_logo.pnm > my_linux_logo_224.pnm
pnmtoplainpnm my_linux_logo_224.pnm > my_linux_logo_224.ppm

After converting the image to ppm format, copy the resulting image in ppm format to the path where the penguin logo is located. Then we convert the image in ppm format to a.c file, where we use the pnmtologo tool under the path (if you report a permission error, add sudo before the command).

./pnmtologo -t clut224 -n logo_ti_clut224 -o logo_ti_clut224.c
my_linux_logo_224.ppm

Realize logo centered display

1. Modify the fb_show_logo_line function in source code /driver/video/fbdev/core/fbmem.c.

//image.dx=0;
//image.dy=y;
image.width=logo->width;
image.height=logo->height;
image.dx = (info->var.xres / 2) - (image.width / 2);
image.dy = (info->var.yres / 2) - (image.height / 2);

Description:

The image. dx and image. dy variables are used to set the top-left corner of the image on the screen. The info-> var.xres and info-> var.yres variables represent the horizontal and vertical resolution of the screen, respectively. The image.width and image.height variables represent the width and height of the flag image, respectively. image. dx is calculated to center the image horizontally on the screen by subtracting half the image's width from half the screen's width. image. dy is calculated to vertically center the image on the screen by subtracting half the height of the image from half the height of the screen. Overall, this code centers the logo image horizontally and vertically on the screen.

2. Modify the source code/driver/video/fbdev/core/fbcon.c中的fbcon_prepare_logo() function.

After logo_height = fb_prepare_logo(info, ops->rotate); add the following line of code

logo_height += (info->var.yres / 2) - (logo_height / 2);

Now you can compile and burn it. If you are only in the debug phase, you can compile the kernel separately and replace the Image. It can also be fully compiled and then burned.

Note: If the logo is not centered or not displayed, check whether the LCD screen has been turned off, otherwise the resolution of the LCD screen will prevail.

Common issues 1

Image has more than 224 colors
Use ppmquant(1) to reduce the number of colors

Solutions

ppmquant 224 logo_ti_clut224.ppm > logo_ti_clut224_224.ppm

Common issues 2

logo_ti_clut224.ppm: Binary PNM is not supported
...

Read more

Cross-compilation Toolchain Location:

OK113i-linux-sdk/out/t113_i/ ok113i/longan/buildroot/host/bin/arm-linux-gnueabihf-gcc

Before executing the method below, please delete the out directory and decompress the cross-compilation tool chain in the lower path of the source code./buildroot/buildroot-201902/dl/toolchain-external-linaro-arm/gcc-linaro-7.3.1-2018.05-x86_64_arm-linux-gnueabihf.tar.xz

1. Modify mkcmd.sh and mkcommon.sh according to the patch modification method in the figure.

2. Go back to the sdk path and execute the following command:

forlinx@ubuntu:~/shuishui/OK113i-linux-sdk$ ./build.sh config

It is modified to emmc or NAND version according to the actual board configuration.

3. Next, execute the following command to enter the configuration of buildroot.

Enter toolchain

Modify the relevant options as shown in the figure below:

Enter target options

Because hard-float is needed, the highlighted part in the diagram needs to be modified to EABIhf.

Save and exit after setting.

Enter the following path to compile.

./build.sh

Full compilation may require an error with an environment variable, resulting in a failure to compile.

If this problem occurs, execute the following instructions and compile the buildroot.

export LD_LIBRARY_PATH=""

In the middle of compiling buildroot, you may encounter an error as shown in the following figure.

If these errors are encountered, you can find the corresponding source code and compile it through the tools in the decompressed cross-compilation chain. Subsequently, place the compiled executable file in the bin path and the library file in the lib path. Finally, continue executing ./build.sh until compilation is successful. After compiling successfully, return to the SDK path, perform full compilation build. sh, and then pack the image.

Next, write a test program to verify whether the cross-compilation chain can be successfully replaced. Here, you need to compare the program compiled with the original compilation chain with the program cross-compiled with the current compilation chain.

The part highlighted in the diagram is a program compiled using our original cross-compilation chain. It can be observed that it does not run normally. "Test" is a program compiled using the tools from the replaced cross-compilation chain, which runs normally. Additionally, the relevant information of the two programs can be determined using the ''strings'' tool.

FET113i-S is an industrial-grade SoM designed by Forlinx Embedded based on Allwinner T113-i processor. With excellent stability and ultra-high cost performance, FET113i-S SoM has gained wide attention from customers. As a multi-core heterogeneous architecture chip with an A7 core, a RISC-V core, and a DSP core, Allwinner Technology recently released the RISC-V core (XuanTie C906) details for the T113-i, and Forlinx embedded quickly adapted to this development.

1. What is RISC-V?

RISC-V is an open-source instruction set architecture (ISA) based on the principles of Reduced Instruction Set Computing (RISC). It was first introduced by the University of California, Berkeley in 2010 and has since gained significant attention and support from academia and industry worldwide. RISC-V architecture, characterized by its openness, simplicity, and scalability, is emerging as a formidable force in the global semiconductor industry.

2. What Are the Advantages of the T113-i's Risc-v?

High Efficiency and Low Power Consumption

RISC-V architecture follows the principles of reduced instruction set computer, which simplifies the hardware design, improves the execution efficiency and reduces the development cost. The RISC-V cores in the T113-i processor can efficiently perform a wide range of computational tasks while maintaining low power consumption, making it ideal for resource-constrained edge computing environments.

Modularity and Scalability

RISC-V architecture is designed with simplicity and modularity in mind, allowing different instruction set extensions to be chosen based on requirements. RISC-V core in the T113-i processor supports multiple standardized extension instruction sets, such as M (integer multiplication and division), A (atomic operations), and F/D/Q (single/double/quad-precision floating-point operations), enabling flexible combination and addition according to specific application scenarios.

Open Standard and No Licensing Fees

RISC-V is open source, allowing anyone to use and extend it for free, without licensing fees. This greatly promotes technology sharing and innovation, reducing product development costs.

Real-Time Performance

In the T113-i, the A7 core, RISC-V core, and DSP core can run simultaneously, realizing multi-core heterogeneous computing. This design enhances overall system performance and meets diverse application requirements. The RISC-V core, in particular, can accommodate applications with high real-time requirements, ensuring rapid response and processing of real-time data.

3. A Quality Choice for Cost Reduction

Forlinx Embedded FET113i-S SoM, with completed RISC-V core adaptation, is highly competitive in price. Its industrial-grade quality enables it to handle more complex application scenarios, while its comprehensive peripheral interface resources make it both powerful and user-friendly.

FET113i-S SoM's clear advantages, combined with Folinx Embedded's stable supply chain and robust technical support, ensure swift project implementation and market primacy for customers.

Description

PWM (Pulse Width Modulation) is very common in embedded systems. It provides a method for generating pulse periodic wave-forms for motor control or can function as a digital-to-analog converter with some external components.

RK3562 supports 16 interrupt-driven on-chip PWM channels and offers capture mode with the following features:

• Measurement of high/low polarity effective periods of input waveforms;
• Generation of a single interrupt when the input waveform polarity changes;
• 32-bit high polarity capture register
• 32-bit low polarity capture register
• 32-bit current value register
• Capture results can be stored in an 8-depth FIFO FIFO data can be read by CPU or DMA
• Channel 3 supports a 32-bit power key capture mode
• Supports switching IO between channel 3 and channels 0/1/2
• Supports input pulse counters
• Supports input filters to eliminate noise

The capture mode of the RK3562 uses the PWM channel clock to measure the high/low effective periods of the PWM channel input waveforms and generates interrupts when the polarity of the input waveform changes. It can also capture the pulse counts of the input waveform, which can be used to measure waveform information such as duty cycle and frequency.

Application Scenario

PWM capture is a technique used to measure the cycle, frequency, and duty cycle of external signals. In the power sector, real-time data acquisition is essential for analyzing and monitoring grid power due to the normal fluctuations in grid frequency. The PWM capture technology can be utilized to detect grid frequency in real-time.

This article will use a signal generator to produce square waves of specific frequencies to simulate signal input in real application scenarios and provide a simple demonstration of the PWM capture function of the RK3562.

Cases

Development Board Model: OK3562-C + FET3562J-C

Forlinx Material Version: OK3562-C_Linux 5.10.198_User Manual_R1

Development Board System: Linux 5.10.198 (CPU0, 1, 2) + RT-Thread (CPU3)

Hardware Preparation:

One set of OK3562-C development board

One signal generator

Several Dupont wires

Software Preparation:

Please contact Forlinx to get it!

Source Code Compilation:

Extract the source code and enter the OK3562-linux-source directory

Execute ./build.sh defconfig:forlinx_ok3562_linux_rtos_defconfig to change the compilation configuration to run Linux on 3 CPUs and RT-Thread on 1 CPU in AMP mode;

Execute ./build.sh for a full compilation and wait for the process to complete;

The compiled update.img image is saved in the rockdev directory.

Testing Steps:

1. Follow the user manual in the software materials to burn the image. After burning, power on the device; RT-Thread will print the following:

2. Execute fl_pwmcap to enable PWM capture functionality and start detecting the input signals. Successful startup will appear as shown below:

3. Turn on the signal generator and change the output mode to continuous pulse waveform, with a frequency set to 10 kHz and a duty cycle of 90%.

After enabling the output of the signal generator, the board will start printing the measured period and duty cycle (the 89% duty cycle is due to the program's calculation not preserving decimal points, causing some errors).

Change the duty cycle of the signal generator to 30%, and the board output will reflect this change to 30%.

Change the frequency of the signal generator to 500 kHz and duty cycle to 75%, and continue observing the board output:

Routing is a core component of device networking, responsible for intelligent data packet forwarding, ensuring efficient communication and internet access. It also assigns IP addresses to devices connected via the network interface, ensuring stable and secure connections. Below is a guide on how to implement routing functionality on the Forlinx i.MX93 platform.

1. Bridge Building

1.1 Busybox Compilation and Brctl Tool Loading

There is no brctl tool in the busybox of the 93 development board, so it needs to be recompiled. If the busybox of the board has the brctl tool, this step can be ignored.

Down load busybox-1.35 source code, website： https://busybox.net/

Unzip it on the 93 development environment and execute make menuconfig to configure.

forlinx@ubuntu:~/work/busybox$ tar -xvf busybox-1.35.0.tar.bz2
forlinx@ubuntu:~/work/busybox$ cd busybox-1.35.0/
forlinx@ubuntu:~/work/busybox/busybox-1.35.0$ . /opt/fsl-imx-xwayland/5.15-kirkstone/environment-setup-armv8a-poky-linux forlinx@ubuntu:~/work/busybox/busybox-1.35.0$ make menuconfig

Select Setting-->[*] Don't use /usr

In this way, it will be installed to the directory specified by itself (default./_ install). This option must be selected, otherwise busybox will be installed under/usr of the original system after make install, which will overwrite the original commands of the system. After selecting this, make install will generate the _ install directory under the busybox directory, which contains the busybox and the link pointing to it.

Add cross-compilation path (it can be set according to your own requirements):
Setting-->--- Build Options

(arch64-poky-linux-) Cross compiler prefix (/opt/fsl-imx-xwayland/5.15-kirkstone/sysroots/armv8a-poky-linux) Path to sysroot                          (-O2 -pipe -g -feliminate-unused-debug-types) Additional CFLAGS                                                    (-Wl,-O1 -Wl,--hash-style=gnu -Wl,--as-needed  -Wl,-z,relro,-z,now) Additional LDFLAGS 

Select brctl tool

Networking Utilities --->[*] brctl (4.7 kb)

Modify and then compile

forlinx@ubuntu:~/work/busybox/busybox-1.35.0$ make
forlinx@ubuntu:~/work/busybox/busybox-1.35.0$ make install

Copy the generated busybox command to the development board/home/root path

1.2 Kernel Source Code Modification

forlinx@ubuntu:~/work/ok-mx93/OKMX93-linux-sdk/OKMX93-linux-kernel$ vi drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
(478 line)
/*      if (hw->promisc) {                netdev_err(dev,                           “Adding VLAN in promisc mode not supported\n");                return -EPERM;        }*/
（533 line）
/*      if (hw->promisc) {                netdev_err(dev,                           "Deleting VLAN in promisc mode not supported\n");                return -EPERM;        }*/

Save and recompile the kernel after modification, generate Image and update the kernel

1.3 Building a Bridge With Brctl

root@ok-mx93:~# ./busybox brctl addbr br0 //Create bridge device br0
root@ok-mx93:~# ./busybox brctl stp br0 off //Turn off the STP
root@ok-mx93:~# ./busybox brctl addif br0 eth0 //Add eth0 to the bridge
root@ok-mx93:~# ./busybox brctl addif br0 eth1 //Add eth1 to the bridge
root@ok-mx93:~# ifconfig br0 192.168.0.10 up configure br0 ip and start it

2. 4G for Network Forwarding

2.1 4G Dial-up

If there is command service, you need to delete it and restart.

root@ok-mx93:~# rm /usr/sbin/connmand
root@ok-mx93:~# sync
root@ok-mx93:~# reboot
root@ok-mx93:~# fltest_quectel.sh
root@ok-mx93:~# ifconfig eth0 up
root@ok-mx93:~# ifconfig eth1 up

Note: The network port will be closed in the 93 dial-up script. If it is not necessary, you can comment out the command to close the network port in the script.

2.2 Route Priority Adjustment

Checking with ''route -n'' reveals that the priorities of eth0 and eth1 are higher than 4G. At this point, 4G cannot access the Internet, so it is necessary to adjust the priorities to avoid affecting the 4G network.

root@ok-mx93:~# route -n
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.1.1     0.0.0.0         UG    0      0        0 eth0
0.0.0.0         192.168.2.1     0.0.0.0         UG    0      0        0 eth1
0.0.0.0...

Read more

The touchscreen driver usually employs the input subsystem driver framework, so the application layer interface must adhere to the interfaces of the input framework.

By entering ls -l /dev/input in the command line, you can see the current input devices available.

root@freescale ~$ ls -l /dev/input/
total 0
crw - r-----       1 root    root     13,    64  Jan    1  00:17  event0
crw - r-----       1 root    root     13,    65  Jan    1  00:17  event1
crw - r-----       1 root    root     13,    66  Jan    1  00:17  event2
crw - r-----       1 root    root     13,    63  Jan    1  00:17  mice
Lrwxrwxrwx      1 root   root             6  Jan	  1  00:18  ts0 -> event2
Lrwxrwxrwx      1 root   root             6  Jan	  1  00:18  ts2 -> event1
root@freescale ~$

View Touch Original Data

When there is an issue with the touch function, you can determine whether the problem lies in the driver layer or the application layer by checking the raw data. There are several methods to view the raw data:

1. cat /dev/event2

Directly using cat on the touch event will output garbled characters when you touch the screen.

2. hexdump

$ hexdump -d /dev/input/event0

0000000  15989  00000  18969  00004  00004  00004  00001  00009 # Other events
0000010  15989  00000  18969  00004  00001  00272  00001  00000 # BTN_MOUSE，press
0000020  15989  00000  18969  00004  00003  00000  16333  00000 # ABS_X
0000030  15989  00000  18969  00004  00003  00001  09599  00000 # ABS_Y
0000040  15989  00000  18969  00004  00000  00000  00000  00000 # Synchronous events
0000050  15989  00000  49415  00005  00004  00004  00001  00009 # Other events
0000060  15989  00000  49415  00005  00001  00272  00000  00000 # BTN_MOUSE，release
0000070  15989  00000  49415  00005  00000  00000  00000  00000 # Synchronous events

The fourth, third, and second-to-last lines correspond to type, code, and value, which are all defined in linux/input.h. The event types for input devices in Linux are:

#define EV_SYN 0x00 // Synchronous events
#define EV_KEY 0x01 // Key events
#define EV_REL 0x02 // Relative coordinates
#define EV_REL 0x03 // Absolute coordinates
#define EV_MSC 0x04 // Other events

Type is the event type, where 3 is the EV _ ABS = 0x03 and 0 is the EV _ SYN = 0x00 (as a separator of events).

The value of code depends on the event type. If the type is EV _ ABS, the value of code 0 is ABS _ X and the value of code 1 is ABS _ Y.

Then, the value represents the measurement under the premises of type and code. For example, if the type is EV_ABS and the code is 0 (which corresponds to ABS_X), then the value represents the absolute X-axis position of the touch point.

For example, if the type is EV_KEY, the code 272 corresponds to BTN_MOUSE, and code 330 corresponds to BTN_TOUCH; a value of 1 indicates a press, while a value of 0 indicates a release. For instance, if the type is EV_ABS and the code is 24 (which corresponds to ABS_PRESSURE), a value of 1 indicates that the screen is being pressed, while a value of 0 indicates it is released.

The tests show that the coordinate values generated by the touchscreen touch events have a range of X: 016384 and Y: 09600, and this touchscreen does not upload ABS_PRESSURE.

3. ts_print / ts_print_raw

The difference between the two is that ts _ print prints the data after tslib processing, while ts _ print _ raw prints the data before tslib processing.

4. evtest

Evtest can not only print original, but it also allows you to see the event types.

Driving Layer Processing Idea

1. Find the corresponding driver in the kernel source code by checking the device information.

You can look for the corresponding string in the kernel source code;

2. To locate the touch reporting position, you can search for the string ABS in the corresponding driver.

The image above shows the touch driver for a resistive screen.

3. Add print statements for further processing.

Application Layer Processing

1. Use tools like ts_test to check if tslib is receiving data.

2. Change the version of tslib.

Capacitive Screen

In theory, capacitive screens do not require touch calibration; however, if they are not calibrated, there...

Read more

In practical applications, embedded boards are often subjected to various vibrations, which may come from device operation, vehicle movement, or external environmental disturbances. The impact of vibration on boards cannot be ignored, as it can cause loose connectors, damage to structural components, and even lead to functional instability and performance degradation.

Forlinx Embedded has three R&D labs: the Physical Environment Lab, the Electromagnetic Compatibility Lab, and the Stability Lab. These labs conduct 10 major test items, each designed to simulate extreme conditions that products might encounter in real-world applications, ensuring they can operate stably in complex environments.

To ensure the stability and reliability of embedded boards in vibrational environments, professional vibration testing becomes crucial. Forlinx's physical lab is equipped with an advanced vibration testing system that provides accurate test data during the design phase.

In the vibration tests, Forlinx precisely sets vibration parameters such as frequency range, amplitude, and acceleration according to the standards of specific application scenarios. The vibration table simulates real-world vibration environments.

During the test, the embedded board is securely placed on the vibration table, and high-precision sensors continuously monitor the vibration waveforms to ensure they strictly comply with the preset parameters. The test also pays close attention to any resonance or abnormal occurrences. Additionally, Forlinx closely monitors the real-time operation status of the board to comprehensively assess its stability and reliability under vibration.

After testing, Forlinx's test engineers conduct detailed visual inspections, structural verifications, and functional performance tests on the board. For specific user scenarios, supplementary mechanical shock and impact tests may also be required to further verify the durability and practicality of the board design.

Through these scientific and rigorous testing methods, we ensure that the embedded board can exhibit outstanding performance and rock-solid stability even when facing vibration challenges, providing strong technical support for various electronic devices.

Configuring a Bridge for LAN Ports

1. Create/etc/systemd/network/br0.netdev

[NetDev]     //A section identifier indicating that the following configuration information belongs to a network device definition.
Name=br0     //Specifies the name of the network device to be "br0".
Kind=bridge     //# Specifies the device type as a bridge, used to connect multiple network devices for network communication.

2. Create/etc/systemd/network/br0.network

[Match]     //Indicates that the following content is for matching device conditions.
Name=br0     //Specifies the device name to match as "br0". The following configuration will apply to the device named "br0".
KernelCommandLine=!root=/dev/nfs
    //Specifies the kernel command line condition for the device, preventing accidental boot to an NFS root file system.
[Network]
Address=192.168.3.1/24

3. Create the Port Configuration Files:

touch /etc/systemd/network/fm1-mac2.network
touch /etc/systemd/network/fm1-mac4.network
touch /etc/systemd/network/fm1-mac5.network
touch /etc/systemd/network/fm1-mac6.network
touch /etc/systemd/network/fm1-mac9.network
touch /etc/systemd/network/fm1-mac10.network

Enter the following content, taking fm1-mac2.network as an example:

Name=fm1-mac2 The attribute differs, must correspond to the filename.

[Match]
Name=fm1-mac2
KernelCommandLine=!root=/dev/nfs


[Network]
Bridge=br0

Enable 5G Dial-Up on Boot

1. Add 5G Autostart:

At the end of the /root/.forlinx file, add the following content:

sleep 10 //Prevents this service from starting before some dependent services.
/root/Net_Tools/quectel-CM

Possible Reasons for Dial-Up Failure:

SIM card inserted incorrectly, SIM card is out of credit.

IoT card is locked, need to add APN (cmnet: Mobile; 3gnet: Unicom; ctnet: Telecom).

The board has a 4/5G switching dial switch.

Install and Configure udhcpd Service

1. Install udhcpd Service:

apt-get update //May fail due to reasons: the board itself has no network, DNS not set, RTC clock not updated.
apt-get install udhcpd

Other Solutions for Source Update Failure:

(1) https://blog.csdn.net/Chaowanq/article/details/121559709 apt command certificate error.

(2) https://blog.csdn.net/zhushixia1989/article/details/104550890 GLib-CRITICAL **: g_strchomp: assertion ‘string != NULL’ failed

(3) https://blog.csdn.net/downanddusk/article/details/126334776 kali-rolling InRelease‘ is not signed

2. Configure udhcpd Service:

Open /etc/udhcpd.conf

and modify the /etc/udhcpd.conf configuration file to customize the IP pool, gateway, DNS, interface, etc.

Here, I allocate IP range 192.168.3.20 — 192.168.3.254, interface as br0.

Modify /etc/default/udhcpd to enable it.

DHCPD_ENABLED=“yes”.

After configuration, start the service: systemctl start udhcpd.service.

Restart the service: systemctl restart udhcpd.service.

Enable the service at boot: systemctl enable udhcpd.service.

Check the service status: systemctl status udhcpd.service.

Set Network Node usb0 Forwarding Rules

1. Set Forwarding Rules:

iptables -t nat -A POSTROUTING -o usb0 -j MASQUERADE（Ensure the -o parameter interface is confirmed correctly.）

2. Save Forwarding Rules:

netfilter-persistent save
netfilter-persistent reload

-t nat: Specifies the table to operate on as the nat table. The nat table is used for network address convert.

-A POSTROUTING: -A indicates that a rule is being appended to the end of the chain, and in this case, the chain being appended is the POSTROUTING chain. Rules in the POSTROUTING chain are handled when a packet is about to leave a network interface.

-o usb0: The -o option specifies which network interface the packets will be sent out from. In this example, usb0 is the designated network interface (usually a USB network adapter).

-j MASQUERADE: The -j jump to target action, here is MASQUERADE, which means enabling IP masquerading, replacing the source...

Read more

3D scanning, an integrated technology of optics, mechanics, electronics, and computing, captures 3D coordinates and color information of object surfaces through non-contact measurement, generating high-precision 3D models. In game development, 3D scanners have significantly enhanced the realism and detail richness of game scenes, characters, and objects.

The production team of the popular game "Black Myth: Wukong" spent a year using 3D scanning to create precise 3D models of real Buddhist statues, temples, and rocks across China. These models not only provide rich materials and inspiration for game designers but also ensure the authenticity and detail richness of game scenes. By capturing real-world 3D data, every detail in the game accurately reproduces historical features, enhancing the game's cultural depth and artistic value.

Not only in the gaming field, but 3D scanning systems, with their high precision, non-contact measurement, and digitization characteristics, can also contribute to the preservation and restoration of cultural relics. The fire at Notre-Dame Cathedral in 2019 attracted global attention. Prior to this, Notre-Dame Cathedral had already undergone comprehensive data recording using 3D scanning technology. This allows experts to use this data to carry out precise repair work after the fire. In addition, it can also be widely used in surveying and mapping engineering, industrial manufacturing, architectural design, education and scientific research and many other industries.

The 3D scanner, as the core component, is responsible for data acquisition and conversion. It consists of a probe, lens, and camera. The probe collects surface patterns without contact, the lens adjusts the probe position and viewing angle, and the camera converts captured images into digital signals for further processing like denoising, stitching, and optimization.

Hardware implementation faces several challenges:

• Complex data processing: Limited by onsite conditions during data collection, processing can be complex, requiring extended post-processing like noise removal and mesh reconstruction, demanding high-performance hardware.
• Compatibility issues: Incompatible hardware and software designs for point cloud data processing across different manufacturers hinder resource sharing and conversion, increasing learning and technical difficulties for users.
• Environmental sensitivity: Lasers and optical systems are sensitive to temperature changes, requiring frequent calibration and affecting efficiency. External factors like temperature, humidity, and vibration can also impact measurement accuracy, necessitating strict environmental control.
• High cost: The hardware cost of 3D scanners is often high, potentially leading to increased product prices and affecting market competitiveness.

Forlinx Embedded recommends using the FET3576-C embedded board as the main controller for 3D scanners. Based on the RK3576 processor, the FET3576-C is a high-performance, low-power, feature-rich, cost-effective solution tailored for AIoT and industrial markets. It integrates four ARM Cortex-A72 and four ARM Cortex-A53 high-performance cores, with a 6TOPS powerful NPU supporting various operations and deep learning frameworks.

（1）Versatile Interfaces

With GPIO, UART, SPI, and other communication interfaces, the FET3576-C precisely controls scanning parameters (e.g., scanning speed, resolution) and sensor states (e.g., laser emitter, camera shutter), enhancing scanning efficiency and quality

（2）Data Processing Hub

As the system's ''brain,'' the FET3576-C processes raw data like laser point clouds and images, ensuring accurate and complete 3D models through filtering, denoising, registration, and fusion.

（3）Intelligent Optimization

6TOPS NPU enables intelligent analysis of scanned data, automatically identifying and optimizing issues like flaws and holes in models, further...

Read more

1. Product Background

The energy consumption monitoring and management system relies on information technologies such as computer networks, wireless communication, and metering collection. This system targets energy mediums such as electricity and water, establishing an energy consumption monitoring center for enterprises, industrial parks, and other energy-consuming units. It enables real-time collection, measurement, and analytical calculation of electricity and water usage, reflecting dynamic data changes and storing historical data for querying, thus achieving digital, networked, and visualized energy and energy-saving management. It helps factory managers understand energy costs, manages control in real time, improves management efficiency, reduces operating costs, and achieves scientific energy use and energy conservation.

Energy consumption monitoring systems have wide applications, including hospitals, residential communities, schools, industrial factories, office buildings, and commercial complexes.

2. Product Features

The energy consumption monitoring system consists of three components: the metering layer, information management layer, and application management layer. The metering terminals include electricity, water, and gas meters, while the gateway collects data from these meters. The system provides statistical analysis, presenting intuitive data visualization to management staff, allowing them to understand real energy consumption data, automatically analyze high energy consumption points, and provide energy-saving solutions for refined management.

Functions of the Energy Consumption Monitoring System

• Real-time Monitoring: Continuously monitors the usage of all users within the system, providing real-time data feedback on energy consumption.
• Data Analysis: Detailed recording and analysis of electrical usage in each circuit, displayed in tabular format, with the ability to switch to bar charts, line graphs, and other intuitive formats for comparison.
• Data Statistics: Offers comprehensive classified and detailed energy consumption statistics reports, allowing users to print daily, monthly, seasonal, and annual electricity consumption statistics at any time.
• Fault Alarm: The system issues voice alerts when there is an unexpected change in electricity load, with alarm messages sent to relevant personnel via SMS.
• Automatic Energy-saving Report Generation: Staff can review real energy consumption data for public buildings, automatically analyze high energy points, and propose energy-saving solutions for refined building management.

3. Product Design Challenges

Hardware Compatibility and Standardization: The energy consumption monitoring gateway needs to connect multiple types of sensors and metering devices from various manufacturers, using different communication protocols and data formats. Therefore, the gateway’s hardware design must consider broad compatibility and standardized interfaces for seamless device connections.

Stability and Reliability: The monitoring gateway operates 24/7, requiring high stability and reliability in hardware design, including the selection of high-quality components, proper heat dissipation design, and effective fault detection and recovery mechanisms.

Scalability and Maintainability: As technology advances and demands increase, the monitoring gateway may need to expand its functionality or interfaces. Therefore, hardware design must account for future scalability and ensure easy addition of new functions or devices. Good maintainability is essential for quick recovery in case of issues.

Power Consumption and Cost: Since the gateway typically runs continuously, power consumption is a critical factor. Hardware design needs to optimize for lower power usage while reducing costs without sacrificing performance, including the selection of low-power components, optimizing power management, and implementing energy-saving strategies.

4....

Read more

Compile the driver to the kernel：

Create the hello folder for the kernel driver source code, add the hello. c and Makefile file, modify the parent directory/kernel/drivers/Makefile file, and execute the full compilation operation.

Modify as follows:

/hello/Makefile is：obj-y += hello.o

/kernel/drivers/Makefile; add the following code：obj-y += hello

Compile the driver as a module：

Method 1：

Create the hello folder for the kernel driver source code, add the hello. c and Makefile file, modify the parent directory/kernel/drivers/Makefile file, and execute the full compilation operation.

Modify as follows:

/hello/Makefile is：obj-m += hello.o

/kernel/drivers/Makefile; add the following code：obj-y += hello

If wanting to compile the driver but not wanting to perform a full compile operation that takes too much time, the following method can be chosen.

Method 2：

Create a hello folder in the kernel driver source code, add the hello. c and Makefile file, modify the parent directory/kernel/drivers/Makefile file, modify the/kernel/Makefile file to add the architecture and cross-compiler, and execute the make modules command.

Modify as follows:

/hello/Makefile is：obj-m += hello.o

/kernel/drivers/Makefile; add the following code：obj-y += hello

/kernel/Makefile, add the following code:

ARCH?= arm64

CROSS_COMPILE?=

$(srctree)/../prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-

Advantages: When executing the make modules command, only the modules will be compiled, and the compilation time will be shortened.

Disadvantages: The driver source code needs to be added to the kernel, which is not easy to find and modify. In addition, the make modules command will determine that the source code is configured as a module and will be compiled.

Issues encountered:

Solution: The kernel top-level Makefile file specifies the architecture and cross-compiler.

Method 3：

Create a folder named "hello" at any path, and add the files ''hello.c'' and ''Makefile''. In the ''/hello/Makefile'', add the architecture and cross-compiler. Then, execute the ''make'' command in the directory where ''hello.c'' is located.

/hello/Makefile to write the following code.

Advantages: Execute the make command, and only hello. C driver files will be compiled separately.

Issues encountered:

Solution: The kernel top-level Makefile file specifies the architecture and cross-compiler.

Appendix:

hello.c
#include #include MODULE_LICENSE("Dual BSD/GPL");
static int hello_init(void)
{
printk(KERN_ALERT "Hello World enter\n");
return 0;
}
static void hello_exit(void)
{
printk(KERN_ALERT "Hello World exit\n");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_DESCRIPTION("A Sample Hello World Module");
MODULE_ALIAS("A Sample module");

In the modern era of intelligence, embedded circuit boards are the core components that support the stable operation of various smart devices, making their performance and reliability crucial. However, prolonged operation, frequent power cycles, or restarts may lead to occasional anomalies due to aging, electrical parameters reaching critical values, or unreasonable software logic design. These anomalies can cause devices to fail to start or reboot normally, significantly reducing reliability and stability. Stability testing has become an essential step to validate the reliability of devices during prolonged operation, multiple power cycles, and restarts.

Forlinx Embedded has three R&D laboratories: the Physical Environment Lab, the Electromagnetic Compatibility Lab, and the Stability Lab, which host multiple testing projects to simulate various extreme conditions in real-world applications, ensuring products can operate stably. The Stability Lab specifically focuses on verifying the reliability of embedded circuit boards during prolonged operation and multiple power cycles. Stability testing is primarily divided into cold start testing and hot start testing.

Cold start testing examines the power cycling process of the device over a specific period, typically conducting up to 10,000 tests. Before the test, Forlinx's testing engineers set reasonable startup and cooling times based on the actual device conditions and use a programmable power supply along with automated testing software to ensure accuracy and efficiency.

Hot start testing involves executing reboot commands while keeping the device powered on, conducting 1,500 tests. During each test, engineers check various interfaces, including WiFi, 4G, USB, TF cards, and network interfaces, to ensure they function correctly during device restarts. To ensure traceability, testing engineers record daily testing counts and interface statuses, maintaining comprehensive experimental logs.

The results of the stability tests on embedded circuit boards provide valuable insights for improving product reliability. Cold start testing verifies whether the device's power circuit stability meets design requirements, while hot start testing checks the normalcy of the operating system's shutdown and startup processes, including the correctness of the shutdown and startup logic. Engineers use these test results to make targeted improvements in design and quality, continually enhancing product reliability.

Additionally, stability testing is a crucial assessment method for determining whether a product can meet its design lifecycle. It ensures that embedded circuit boards operate consistently throughout their lifecycle, providing users with lasting and reliable service.

In conclusion, stability testing of embedded circuit boards is a key factor in ensuring the long-term stable operation of smart devices. Through rigorous testing processes and precise result analysis, we can not only promptly identify and resolve issues but also provide robust support for continuous product improvement and optimization.

1. Introduction to Weeding Robots

In the agricultural sector, traditional weeding methods are not only inefficient and costly but can also lead to environmental pollution. With advancements in technology, intelligent weeding robots have emerged as important tools in modern agriculture. This intelligent weeding robot employs advanced machine vision and artificial intelligence technologies to precisely identify weeds and crops, enabling automated and intelligent weeding operations. This significantly enhances agricultural productivity while protecting the ecological environment.

2. Product Features

• Precision Identification: Equipped with a high-performance image recognition system, it accurately differentiates between weeds and crops, ensuring precise weeding, avoiding crop damage, and improving weeding efficiency.
• Autonomous Navigation: The built-in advanced navigation system autonomously plans the work path, adapting to different shapes and sizes of fields to ensure comprehensive coverage without leaving any blind spots.
• Eco-Friendly and Energy-Efficient: Powered by batteries with zero emissions, it reduces reliance on chemical herbicides, decreasing chemical residues in agricultural products and protecting soil and the environment.
• Intelligent Learning: Capable of self-learning and optimization, it adjusts strategies based on the working environment to enhance weeding effectiveness and reduce energy consumption.

3. Product Design Challenges

• High-Performance Requirements: Weeding operations require the main control system to have high processing power and computational speed to support real-time image processing and complex algorithms. High performance often comes with high power consumption, challenging the robot’s endurance.
• High-Temperature Stability: Outdoor environments are variable, requiring the main control system to have strong environmental adaptability to withstand dust, moisture, high temperatures, and other harsh conditions, ensuring long-term stable operation.
• Machine Learning Capabilities: Improving the control system's recognition and decision-making abilities through machine learning involves complex issues such as data collection, model training, and optimization.
• Diverse Interfaces: The main control system should offer a variety of interfaces to support different types of sensors and communication modules.

4. Folinx Implementation Solution

To address these challenges, Forlinx's embedded FET3588J-C platform provides powerful hardware support for the intelligent weeding robot, featuring the following significant advantages:

• High Performance: The combination of a quad-core Cortex-A76 and a quad-core Cortex-A55 processor ensures strong performance under high load while achieving low power consumption during low load, meeting the dual demands of performance and power efficiency for intelligent weeding robots.
• Image Processing Capability: FET3588J-C supports a 48-megapixel ISP3.0 and various image processing functions, significantly enhancing image capture quality and providing robust support for precise weed and crop identification.
• Rich Interface Resources: Provides various interface resources to connect different sensors and expansion devices, meeting the diverse application needs of intelligent weeding robots.
• Powerful AI Capabilities: With a built-in NPU providing up to 6 TOPS of computing power, the robot gains substantial AI learning and edge computing capabilities, enabling it to intelligently handle various weeding tasks.
• Product Stability: Rigorous environmental temperature and stress testing ensures stable operation in complex environments, providing reliable performance assurance for the intelligent weeding robot.

In summary, Forlinx's FET3588J-C, as a hardware implementation solution for intelligent weeding robots, offers exceptional performance, rich interface resources, powerful AI computing capabilities, and overall...

Read more

Amidst the ongoing reforms in the power industry, the intelligent management of key electrical infrastructure such as substations and distribution rooms has become a crucial driver for ensuring the safe, economical, and efficient operation of power grids. 

With the growing demand for electricity and the accelerating process of urbanization, the number of power substations has surged, with widespread distribution and complex environmental conditions. This presents unprecedented challenges to the stability, reliability, and safety of power systems.

Traditional monitoring systems for power rooms face significant limitations: independent operation of subsystems, severe information silos, and consequently low overall monitoring efficiency. This fragmented management approach not only increases operation and maintenance costs but also hampers rapid response to emergencies, with insufficient capability for early warning of potential risks. These issues severely constrain the intelligent upgrading and efficient operation of power grids.

To address these problems, the Smart Assistance and AI Visualization Gateway for power substations has emerged.

Designed specifically for power scenarios such as substations and distribution rooms, this innovative solution integrates LCD screens with advanced AI technology, enabling comprehensive visualization, monitoring, and management of on-site parameters. This intelligent gateway can monitor real-time information from multiple dimensions, including transformer status, switch gear operation, environmental temperature and humidity, air conditioning and fan status, lighting systems, smoke detection, access control, and video surveillance, creating a comprehensive and multidimensional monitoring network for power substations.

By intelligently analyzing real-time data collected from various sensors and accurately comparing it with preset thresholds, the intelligent gateway can quickly identify and respond to anomalies, providing features such as automatic alarms, remote control, and fault prediction. This significantly enhances the safety protection level and emergency response capability of power substations. Furthermore, its powerful data integration and analysis capabilities offer robust data support for operational decision-making, facilitating the refined and intelligent transformation of maintenance management.

1. Client Requirements

Through communication with the client, Forlinx Embedded has identified the following requirements for the main control unit of the Smart Assistance and AI Visualization Gateway project for power substations:

(1) The gateway's core CPU should use an ARM architecture with at least 4 cores and a clock speed of no less than 1GHz;

(2) The gateway should include a video processing module for video stream processing and AI analysis, with computing power of no less than 3 TOPS;

(3) The gateway should have at least 2GB of memory and 8GB of storage capacity;

(4) The gateway should use a Linux kernel operating system;

(5) The gateway should include at least 4 RS485 ports, with selectable serial port speeds of 9600bps, 19200bps, and 115200bps;

(6) The gateway should support Ethernet interfaces with adaptive rates of 100/1000Mbps.

2. Main Control Selection: RK3576 Processor

Based on the actual project requirements, the client has chosen the Rockchip RK3576 processor as the main control unit for the Smart Assistance and AI Visualization Gateway for power substations. Based on the actual project requirements, the client has chosen the Rockchip RK3576 processor as the main control unit for the Smart Assistance and AI Visualization Gateway for power substations.

In terms of performance, the RK3576 processor features 4 x Cortex-A72 and 4 x Cortex-A53 high-performance cores, with a maximum clock speed of 2.3GHz and an integrated 6 TOPS NPU. This provides robust performance support for the Smart Assistance and AI Visualization Gateway for power substations and ample...

Read more

System sleep and wake technology is a crucial aspect of power management. Firstly, it allows the system to reduce power consumption to the lowest level when idle by putting external devices, internal IP of the chip, and clocks into a low-power state or completely shut off the power state, thereby greatly extending the product's runtime. Secondly, when users need the system to run, it can quickly recover power, clocks, internal IP of the chip, and the working state of external devices to ensure that the user's experience is not interrupted.

Forlinx T113 supports two types of sleep modes: freeze and mem. These two methods can be operated through the/sys/power/state file node, and the user can trigger the corresponding sleep state by writing freeze or mem to the file node. Before hibernation, the system configures the wakeup source. Once the system enters the sleep state, it can be awakened by these wake-up sources, such as keys, RTC, etc., when needed. This design allows users to choose when and how to wake up the system quickly according to their needs, achieving a balance between power consumption minimization and fast recovery. This mechanism enables the system to greatly reduce power consumption in the sleep state, while retaining the convenience of the user to use the system quickly after waking up.

Here's how to enter sleep mode and wake up the system using the RTC on the Forlinx Embedded OK113i-S development board.

Two Sleep Modes:

freeze: Freezes I/O devices, placing them into a low-power state, and puts the processor into an idle state. It offers the quickest wake-up time, but consumes more power than other methods. Measured current with only serial port connected and 5V power supply: Approximately 0.112A

mem: Suspend-to-RAM, where the computer stores current runtime state data in memory and shuts down the hard drive, external devices, etc., entering a wait state. At this time, the memory still needs power to maintain its data, but the whole machine consumes very little power. When recovering, the computer reads data from memory, returns to the state before suspension, and recovers quickly. Measured current with only serial port connected and 5V power supply: approximately 0.076A

1. cat /sys/power/state shows the supported modes.

2. cat /sys/power/state shows the supported modes.

3. cat /sys/power/state shows the supported modes.

RTC Alarm Wakeup

Tips: Note that the internal RTC needs to be used here; external RTCs do not support wakeup functionality, and we will mention this later.

Enter the kernel configuration:

Follow the instructions in the diagram to select the wake-up function.

After completing the configuration, save it, then modify the device tree file to enable the internal RTC.

Compile after saving:

After the compilation is successful, it is packaged into an image. After the programming is completed, we test it at the serial port terminal.

Enter the serial port terminal for test:

echo''+15''> /sys/class/rtc/rtc0/wakealarm

This sets a 15-second timer, which can be adjusted as needed. After executing this command, it will take effect. If the system goes into sleep after 15 seconds, it will not trigger a wake-up. (Note: This requires using the internal RTC; external RTC does not support wake-up functionality.)echo mem > /sys/power/state (The two commands need to be entered closely together; a long interval between them will make them ineffective.)

(It should be noted here that when the internal RTC is not opened, the default external RTC node is rtc0. After modification, the external RTC device node will be changed to rtc1.)

3. cat /sys/power/state shows the supported modes.

RTC Alarm Wakeup

Tips: Note that the internal RTC needs to be used here; external RTCs do not support wakeup functionality, and it will be mentioned later.

Enter the kernel configuration:

Follow the instructions in the diagram to select the wake-up function.

After completing...

Read more

In this era of rapid technological advancement, an amazing product — RK3568 System on Module (SoM) has emerged.

✨It is equipped with Rockchip’s new — generation AIoT processor RK3568, which is a 64 — bit quad — core Cortex — A55 System on Chip (SoC) based on the advanced 22nm process technology. The built — in Neural Processing Unit (NPU) has a processing performance of up to 1TOPS.

Network models based on a series of frameworks such as TensorFlow, MXNet, PyTorch, and Caffe can be easily converted, and it also supports RKNN — Toolkit. At a running speed of up to 2.0GHz, it still maintains excellent low — power performance.

🎯In terms of graphics processing, the 38.4GFLOPS 800MHz GPU Mali — G52 performs outstandingly.

🎥The video codec capabilities are extremely powerful. It supports 4K resolution H.264, H.265, VP9 and other formats of high — definition hard decoding. It can support the decoding of multiple video sources simultaneously and also supports HDR10 with excellent color and dynamic range performance. At the same time, it supports H.264 and H.265 format hardware encoding at 1080p60fps and can adjust the dynamic bit rate, frame rate and resolution.

📺There are various display interfaces, including HDMI (up to 4K output), LVDS, MIPI — DSI, RGB, eDP, etc., which can support three — screen synchronous / asynchronous playback. It is perfectly suitable for fields such as PDAs, cash registers, multi — screen advertising machines, karaoke machines, electronic bus stop signs, and self — service machines.

🖥Multiple high — speed interfaces make it even more powerful, including 2 USB3.0, 2 PCIE3.0, 3 SATA3.0, 2 1000Mbps Ethernet (GMAC), 3 CAN — FD, and 10 UART.

🛡After undergoing harsh ambient temperature tests, stress tests and long — term running tests, the FET3568 — C SoM has been proved to be robust and reliable. It is widely used in multiple fields such as medical, industrial, transportation, cloud terminal, streaming media, security, AI application, and energy management.

Whether you are looking for high — performance, multi — interface or stable and reliable devices, Rockchip RK3568 SoM will be your ideal choice. Come and explore its infinite possibilities!

1. Introduction to Laser Coding Machines:

Laser coding machines use high-energy lasers focused directly on the surface of objects to induce physical and chemical changes, creating markings.

As the laser beam's focus moves systematically across the marking surface, controlling the laser's activation allows for the creation of specific marking patterns on the object's surface.

Laser marking offers advantages such as non-contact marking, high speed, minimal pollution, no consumable loss, and clear, permanent identification. These benefits give it a competitive edge, leading to its gradual replacement of traditional ink-jet coders.

2. Structure of Laser Coding Machines:

A laser coding machine primarily consists of the following components:

• Control System: The core component responsible for editing and processing marking content, generating marking data, transmitting it to the galvo system and laser system, and handling external input.
• Laser System: Responsible for generating and transmitting the laser to the galvo system.
• Galvo System: Quickly and precisely rotates mirrors to alter the laser beam's path, focusing it into a spot on the marking surface.
• Power Supply System: Provides power to the entire laser marking machine, including the controller, laser, and galvo system.
• Conveyor Mechanism: Moves items to be marked and uses speed measurement devices to monitor real-time item movement, feeding this data back to the control system.

3. ARM+FPGA-Based Control System Design:

ARM processor manages the human-machine interface, complex data processing, and communication, while the FPGA handles the reception, storage, conversion of marking data, and controls the marking equipment.

The marking control is managed by the marking card, with real-time performance mainly relying on the FPGA. ARM SoM is used for interface display and higher-level computation.

4. Folinx Solution

Forlinx Embedded recommends the FETA40i-C SoM as the ARM platform for laser coding machines, offering notable advantages: Notable advantages:

• High Performance Processing: The A40i platform, with its 1.2GHz high frequency, rapidly processes complex coding tasks. In laser coding machines, a high-performance processor ensures speed, precision, and efficiency in coding, with the A40i's high frequency reducing response time, enhancing productivity.
• Excellent Display Capabilities: A40i platform supports multiple display interfaces, making the coding interface more intuitive and visually appealing. A clear and user-friendly interface is crucial for operators, who can more easily view and edit coding content via a large screen, improving work efficiency.
• Robust Communication Capabilities: A40i features dual Ethernet ports and a 4G communication module, supporting various communication methods. This allows easy data transfer and communication with other devices, meeting the networking needs of modern industrial production, and facilitating future interface upgrades.
• Extensive External Expansion Interfaces: A40i platform offers numerous native external expansion interfaces, including 8 x serial ports and 3 x USB. These provide ample connection options for external devices, enabling easy integration and interaction with various peripherals.
• Industrial-Grade Stability and Reliability: A40i is an industrial-grade CPU known for its stable and reliable quality. Stability and reliability are critical in laser coding machines, ensuring long-term stable operation in harsh industrial environments, reducing failure rates, and extending equipment lifespan.

In summary, Forlinx Embedded A40i platform offers numerous advantages as the hardware control platform for laser coding machines, meeting the high-performance, high-stability, and high-reliability demands of modern industrial production

OK3568 4.19.232 buildroot adds python3-pip installation package.

1. Modify buildroot/package/Config.in to add python-pip/Config.in.

2. Download python-pip and extract the compressed package to the buildroot/package directory.

3. Modify the defconfig file used by buildroot. Execute make menuconfig in the buildroot/output/OK3568 directory to select python3 and python-pip.

After modification, save the modified .config file to buildroot/configs/OK3568_defconfig. Then, perform a full compilation. During the compilation, the downloading, compilation, and installation of pip-related packages will be visible, indicating success.

Burn the compiled file system to the development board to enable pip commands.

4. Possible compilation errors and solutions:

a. Possible compilation errors and solutions:

Solution:

Re-create a soft link from OK3568-linux-source/buildroot/output/OK3568/host/bin/python to python3.

cd buildroot/output/OK3568/host/bin
rm python
ln -s ln -s python3 python

After re-establishing the soft link, recompile. Use ls -l python to check if the soft link is successful.

b. SSL error when using pip install on the development board:

Solution:

Delete the python-related files in OK3568-linux-source/buildroot/output/OK3568/build/ and recompile.

This is because pip installation depends on SSL, and if the full compilation in step 1 was done using python2 for SSL compilation,

pip requires python3. So, after re-linking to python3, recompile the python-related files.

rm buildroot/output/OK3568/build/python-* -rf
./build.sh buildroot

After compilation, burn and verify the file system. Opencv-python related tests can then be performed.

The MAX31865 is a simple and easy-to-use thermistor-to-digital output converter, optimized for platinum resistance temperature detectors (RTD). External resistors set the sensitivity of the RTD, while a high-precision Δ-Σ ADC converts the ratio of the RTD resistance to the reference resistance into a digital output. The MAX31865 input has overvoltage protection of up to ±45V and provides configurable detection for RTD and cable open-circuit and short-circuit conditions. It is suitable for a wide range of high-precision temperature devices in medical, industrial, temperature computation, satellite, meteorological, resistance measurement, and other applications.

The latest OK3562J-C single board computer from Forlinx Embedded has reserved the SPI2 interface, located on the P8 pin header:

SPI2_CLK_M0,

SPI2_CSN0_M0,

SPI2_MOSI_M0,

SPI2_MISO_M0.

This article will introduce how to use SPI2 on the OK3562J-C development board to interface with the MAX31865 (digital RTD temperature sensor) chip.

1. Modification Approach

The approach to adding an SPI device is as follows:

Add a description in the device tree → Corresponding device driver in the device tree description → Add the device driver to the kernel.

2. Modification Method

(1) The MAX31865 module supports 2-wire, 3-wire, and 4-wire connection methods. The 3-wire connection method is utilized here, which is a compromise requiring one less wire than the 4-wire method. To compensate for the voltage drop across the leads, the voltage between (RTDIN+ and RTDIN-) will be reduced by the voltage between FORCE+ and RTDIN+. Sampling at the input is achieved using FORCE2. If the cable resistance has good consistency, it can eliminate errors introduced by the cable resistance.

Before wiring, the module needs to be soldered to configure it in a 3-wire mode as shown in the diagram below.

(2) Add the relevant descriptions for the MAX31865 in the device tree. Since we are using a 3-wire connection, we need to add the maxim,3-wire parameter.

3. Compiling the Driver as a Module

(1) Create a folder named max31865 under the /drivers directory in the kernel source, and add the max31865.c and Makefile files.

(2) Modify the parent directory /kernel/drivers/Makefile, and perform a full compilation operation. The modifications are as follows:

The content is: /drivers/max31865/Makefile:

obj-m += max31865.o

Add the following code to /kernel/drivers/Makefile:

obj-y += max31865

Then execute the ./build.sh kernel script to compile the kernel, which will generate the .ko module in the /drivers/max31865 directory.

(3) Copy max31865.ko to the OK3562J-C development board and execute insmod max31865.ko to load the module.

4. Test

Use a 22Ω resistor to simulate the platinum resistance and run the following command to check the raw ADC value:

cat /sys/bus/iio/devices/iio:device2/in_temp_raw

The ADC value for the 22Ω resistor should be observed as 1655. Comparing this with the values in the chip manual indicates that this is normal, corresponding to a temperature of approximately -190℃.

At this point, the new MAX31865 (digital RTD temperature sensor) device has been successfully added, and applications can be developed based on the raw ADC values to correspond to the measured temperature.

The above is the method of using SPI2 to mount MAX31865 (digital RTD temperature sensor) device on OK3562J-C development board. It is hoped that this will be helpful for project development.

Welcome to the Forlinx Product Review Program. At Forlinx, we offer a range of single board computers (SBCs) powered by NXP, TI, Rockchip, and Allwinner. As curious and passionate members of the embedded community, we believe many of YOU want to get hands-on with these products, test them out and share your real experience with the community.

So whether you're a professional or an enthusiastic hobbyist, if you have a strong presence in the embedded community, we want to hear from you.

Who We're Looking For

Engineers with a solid social media presence or active community involvement in embedded systems.

What You'll Do

Review our SBCs, share your feedback on your social media channel, and engage with the embedded engineers.

How to Join: Email us at rongyi@forlinx.com with

• Your name and address
• The product you'd like to review
• A brief introduction explaining why you’re the perfect fit
• Links to your social media channels/website/technical articles

Apply NOW and make your mark!

Email us Now

For example, porting 8-channel output LVDS display with a resolution of 1024x768, a clock of 65MHz, and a refresh rate of 76.

Kernel Stage Modifications

1. Modify screen parameters in device tree

vi vendor/nxp-opensource/kernel_imx/arch/arm64/boot/dts/freescale/OK8MP-C.dts

Locate the lvds0_panel node and update the screen parameters and clock settings:

These settings include screen resolution, front and back porch, and clock. The system calculates the refresh rate based on these variables, so accuracy is crucial. Small deviations are allowed, but they should not be excessive. The calculation formula is as follows:

clock-frequency= fframe*(hfront+hback+hsync+xres)*(vfront+vback+vsync+yres)

Eg.：65000000=76*（34+20+1024+2）*（4+10+768+5）

2. Remove clock limitations in U-Boot stage

vi vendor/nxp-opensource/kernel_imx/drivers/gpu/drm/imx/imx8mp-ldb.c

Comment out the relevant restriction.

3. Calculate the clock and modify it according to the actual situation of the ported screen

(1) vi vendor/nxp-opensource/kernel_imx/drivers/clk/imx/clk-imx8mp.c

Locate imx8mp_videopll_tbl and add a 910 clock as an example:

Parameters to set: rate, mdiv, pdiv, sdiv, kdiv.

• rate = 910,000,000 (calculated as 65,000,000 × 7 × 2, which is clock-frequency × 14).
• mdiv = 152
• pdiv = 2
• sdiv = 1
• kdiv = 0 (default value)

Calculation formula:

Fout = (M*Fin)/(P*2 S)

Fin = 24 (known value, used directly), Fout = 910, and MPS are all unknown and must be derived independently.

So：910 = (M*24)/(P*2S) -->910 = (152*24)/(2*21)

(2)vi vendor/nxp-opensource/kernel_imx/arch/arm64/boot/dts/freescale/imx8mp.dtsi

Locate the clock node and change the clock from 1039 500 000 to 910 000 000:

4. Recompile and flash after the above modifications

U-Boot Stage Modifications

The steps to modify the uboot stage are basically the same as the kernel stage, both require changing the device tree and adding clocks.

1. Modify screen parameters in device Tree

vi vendor/nxp-opensource/uboot-imx/arch/arm/dts/OK8MP-C.dts

Locate the lvds0_panel node and update the screen parameters and clock settings:

2. Calculate the clock and modify it according to the actual situation of the ported screen.

(1)vi vendor/nxp-opensource/uboot-imx/arch/arm/mach-imx/imx8m/clock_imx8mm.c

Locate imx8mm_fracpll_tbl and add a 910 clock:

(2)Locate VIDEO_PLL_RATE, then modiffy the value from 1,039,500,000 to 910,000,000:

3. Modify U-Boot environment variables

vi vendor/nxp-opensource/uboot-imx/include/configs/OK8MP-C_android.h

Locate CONFIG_EXTRA_ENV_SETTINGS, and modify video_mipi and video_hdmi to ''off''.

4. Recompile and flash

Multicore heterogeneous systems are computing systems that allow different cores within the same SoC chip to independently run different platforms. By properly allocating processor cores and peripheral resources, a single SoC chip can simultaneously run Linux and real-time operating systems (RTOS), meeting the demands for system functionality, hardware diversity, and real-time performance, while also offering excellent cost-effectiveness and product compactness.

1. Rockchip Multicore Heterogeneous System

Rockchip's multicore heterogeneous system solution includes:

Operating Platforms:

Linux provides the standard Linux Kernel；RTOS offers the open-source RT-Thread；Bare-metal supports a bare-metal development library based on the RK HAL hardware abstraction layer. Users can also adapt other RTOS based on RK HAL.

Processor Cores:

It supports homogeneous ARM Cortex-A cores running independently within the SoC, as well as heterogeneous ARM Cortex-M or RISC-V cores. The system allocates tasks to the most suitable core, enhancing performance and efficiency.

Currently, Rockchip's multicore heterogeneous system uses an unsupervised AMP (Asymmetric Multiprocessing) approach. It does not use virtualization management, which allows for faster interrupt response in real-time systems, meeting stringent real-time requirements in industries such as power and industrial control.

2. RK3562J Processor Cores and AMP Support

Processor Cores:

AMP Support:

3. Interrupt Nesting Mechanism

Interrupt nesting is an effective interrupt handling mechanism that allows the system to respond to and process interrupts based on their priority, ensuring that critical tasks are handled in a timely manner. It features high real-time performance, flexibility, and quick response. However, traditional Linux systems do not support interrupt nesting to simplify design, improve system stability, reduce resource contention and deadlock risks, and enhance compatibility and maintainability. While Linux performs well in many application scenarios, it struggles with high real-time applications.

4. Case Study

Development Board Model: OK3562J-C

Documentation Version: OK3562-C_Linux 5.10.198_User Documentation_R1

Testing Approach:

Use two GPIO, GPIO4B1 set as output and GPIO0B0 set as input with falling edge trigger.

Physically short GPIO4B1 and GPIO0B0.

Use Timer4 to generate a timer interrupt every second, and in the interrupt handler, control GPIO4B1 to create a falling edge and delay. If the print statement in GPIO0B0's interrupt handler appears, it indicates successful interrupt preemption.

Testing Steps:

(1) Write the test program fltest_irq_preempt.c to enable TIMER4 and GPIO0B0 interrupts and configure GPIO0B0 for falling edge trigger. In the timer interrupt handler, toggle GPIO4B1 to trigger GPIO0B0's interrupt and print a message in GPIO0B0's interrupt handler to indicate the interrupt;

(2) Modify the interrupt routing to bind TIMER4 and GPIO0 interrupts to CPU3, and set TIMER4's interrupt priority higher than GPIO0B0;

(3) Recompile the image and flash it to the development board;

(4) Enable AMP in the uboot menu and reboot the OK3562J-C development board. The RTOS debug serial port will display related information:

Press the tab key to print out all the current commands:

Then the command is registered successfully.

Execute the fl_irq_test command, and you will see:

GPIO0B0's interrupt preempts the TIMER4 interrupt.

Swap their priorities, recompile and flash again, and it will be observed that GPIO0B0's interrupt is handled after the TIMER4 interrupt ends, without preemption.

Introduction to Ultrasonic Testing Instruments

Ultrasonic testing instruments are portable, non-destructive testing devices that use ultrasonic technology to quickly, conveniently, and accurately detect, locate, and assess various internal defects (such as cracks, porosity, and inclusions) in workpieces. These instruments are suitable for both laboratory environments and field use, and are widely used in industries including, but not limited to, boilers, pressure vessels, aerospace, power, oil, chemical, marine oil, pipelines, defense, shipbuilding, automotive, machinery manufacturing, metallurgy, and metalworking.

Ultrasonic flaw detectors work on the principle that ultrasound waves are strongly reflected when they pass through the interface of tissues with different acoustic impedances. When ultrasonic waves encounter defects or interfaces, they reflect, and the testing instrument identifies and locates these defects by receiving and processing the reflected waves.

Product Features

• High Precision Detection: Capable of accurately detecting minute internal defects such as cracks and porosity, providing detailed information and location of defects.
• Portable Design: Typically designed to be lightweight and easy to carry, enabling quick field inspections.
• Versatility: Many ultrasonic testing instruments offer advanced features such as automatic calibration, automatic display of defect echo positions, and automatic recording of the inspection process.
• User-Friendly: Equipped with intuitive user interfaces and displays, simplifying operation while providing detailed inspection reports and data storage capabilities.
• Strong Adaptability: Capable of meeting the demands of different industries and materials by changing probes and adjusting settings to meet specific testing requirements.

Design Requirements

• Processing Power and Real-Time Performance: Ultrasonic testing instruments need to process large amounts of ultrasonic signal data quickly, requiring the main control platform to have strong processing capabilities. The processing must also meet real-time requirements to ensure accuracy and efficiency of the testing.
• Interface Richness and Compatibility: The instrument may need to connect and exchange data with various peripherals and sensors, necessitating a control platform with extensive interface support and good compatibility to adapt to devices from different manufacturers and models.
• Power Consumption and Heat Dissipation: Given that ultrasonic testing instruments often operate continuously for extended periods, power consumption and heat dissipation are key design considerations. The control platform must minimize power consumption to reduce heat generation and improve device endurance.
• Cost Considerations: Cost is a critical factor in the design of ultrasonic testing instruments. The choice and design of the control platform need to balance performance and functionality with cost-effectiveness to ensure market competitiveness.

Forlinx Embedded FET62xx-C is highly suitable as a hardware development platform for ultrasonic testing instruments, featuring:

1. High-Performance Processor: FET62xx-C SoM uses the TI Sitara™ AM62x series industrial-grade processors with an Arm Cortex A53 architecture, operating at up to 1.4GHz. This high-performance processor ensures speed and accuracy in data processing, image analysis, and real-time feedback, enhancing the overall performance of the testing instrument.

2. Extensive Interface Support: It integrates a wide range of interfaces, including 2 x TSN-supported Gigabit Ethernet ports, USB 2.0, LVDS, RGB parallel, UART, OSPI, CAN-FD, Camera, and Audio. These interfaces provide seamless connectivity with various peripherals and sensors, offering greater expandability and application possibilities for the ultrasonic testing instrument.

3. Flexible Processor Options: It is compatible with the full AM62x processor series, offering...

Read more

This project is based on the Forlinx Embedded OKMX8MP-C development board, which has a virtual machine ported. It is necessary to install the required packages on the development board and ensure that the board is connected to the network.

01 Logging into the OKMX8MP-C Development Board

Connect the Type-C cable to the Debug port and select eMMC as the boot mode (i.e., set mode selection switch 2 to “on” and all others to “off”). After booting, log in using the root account.

02 Modifying the pip Source

To speed up the installation process, it is necessary to modify the pip source:

mkdir ~/.pip
vim ~/.pip/pip.conf

Add the followings:

[global]
trusted-host=mirrors.aliyun.com
index-url=http://mirrors.aliyun.com/pypi/simple/

03 Installing the Python venv Environment

First, install the python3-venv package:

apt install python3-venv

Once installed successfully, create a directory named yolo (or any name of choice) and enter this directory to set up the Python 3 environment:

Create the yolo directory (the directory name can be taken by yourself), and enter the directory to install the python3 environment:

cd ~
mkdir yolo
cd yolo
python3 -m venv venv

Execute the following figure:

Activate the Python 3 venv environment:

source venv/bin/activate

If activation is successful, it will display the following:

04 Installing Ultralytics

Ultralytics YOLOv8 is based on cutting-edge deep learning and computer vision technologies, offering unparalleled performance in speed and accuracy. Its streamlined design makes it suitable for various applications and easily adaptable to different hardware platforms, from edge devices to cloud API.

To install it, use the following command:

pip3 install ultralytics

Be patient while the installation completes:

Once the installation is successful:

05 Testing the Installation

Use the following command to test the setup. The image link in source can be replaced with another link:

During this process, the model and image will be downloaded, so patience is required.

After successful execution, the results will be generated in the runs/detect/predict* directory. The results can be copied to a Windows computer using the scp command. In the cmd terminal, execute the following command:

scp root@192.168.123.18:/root/yolo/runs/detect/predict/8f.jpg E:\\

If the output can be recognized, it indicates that the YOLO environment is functioning correctly.

It is the process of setting up the YOLO environment on the Forlinx Embedded OKMX8MP-C development board. Hope it is useful.

MIPI-CSI is a common camera interface in embedded systems or mobile devices, enabling high-speed image data transfer. The latest OK3576-C development board from Forlinx Embedded offers a wealth of resource interfaces, including support for 5 x CSI-2 , meaning it can support up to five camera inputs simultaneously.

This article introduces the Camera path of RK3576 processor and how to configure different output formats of MIPI-CSI camera through OK3576-C development board.

01. RK3576 Camera Channels

If there is only one camera access, turn on only rkispx_vir0 . Please note:

• vicap and isp do not have a direct correspondence;
• The relationships between different vir0/vir1 channels are essentially the same hardware being multiplexed, with the same effect. When using multiple cameras, configure them using 0, 1, 2, etc., as much as possible.

The hardware channel diagram is as follows:

There is one dcphy interface and two dphy interfaces. The connection paths are as follows:

Single Camera (connected to one dphy):

sensor0->csi2_dphy0->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir0

Dual Cameras (connected to two dphys)

sensor0->csi2_dphy0->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir0
sensor1->csi2_dphy3->mipi3_csi2->rkcif_mipi_lvds3(sditf)->rkisp_vir1

Three Cameras (connected to dcphy and two dphys)

sensor0->csi2_dcphy0->mipi0_csi2->rkcif_mipi_lvds(sditf)->rkisp_vir0
sensor1->csi2_dphy0->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir1
sensor2->csi2_dphy3->mipi3_csi2->rkcif_mipi_lvds3(sditf)->rkisp_vir2

Five Cameras (connected to dcphy and two split dphys)

sensor0->csi2_dcphy0->mipi0_csi2->rkcif_mipi_lvds(sditf)->rkisp_vir0
sensor1->csi2_dphy1->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir1
sensor2->csi2_dphy2->mipi2_csi2->rkcif_mipi_lvds2(sditf)->rkisp_vir2
sensor3->csi2_dphy4->mipi3_csi2->rkcif_mipi_lvds3(sditf)->rkisp_vir3
sensor4->csi2_dphy5->mipi4_csi2->rkcif_mipi_lvds4(sditf)->rkisp_vir4

Camera Channel Connection Diagram:

(Note: For RGB data input, it is also necessary to connect to rkisp_virx)

02. Sensor Link Scenarios for Different Platforms

yuv422/rgb888 input

There are three common scenarios for yuv422/rgb888 input:

• Cameras with Built-in isp or External isp. Enter yuv422 format;
• HDMI to MIPI CSI Input. Common chips like rk628d/f,lt6911xxx, etc., typically convert yuv422, but rgb888 format is also possible;
• Multiple ahd and serdes. A single mipi port can support up to four virtual channels. For these scenarios, an isp is not required, and the connection only needs to go to cif. Thus, the link is:

sensor->csi2_dphyX->mipiX_csi2->rkcif_mipi_lvdsX rkcif_mipi_lvdsx_sditf

The isp node can be disabled. The X varies depending on the platform and hardware connections.

The node used for capturing images is the first video node corresponding to rkcif_mipi_lvdsX. This can be viewed using media-ctl to check the topology. For example, on the OK3576-C development board with an OV5645 camera, it is mounted on the media1 node.

root@ok3576-buildroot:/# media-ctl -p -d /dev/media1
Media controller API version 6.1.57
driver          rkcif
model           rkcif-mipi-lvds1
serial
bus info        platform:rkcif-mipi-lvds1
hw revision     0x0
driver version  6.1.57
Device topology
- entity 1: stream_cif_mipi_id0 (1 pad, 11 links) type Node subtype V4L flags 0 device node name /dev/video11 pad0: Sink <- "rockchip-mipi-csi2":1 [ENABLED] <- "rockchip-mipi-csi2":2 [] <- "rockchip-mipi-csi2":3 [] <- "rockchip-mipi-csi2":4 [] <- "rockchip-mipi-csi2":5 [] <- "rockchip-mipi-csi2":6 [] <- "rockchip-mipi-csi2":7 [] <- "rockchip-mipi-csi2":8 [] <- "rockchip-mipi-csi2":9 [] <- "rockchip-mipi-csi2":10 [] <- "rockchip-mipi-csi2":11 [] - entity 5: stream_cif_mipi_id1 (1 pad, 11 links) type Node subtype V4L flags 0 device node name /dev/video12 pad0: Sink <- "rockchip-mipi-csi2":1 [] <- "rockchip-mipi-csi2":2 [ENABLED] <- "rockchip-mipi-csi2":3 [] <- "rockchip-mipi-csi2":4 [] <- "rockchip-mipi-csi2":5 [] <- "rockchip-mipi-csi2":6 [] <- "rockchip-mipi-csi2":7 []...

Read more

MIPI-CSI is a common camera interface in embedded systems or mobile devices, enabling high-speed image data transfer. The latest OK3576-C development board from Forlinx Embedded offers a wealth of resource interfaces, including support for 5 x CSI-2 , meaning it can support up to five camera inputs simultaneously.

This article introduces the Camera path of RK3576 processor and how to configure different output formats of MIPI-CSI camera through OK3576-C development board.

01. RK3576 Camera Channels

If there is only one camera access, turn on only rkispx_vir0 . Please note:

• vicap and isp do not have a direct correspondence;
• The relationships between different vir0/vir1 channels are essentially the same hardware being multiplexed, with the same effect. When using multiple cameras, configure them using 0, 1, 2, etc., as much as possible.

The hardware channel diagram is as follows:

There is one dcphy interface and two dphy interfaces. The connection paths are as follows:

Single Camera (connected to one dphy):

sensor0->csi2_dphy0->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir0

Dual Cameras (connected to two dphys)

sensor0->csi2_dphy0->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir0
sensor1->csi2_dphy3->mipi3_csi2->rkcif_mipi_lvds3(sditf)->rkisp_vir1

Three Cameras (connected to dcphy and two dphys)

sensor0->csi2_dcphy0->mipi0_csi2->rkcif_mipi_lvds(sditf)->rkisp_vir0
sensor1->csi2_dphy0->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir1
sensor2->csi2_dphy3->mipi3_csi2->rkcif_mipi_lvds3(sditf)->rkisp_vir2

Five Cameras (connected to dcphy and two split dphys)

sensor0->csi2_dcphy0->mipi0_csi2->rkcif_mipi_lvds(sditf)->rkisp_vir0
sensor1->csi2_dphy1->mipi1_csi2->rkcif_mipi_lvds1(sditf)->rkisp_vir1
sensor2->csi2_dphy2->mipi2_csi2->rkcif_mipi_lvds2(sditf)->rkisp_vir2
sensor3->csi2_dphy4->mipi3_csi2->rkcif_mipi_lvds3(sditf)->rkisp_vir3
sensor4->csi2_dphy5->mipi4_csi2->rkcif_mipi_lvds4(sditf)->rkisp_vir4

Camera Channel Connection Diagram:

(Note: For RGB data input, it is also necessary to connect to rkisp_virx)

02. Sensor Link Scenarios for Different Platforms

yuv422/rgb888 input

There are three common scenarios for yuv422/rgb888 input:

• Cameras with Built-in isp or External isp. Enter yuv422 format;
• HDMI to MIPI CSI Input. Common chips like rk628d/f,lt6911xxx, etc., typically convert yuv422, but rgb888 format is also possible;
• Multiple ahd and serdes. A single mipi port can support up to four virtual channels. For these scenarios, an isp is not required, and the connection only needs to go to cif. Thus, the link is:

sensor->csi2_dphyX->mipiX_csi2->rkcif_mipi_lvdsX rkcif_mipi_lvdsx_sditf

The isp node can be disabled. The X varies depending on the platform and hardware connections.

The node used for capturing images is the first video node corresponding to rkcif_mipi_lvdsX. This can be viewed using media-ctl to check the topology. For example, on the OK3576-C development board with an OV5645 camera, it is mounted on the media1 node.

root@ok3576-buildroot:/# media-ctl -p -d /dev/media1
Media controller API version 6.1.57
driver          rkcif
model           rkcif-mipi-lvds1
serial
bus info        platform:rkcif-mipi-lvds1
hw revision     0x0
driver version  6.1.57
Device topology
- entity 1: stream_cif_mipi_id0 (1 pad, 11 links) type Node subtype V4L flags 0 device node name /dev/video11 pad0: Sink <- "rockchip-mipi-csi2":1 [ENABLED] <- "rockchip-mipi-csi2":2 [] <- "rockchip-mipi-csi2":3 [] <- "rockchip-mipi-csi2":4 [] <- "rockchip-mipi-csi2":5 [] <- "rockchip-mipi-csi2":6 [] <- "rockchip-mipi-csi2":7 [] <- "rockchip-mipi-csi2":8 [] <- "rockchip-mipi-csi2":9 [] <- "rockchip-mipi-csi2":10 [] <- "rockchip-mipi-csi2":11 [] - entity 5: stream_cif_mipi_id1 (1 pad, 11 links) type Node subtype V4L flags 0 device node name /dev/video12 pad0: Sink <- "rockchip-mipi-csi2":1 [] <- "rockchip-mipi-csi2":2 [ENABLED] <- "rockchip-mipi-csi2":3 [] <- "rockchip-mipi-csi2":4 [] <- "rockchip-mipi-csi2":5 [] <- "rockchip-mipi-csi2":6 [] <- "rockchip-mipi-csi2":7...

Read more

Driven by modern technology, embedded boards have become integral to various aspects of life, from power supply and transportation to precision medical devices. Their stable operation is crucial for the smooth functioning of society. However, devices in these critical areas often operate under extreme temperature conditions, demanding high levels of stability from embedded boards. Therefore, performance testing under high and low temperatures is essential.

Forlinx Embedded understands this need and has equipped its physical environment laboratory with three advanced high-low temperature testing devices. These devices have a broad temperature control range, from -60°C to +150°C. Forlinx conducts stability tests on embedded boards for up to 48 hours within this extreme temperature range. This step is crucial for validating the board's stability and reliability in various environments, ensuring fault-free operation in real-world applications.

To comprehensively assess board performance, Forlinx also offers customized tests based on client requirements, including temperature variation tests, constant temperature and humidity tests, and cyclic humidity tests. These tests simulate working conditions under different temperatures and humidity levels to ensure high stability in variable environments.

Why Are High and Low Temperature Tests for Embedded Boards So Critical?

The increasing use of embedded boards in sectors such as power, transportation, and healthcare means these devices often need to operate in extreme climates. Whether in a hot desert or a cold polar region, embedded boards must operate reliably to prevent system failures and potential safety hazards.

In high temperatures, electronic components on embedded boards risk performance degradation, slow response, or even damage. In low temperatures, components might fail to start due to condensation or freezing. To mitigate these issues, Forlinx incorporates several preventive measures in board design, including careful layout and thermal management to minimize the impact of temperature on its performance.

In low-temperature environments, special attention is given to waterproofing, moisture-proofing, and condensation prevention to ensure reliable operation under harsh conditions.

During testing, Forlinx ensures that boards run stably for 24 hours in both low and high-temperature environments to mimic extreme scenarios. Comprehensive performance testing and reliability assessments are conducted to identify and resolve potential issues, guaranteeing outstanding stability and adaptability in real applications.

Through rigorous testing and optimization, Forlinx Embedded is dedicated to providing solutions for embedded boards that perform reliably in various extreme environments, contributing to the stability of critical industries.

Recently, NXP (NXP Semiconductors) i.MX 6 series processors have been added to its "NXP's Product Longevity Program", which extends the lifecycle of different processor models by 10 to 15 years, ensuring long-term stable supply and maintenance.

(The purpose of NXP's Product Longevity Program is to provide stable chip supply for customers' embedded products. The NXP's Product Longevity Program for specific products means ''NXP will at least support this product for a specified period,'' and in special cases, the supply duration can be extended.)

As a gold partner of NXP, Forlinx Embedded has launched 7 SoM products based on 4 processors from the i.MX 6 series, with various temperature ranges and connector types, offering more flexible options for customers. These products are currently widely used in fields such as artificial intelligence, industrial IoT, energy storage, smart transportation, medical equipment, charging stations, consumer electronics, and HMI, and have gained the trust of thousands of customers.

Thanks to NXP's Product Longevity Program, the supply lifecycle of Forlinx Embedded's i.MX 6 series SoMs has also been further extended, providing customers with more durable and stable product support.

i.MX6UltraLite （NXP's Product Longevity Program Until 2035）

Folinx Embedded FETMX6UL-C SoM

Designed based on the NXP i.MX6UltraLite processor with Cortex-A7 architecture and a clock frequency of 528MHz. It uses two sets of high-quality 80Pin board-to-board connectors. Rigorous temperature range testing ensures stable operation in environments from -40℃ to +85℃, supporting up to 8 x UART, 2 x Ethernet, and 2 x CAN industrial bus interfaces. It is available in industrial and commercial versions, providing users with more options.

i.MX 6Quad（NXP's Product Longevity Program Until 2035）

Folinx Embedded FETMX6Q-C SoM

Designed based on the NXP quad-core ARM Cortex-A9 processor with a clock frequency of 1GHz and 12-layer PCB gold-plated technology. The overall board size is only 40mm x 70mm and features four 1.5mm high connectors with up to 320 pins, exposing all processor function pins. It comes with rich carrier board resources, including Gigabit Ethernet, CAN-bus, camera, Wi-Fi & Bluetooth, as well as MIPI, MLB, EIM BUS, and other CPU-specific functions.

Folinx Embedded FETMX6Q-S SoM

Also based on the NXP i.MX 6Quad processor, this version uses 8-layer PCB gold-plated technology with better electrical characteristics and anti-interference properties. The board has 220 pins (55*4) and measures 60mm x 60mm, offering a square structure design for easier carrier board layout.

i.MX 6DualLite （NXP's Product Longevity Program Until 2035）

Folinx Embedded FETMX6DL-C SoM

Designed based on the NXP dual-core ARM Cortex-A9 i.MX6DualLite processor with a clock frequency of 1GHz and 12-layer PCB gold-plated technology. The board is compact at 40mm x 70mm, featuring optimized fixed holes and anti-misplug design, with four 1.5mm high connectors and up to 320 pins, exposing all processor function pins. It comes with abundant carrier board resources, including Gigabit Ethernet, CAN-bus, camera, Wi-Fi & Bluetooth.

Folinx Embedded FETMX6DL-S SoM

Also based on the NXP i.MX6DualLite processor, this board uses 8-layer PCB gold-plated technology. The stamp hole connection method provides better electrical characteristics and anti-interference properties. This SoM is a minimal system with an integrated LCD interface, eliminating the need for a carrier board and enabling immediate startup and debugging, reducing development difficulty. FETMX6DL-S SoM is available in industrial and commercial versions for more options.

i.MX6ULL

Note: i.MX6ULL processor was released in 2016 with a 15-year supply period, and its product longevity has not yet been extended.

Folinx Embedded FETMX6ULL-C SoM

Developed based on the NXP i.MX6ULL processor, using the low-power ARM Cortex-A7 architecture,...

Read more

1. OTG Driver Installation

Tool: OK3568-C ForlinxDesktop User Profile\ForlinxDesktop\Tool\DriverAssitant_v5.11.zip

Extract the above path file to any directory and run it with administrator privileges

Open DriverInstall.exe

Click "Driver Installation"

2. OTG Full Flashing Test

Path: OK3568-C ForlinxDesktop User Profile\ForlinxDesktop\Tool\RKDevTool_Release.zip

It is a development tool provided by Rockchip, before using it, unzip it to a full English path, connect the development board and the host computer with a Type-C cable, press and hold the recovery key of the development board and don't release it, then press the reset key to reset the system, about two seconds after releasing the recovery key. There will be prompts on the Rockchip development tool :

loader device found

Note:

The condition for recognition is that the development board is powered up and the recover key is in the pressed state.

Theoretically, Rockchip development tools have no requirements for the unzip directory. However, some users have feedback that the unzip directory should be in full English. If the tool doesn't match the following figure, please consider unzipping it in an English directory.

Note: Pay attention to two points during OTG programming:

1. Link the OTG line.

2. If OTG is multiplexed with the USB 3.0, it is necessary to modify the dial switch, as shown in the following figure:

Open the RKDevTool

Click the "Upgrade Firmware" tab, click the "Firmware" button to select the full upgrade image update.img.

If the key operation fails, the board will start normally, and the tool interface displays Found One ADB Device. In this case, you can click the “switch” button of the tool to enter loader mode.

3. OTG Step Programming Test

In the development phase, it is very time-consuming to flash all of them every time, so here is the method of using OTG flashing tool to flash in separate partitions.

Note:

The condition for recognition is that the development board is powered up and the recover key is in the pressed state.

First, after OK3568-Forlinx Desktop-release is compiled, a separate partition image can be found in the rockdev directory

Take separate programming boot.img (including device tree and startup logo) as an example to demonstrate the programming method. Use the Type-C cable to connect the development board to the host. Press and hold the recover key and do not release it. Then press the reset key to reset the system. Release the recover key after about two seconds. The system will prompt to discover the loader device.

Click the "Dev Partition" button to automatically read the partition address. There will be a prompt that some partitions cannot be read. Click OK.

Click the right test area of the partition to select the partition mirror, and check the partition.

Click the "Run" button will automatically flash and restart.

Other partitions have been detected on the right but are not displayed in the list on the left, and when you need to flash the partition, you need to right-click on the left and select "Select Add Item", just enter the partition, click "Read Partition Table" again, and the software will automatically assign the partition address.

Introduction to MASKROM mode

If Loader mode is inaccessible (loader problem, etc.), press and hold the BOOT key, then press the reset key to enter maskrom mode for flashing.

At this time, the system will prompt the discovery of a maskrom device. The flashing process is consistent with the loader mode, so it is best to use an update.img flashing.

Note: Don't click "Device Partition Table" in maskrom mode, it is invalid.

OTA Description

OTA, short for Over-the-Air Technology, refers to the process in Android systems where mobile devices download and install updates directly via wireless networks (such as WiFi, 3G/4G/5G) from remote servers, without needing to connect to a computer, simplifying the upgrade process and enhancing user experience.

Advantages of OTA

The advantages of OTA (Over-the-Air) updates in the Android ecosystem are significant and well-appreciated. The primary reason for their popularity is the convenience and speed – users can upgrade their devices without connecting to a computer, simply by being on a network, which saves a considerable amount of time and effort. Simultaneously, OTA updates efficiently and automatically detect new versions and notify users, ensuring that their devices always operate on the latest, most secure system or applications. This not only simplifies the process of manually searching for and installing updates but also reduces the security risks associated with outdated versions. Consequently, OTA updates are vital for enhancing user experience, lowering operational costs, and ensuring the security of devices.

How to implement Android OTA upgrade in imx8mp platform?

Build the OTA upgrade package

1. Build the target file

Enter the related path：

forlinx@ubuntu:~$ cd imx8mp/OK8MP-android-source/
forlinx@ubuntu:~/imx8mp/OK8MP-android-source$

Configure the environment:

forlinx@ubuntu:~/imx8mp/OK8MP-android-source$ source env.sh
forlinx@ubuntu:~/imx8mp/OK8MP-android-source$ source build/envsetup.sh
forlinx@ubuntu:~/imx8mp/OK8MP-android-source$ lunch evk_8mp-userdebug
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=11
TARGET_PRODUCT=evk_8mp
TARGET_BUILD_VARIANT=userdebug
TARGET_BUILD_TYPE=release
TARGET_ARCH=arm64
TARGET_ARCH_VARIANT=armv8-a
TARGET_CPU_VARIANT=cortex-a53
TARGET_2ND_ARCH=arm
TARGET_2ND_ARCH_VARIANT=armv7-a-neon
TARGET_2ND_CPU_VARIANT=cortex-a9
HOST_ARCH=x86_64
HOST_2ND_ARCH=x86
HOST_OS=linux
HOST_OS_EXTRA=Linux-5.4.0-150-generic-x86_64-Ubuntu-18.04.4-LTS
HOST_CROSS_OS=windows
HOST_CROSS_ARCH=x86
HOST_CROSS_2ND_ARCH=x86_64
HOST_BUILD_TYPE=release
BUILD_ID=RQ1A.201205.003
OUT_DIR=out
PRODUCT_SOONG_NAMESPACES=device/generic/goldfish device/generic/goldfish-opengl external/mesa3d vendor/nxp-opensource/imx/power hardware/google/pixel vendor/partner_gms hardware/google/camera vendor/nxp-opensource/imx/camera
============================================

Start compiling:

forlinx@ubuntu:~/imx8mp/OK8MP-android-source$ ./imx-make.sh bootloader kernel -j4
make: Entering directory '/home/forlinx/imx8mp/R3_6.28/OK8MP-android-source'
/home/forlinx/imx8mp/R3_6.28/OK8MP-android-source/device/nxp/common/build/uboot.mk:74: *** shell env AARCH64_GCC_CROSS_COMPILE is not set.  Stop.
make: Leaving directory '/home/forlinx/imx8mp/R3_6.28/OK8MP-android-source'
forlinx@ubuntu:~/imx8mp/OK8MP-android-source$ make target-files-package -j4
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=11
TARGET_PRODUCT=evk_8mp
TARGET_BUILD_VARIANT=userdebug
TARGET_BUILD_TYPE=release
TARGET_ARCH=arm64
TARGET_ARCH_VARIANT=armv8-a
TARGET_CPU_VARIANT=cortex-a53
TARGET_2ND_ARCH=arm
TARGET_2ND_ARCH_VARIANT=armv7-a-neon
TARGET_2ND_CPU_VARIANT=cortex-a9
HOST_ARCH=x86_64
HOST_2ND_ARCH=x86
HOST_OS=linux
HOST_OS_EXTRA=Linux-5.4.0-150-generic-x86_64-Ubuntu-18.04.4-LTS
HOST_CROSS_OS=windows
HOST_CROSS_ARCH=x86
HOST_CROSS_2ND_ARCH=x86_64
HOST_BUILD_TYPE=release
BUILD_ID=RQ1A.201205.003
OUT_DIR=out
PRODUCT_SOONG_NAMESPACES=device/generic/goldfish device/generic/goldfish-opengl external/mesa3d vendor/nxp-opensource/imx/power hardware/google/pixel vendor/partner_gms hardware/google/camera vendor/nxp-opensource/imx/camera
============================================
[……]
#### build completed successfully (13:07 (mm:ss)) ####

After the compilation is completed, it will generate "evk_8mp-/target_files-eng.forlinx.zip" under the path

"out/target/product/evk_8mp/obj/PACKAGING/target_files_intermediates/".target_files-eng.forlinx.zip"...

Read more

Product Background

With the rapid development and widespread application of drone technology, drone-mounted hyperspectral imaging systems integrating drone platforms with high-precision spectral imaging technology are gradually gaining attention. The drone-mounted hyperspectral imaging system can measure spectral information of plants, water bodies, soil, etc., in real-time and generate spectral images. 

By analyzing these images, it is possible to establish relationships with the physicochemical properties of plants and use the data for research on plant classification and growth conditions. Additionally, it has applications in geological and mineral resource exploration, forest pest and disease monitoring, meteorological studies, and other industry fields.

Product Features

• Hyperspectral resolution: Capable of capturing hundreds of continuous and narrow spectral bands, enabling detailed spectral characterization of surface materials.
• High spatial resolution: Combined with the flexibility and stability of the drone platform, this enables high-resolution imaging of ground targets.
• Intelligent data processing: Integrates advanced image processing algorithms and spectral analysis software, supporting rapid processing and interpretation of data.
• Portability and ease of use: The equipment is lightweight and portable, making it easy to mount on drone platforms, while the user interface is user-friendly, simplifying operation for users.
• Broader application scenarios: Suitable for environmental monitoring, agricultural surveys, geological exploration and other fields, meeting the needs of different users.

Product Requirements:

1. Compact carrier board design: Considering the weight and space constraints of the drone, the accompanying imaging device needs to be designed as compactly as possible. The carrier board design should be compact, effectively utilizing every inch of space while ensuring that all key components can be securely installed.

The size of the SoM should also be strictly controlled to fit the compact carrier board layout, without sacrificing its performance.

2. High compression ratio image compression algorithm: The product should incorporate a proprietary high compression ratio image compression algorithm to optimize the storage and transmission efficiency of image data. The algorithm needs to fully leverage the computational power of the SoM to ensure that excessive performance loss does not occur during image compression. The compression algorithm should minimize file size while maintaining image quality to accommodate the limited data transmission bandwidth and storage space of drones.

3. High-quality product stability: Given the complexity of the product application environment, such as extreme weather and mechanical vibrations, the requirements for product quality and stability are extremely high. All components and materials shall be of industrial grade or higher quality to ensure proper operation in a variety of harsh environments. Products shall be subjected to rigorous tests for shock, impact and weather resistance to verify their reliability in complex application environments.

Based on the product characteristics, Forlinx Embedded recommends using the FET3588J-C system on module(SoM) as the hardware design solution for the product.

Solution Features:

1. Strong performance support

High-performance processor: FET3588-C is based on Rockchip's new flagship RK3588 processor, which adopts an 8nm manufacturing process and integrates a quad-core Cortex-A76+quad-core Cortex-A55 architecture with a clock speed up to 2.4GHz, ensuring strong data processing capabilities for drones during hyperspectral imaging.

Powerful computing power: The built-in NPU provides 6 TOPS computing power, which makes it possible for artificial intelligence to be applied in UAV hyperspectral imaging, such as automatic target recognition, real-time analysis, etc.

2. Excellent image processing capabilities...

Read more

To fully meet the growing demand in the AIoT market for high-performance, high-computing-power, and low-power main controllers, Forlinx Embedded has recently launched the FET3576-C System on Module, designed based on the Rockchip RK3576 processor. It features excellent image and video processing capabilities, a rich array of interfaces and expansion options, low power consumption, and a wide range of application scenarios. This article delves into the distinctive benefits of the Forlinx Embedded FET3576-C SoM from four key aspects.

Advantages: 6TOPS computing power NPU, enabling AI applications

Forlinx Embedded FET3576-C SoM has a built-in 6TOPS super arithmetic NPU with excellent deep learning processing capability. It supports INT4/ INT8/ INT16/ FP16/ BF16/ TF32 operation. It supports dual-core working together or independently so that it can flexibly allocate computational resources according to the needs when dealing with complex deep learning tasks. It can also maintain high efficiency and stability when dealing with multiple deep-learning tasks.

FET3576-C SoM also supports TensorFlow, Caffe, Tflite, Pytorch, Onnx NN, Android NN and other deep learning frameworks. Developers can easily deploy existing deep learning models to the SoM and conduct rapid development and optimization. This broad compatibility not only lowers the development threshold, but also accelerates the promotion and adoption of deep learning applications.

Advantages: Firewall achieves true hardware resource isolation

The FET3576-C SoM with RK3576 processor supports RK Firewall technology, ensuring hardware resource isolation for access management between host devices, peripherals, and memory areas.

Access Control Policy - RK Firewall allows configuring policies to control which devices or system components access hardware resources. It includes IP address filtering, port control, and specific application access permissions. Combined with the AMP system, it efficiently manages access policies for diverse systems.

Hardware Resource Mapping and Monitoring - RK Firewall maps the hardware resources in the system, including memory areas, I/O devices, and network interfaces. By monitoring access to these resources, RK Firewall can track in real-time which devices or components are attempting to access specific resources.

Access Control Decision - When a device or component attempts to access hardware resources, RK Firewall will evaluate the access against predefined access control policies. If the access request complies with the policy requirements, access will be granted; otherwise, it will be denied.

Isolation Enforcement - For hardware resources identified as requiring isolation, RK Firewall will implement isolation measures to ensure that they can only be accessed by authorized devices or components.

In summary, RK Firewall achieves effective isolation and management of hardware resources by setting access control policies, monitoring hardware resource access, performing permission checks, and implementing isolation measures. These measures not only enhance system security but also ensure system stability and reliability.

Advantages: Ultra clear display + AI intelligent repair

With its powerful multimedia processing capability, FET3576-C SoM provides users with excellent visual experience. It supports H.264/H.265 codecs for smooth HD video playback in various scenarios, while offering five display interfaces (HDMI/eDP, MIPI DSI, Parallel, EBC, DP) to ensure compatibility with diverse devices.

FET3576-C SoM notably supports triple-screen display functionality, enabling simultaneous display of different content on three screens, significantly enhancing multitasking efficiency.

In addition, its 4K @ 120Hz ultra-clear display and super-resolution function not only brings excellent picture quality enjoyment, but also intelligently repairs blurred images, improves video frame rate, and brings users a clearer and smoother visual...

Read more

Note: Operate under the root user by default.

1. Qemu and Debootstrap Installation

Since a Debian file system is built on Ubuntu, these two tools can be installed directly using the apt-get command. The commands are as follows:

sudo apt-get install binfmt-support qemu qemu-user-static debootstrap

2. Extracting Debian File System

Use the debootstrap command to extract the file system. Execute the following command to retrieve the file system from the Debian mirror:

mkdir /home/forlinx/debian
sudo debootstrap --arch=armhf --foreign buster root https://mirrors.tuna.tsinghua.edu.cn/debian/

Explanation of command parameters:

arch：Specify CPU architecture

buster：Debian version (currently 10)

foreign：Use when initializing unpacking in a different architecture than the host

root：The folder where the file system is stored

https: // mirrors.tuna.tsinghua.edu.cn / debian /：Download source

Extraction may take around 10 minutes. Please be patient. Successful extraction reveals the Linux directory tree. If extraction fails, try multiple attempts or switch networks.

3. Perfecting the File System

Since the operation is conducted on an X86 virtual machine, QEMU needs to be used to simulate an ARM environment to improve the file system.

a.To copy qemu-arm-static into the newly built base system, use the following command:

cd root
sudo cp /usr/bin/qemu-arm-static usr/bin
cd ..

b.Initialize the file system.

Execute the following command:

sudo DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true LC_ALL=C
LANGUAGE=C LANG=C chroot root debootstrap/debootstrap --second-stage

c.Use the chroot root command to initialize file system

chroot root

d.Use the command to create the following

echo "proc /proc proc defaults 0 0" >> etc/fstab
mkdir -p usr/share/man/man1/
mknod dev/console c 5 1

e.To update the download sources, use the command vi /etc/apt/sources.list to open the source.list file and replace the contents with the following:

deb http://mirrors.ustc.edu.cn/debian stable main contrib non-free
#deb-src http://mirrors.ustc.edu.cn/debian stable main contrib non-free
deb http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
#deb-src http://mirrors.ustc.edu.cn/debian stable-updates main contrib non-free
#deb http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free
#deb-src http://mirrors.ustc.edu.cn/debian stable-proposed-updates main contrib non-free

Then save and exit. Use the command apt-get update to update the source. If updating the download source reports an error,use the date command to modify the system time to solve the problem.

f.Use the command apt-get install vim to install some necessary software

apt-get install vim
apt-get install sudo
apt-get install dpkg
apt-get install bzip2
apt-get install net-tools
apt-get install ntpdate

g.Create a new user with the command adduser forlinx, then enter the password

adduser forlinx

h.Set the root password, use the command passwd root, and set the password to forlinx.

passwd root

i.To set up Ethernet, enter the following command:

vi /etc/network/interfaces

As follows:

#/etc/network/interfaces -- configuration file for ifup(8), ifdown(8)
#The loopback interface
auto lo
iface lo inet loopback
#Wireless interfaces
iface wlan0 inet dhcp
wireless_mode managed
wireless_essid any
wpa-driver wext
wpa-conf /etc/wpa_supplicant.conf
iface atml0 inet dhcp
#Wired or wireless interfaces
auto eth0
#iface eth0 inet dhcp
#iface eth1 inet dhcp
iface eth0 inet static
address 192.168.0.232
netmask 255.255.255.0
gateway 192.168.0.1
broadcast 192.168.0.255
auto eth1
iface eth1 inet static
address 192.168.1.232
netmask 255.255.255.0
gateway 192.168.1.1
broadcast 192.168.1.255
#Ethernet/RNDIS gadget (g_ether)
#... or on host side, usbnet and random hwaddr
iface usb0 inet static
address 192.168.7.2
netmask 255.255.255.0
network 192.168.7.0
gateway 192.168.7.1
#Bluetooth networking
iface...

Read more

1. Product Description

Vending machines, combining modern technology with the idea of convenient shopping, have become essential in our lives. It breaks through the constraints of time and space, providing us with round-the-clock uninterrupted product purchasing services. Whether in busy transportation hubs or quiet residential areas, you can always find its presence.

2. Components:

• Body Compartment: Made from high-strength, corrosion-resistant metal materials to ensure the stability and durability of the vending machine. The warehouse's interior is well-designed and can be adjusted according to the size of the goods to maximize the use of storage space.
• Payment System: Integrated with multiple payment methods including coins, bills, card swiping, and mobile payments, satisfying various consumer payment needs.
• Display and operation: HD touchscreen shows product information and purchase process, simplifying steps to enhance user experience.
• Product Delivery System: Uses precise mechanics and sensors for accurate, fast delivery to the outlet after payment.
• Communication Management System: Enables real-time monitoring, sales data analysis, and remote fault diagnosis and repair of vending machines via wireless network.

Business Logic Topology

The vending machine's main control system acts as its operational core, akin to its "brain", overseeing and coordinating each module's functions. With the ongoing development of IoT, big data, and AI, automation has become an inevitable trend in the vending machine industry. This has led to new demands for the main control systems, focusing on:

• Core Controller: It is essential to choose a stable, reliable, and high-performance core controller to ensure the overall logic control and data processing capabilities of vending machines.
• Device Stability: It requires 24/7 uninterrupted operation, necessitating high stability and durability in both hardware and software. Specifically, the software system should have fault self-check and automatic recovery capabilities.
• Scalability and Compatibility: To meet various scenarios and demands, the main control system of vending machines needs to be scalable. As products evolve, the main control system should be compatible with new hardware and software standards.
• Payment Security: As payment methods diversify, ensuring the security of the payment process has become increasingly important. Vending machines need to guard against various security threats, such as data breaches and fraudulent activities.
• AI Integration: Vending machines need to have intelligent recognition capabilities and data analysis abilities to recommend products based on users' purchasing preferences.

FET3568-C system on module(SoM) from Forlinx Embedded Systems offers high performance, low power consumption, and rich functionality, making it ideal for vending machines for these reasons:

• Powerful Performance: FET3568-C SoM is based on the Rockchip RK3568 processor, which features a quad-core 64-bit Cortex-A55 architecture with a clock speed of up to 2.0GHz. It supports lightweight edge AI computing and delivers strong computational and processing capabilities. Such performance meets the high demands of logic control and data processing for vending machine control systems, ensuring efficient and stable operation of the vending machines.
• Rich Interfaces and Expandability: The FET3568-C SoM offers 3 x PCIe slots, 4 x USB ports, 3 x SATA3.0 controllers, and 2 x Gigabit Ethernet ports. It supports 5 x display interfaces including HDMI2.0, eDP, LVDS, RGB Parallel, and MIPI-DSI, with up to three simultaneous display outputs. These interfaces provide great convenience for expanding the functionality of vending machines, enabling customized development to meet various scenarios and requirements.
• Multi-OS Support: FET3568-C SoM supports multiple operating systems including Linux, Android 11, Ubuntu, and Debian 11. This...

Read more

Introduction to the U-Boot boot process

U-Boot Boot Process Stage 1

Main process Partial Hardware Initialization -> Load Full U-Boot into RAM -> Jump to Stage 2 Entry for Execution.

Files Used Mainly in Stage 1 (Non-Open Source Scenario):

• start.S (Hardware Initialization, watchdog, interrupts, clock configurations)
• lowlevel_init.S (RAM (DDR) initialization, U-Boot code loading, stack setup, BSS clearing, jump to U-Boot Stage 2

U-Boot Boot Process Stage 2

Stage 2 involves further hardware initialization by U-Boot, configuring command line parameters and environment variables, and transitioning to the kernel.

The main documents used are:

• board.c file: Typically, our own files are located in the board/forlinx/ directory.
• main.c file: Located in the common directory

Main function

Some of the more important initialisation functions are as follows:

1.''setup_mon_len'' function: Set the ''gd'' structure's ''mon_len'' member variable, representing the length of the entire code;

2.''initf_malloc'' function: Sets the ''gd '' structure's member variables related to ''malloc'';

3.''board_early_init_f''function;

4.To initialize the IO configuration of the serial port, defined in the board/freescale/mx6ull_toto/mx6ull_toto.cfile;

5.''timer_init'' function: Initialize the kernel timer to provide clock ticks for U-Boot, defined in the ''arch/arm/imxcommon/timer.c''file;

6.''get_clocks'' function: Retrieve the clock for the SD card peripheral (sdhc_clk), defined in the arch/arm/imxcommon/speed.c file;

7.''init_baud_rate'' function: Initialize the baud rate, defined in the ''common/board_f.c'' file.

8.''serial_init'' function: Initialize serial communication settings, defined in the''drivers/serial/serial.c''file;

9.''console_init_f'' function: Initialize the console, defined in the ''common/console.c'' file;

10.''display_options'' function: Print U-Boot version information and compilation details, defined in the lib/display_options.c file;

11.''print_cpuinfo'' function: To display CPU information and the main clock frequency, defined in the arch/arm/imx-common/cpu.c file;

12.''show_board_info'' function: Print development board information, defined in the common/board _ info.c file;

13.''init_func_i2c'' function: To initialize I2C;

14.''announce_dram_init'' function: This function is simple, it outputs the string "DRAM:";

15.''dram_init'' function: Doesn't actually initialize DDR but rather sets the value of gd->ram_size.

Current U-boot startup print information

U-Boot SPL 2021.01-gd1345267-dirty (Jul 08 2023 - 08:00:49 +0800)
SYSFW ABI: 3.1 (firmware rev 0x0015 '21.5.1--w2022.07-am62x (Terrifi')
am625_init: board_init_f done(counter=1)
SPL initial stack usage: 13768 bytes
i2c_write: error waiting for data ACK (status=0x116)
i2c_write: error waiting for data ACK (status=0x116)
Auth Success!
normal mode
am625_init: spl_boot_device: devstat = 0x1843 bootmedia = 0x9 bootindex = 0
Trying to boot from MMC1
am625_init: spl_boot_device: devstat = 0x1843 bootmedia = 0x9 bootindex = 0
Loading Environment from MMC... MMC: block number 0x3500 exceeds max(0x2000)
*** Warning - !read failed, using default environment
am625_init: spl_boot_device: devstat = 0x1843 bootmedia = 0x9 bootindex = 0
am625_init: spl_boot_device: devstat = 0x1843 bootmedia = 0x9 bootindex = 0
init_env from device 9 not supported!
Starting ATF on ARM64 core...
NOTICE:  BL31: v2.5(release):v0.6-6-gd489c56b
NOTICE:  BL31: Built : 15:08:18, Jun 26 2023
U-Boot SPL 2021.01-gd1345267-dirty (Jul 08 2023 - 08:00:56 +0800)
SYSFW ABI: 3.1 (firmware rev 0x0015 '21.5.1--w2022.07-am62x (Terrifi')
am625_init: board_init_f done
am625_init: spl_boot_device: devstat = 0x1843 bootmedia = 0x9 bootindex = 0
Trying to boot from MMC1
am625_init: spl_boot_device: devstat = 0x1843 bootmedia = 0x9 bootindex = 0
U-Boot 2021.01-gd1345267-dirty (Jul 08 2023 - 08:00:56 +0800)
SoC: AM62X SR1.0
Model: Forlinx OK62xx-C board
DRAM: 2 GiB
MMC: mmc@fa10000: 0, mmc@fa00000: 1
Loading Environment...

Read more

1. RTC Description

1.1 What's RTC?

RTC (Real Time Clock): It is an electronic device that functions like a clock to output real-world time. RTC Overview: The RTC is a 32-bit timer that increments every second, functioning like a clock. Date and time can be modified by adjusting the timer value.

To ensure that the RTC time is not lost during power outages, a small battery is usually connected separately to provide power to the RTC. Once the small battery is removed, the RTC will lose the time after a power outage.

However, the time in the lower right corner of the computer and the time seen with date under Linux are not RTC time. During system operation, a high-precision register on the chip serves as the system time reference. To avoid drift over extended system operation and prevent time loss after power failure, each time the system starts up, it retrieves the time from the RTC to set as the system time.

1.2 Difference Between Internal and External RTC

External RTC advantages:

Low power consumption

Minimal deviation

Therefore, an external RTC (Real-Time Clock) is generally used.

2. Unix Time Stamp

Unix timestamp is defined as the number of seconds elapsed since 00:00:00 coordinated Universal Time (UTC) on January 1, 1970, excluding leap seconds.

The timestamp is stored in a seconds counter, which is a 32-bit/64-bit integer variable.

The timestamp is stored in a 32-bit/64-bit integer seconds counter, uniform globally across all time zones, with local times derived from applying offsets to this counter.

3. Common operation

3.1 Date

The "date" command can read/write the current system time and also display the time zone. Common operations：

View time:

Before changing the timezone
root@fl-imx6ull:~# date
Thu Sep 21 04:43:03 UTC 2017
After changing the timezone
root@fl-imx6ull:~# date
Thu Sep 21 12:43:50 HKT 2017

View timezone

Before changing the timezone
root@fl-imx6ull:~# date -R
Fri, 26 Apr 2019 19:07:20 +0000
After changing the timezone
root@fl-imx6ull:~# date -R
Thu, 21 Sep 2017 12:45:37 +0800

Set time:

root@fl-imx6ull:~# date -s "20240531 12:00:00"
Fri May 31 12:00:00 UTC 2024

3.2 Timezone modification

The time zone file is/etc/localtime. When the time zone needs to be modified, only the corresponding time zone file needs to be linked to/etc/localtime.

root@fl-imx6ull:~# rm /etc/localtime
root@fl-imx6ull:~# ln -s /usr/share/zoneinfo/Asia/Hong_Kong /etc/localtime

3.3 hwclock

Read RTC time

root@fl-imx6ull:~# hwclock -r
Thu Sep 21 04:47:03 2017 0.000000 seconds

Write in time

hwclock -w
root@fl-imx6ull:~# date
Thu Sep 21 12:50:41 HKT 2017
root@fl-imx6ull:~# hwclock -w
root@fl-imx6ull:~# hwclock -r
Thu Sep 21 12:51:36 2017 0.000000 seconds
hwclock -wu
root@fl-imx6ull:~# date
Thu Sep 21 12:52:51 HKT 2017
root@fl-imx6ull:~# hwclock -wu
root@fl-imx6ull:~# hwclock -r
Thu Sep 21 04:52:56 2017 0.000000 seconds

Note: If UTC is enabled and the time zone is modified, hwclock -wu should be usedSync system time to RTC

hwclock --systohc

Sync RTC time to system

hwclock --hctosys

4. Sync RTC to system

At system startup, the RTC time is read and used as the system time. Using the example of the imx6ull processor, after powering on, the operations related to RTC are as follows:

There are the followings in the /etc/rcS.d/S55bootmisc.sh:

#
# This is as good a place as any for a sanity check
#
# Set the system clock from hardware clock
# If the timestamp is more recent than the current time,
# use the timestamp instead.
test -x /etc/init.d/hwclock.sh && /etc/init.d/hwclock.sh start
if test -e /etc/timestamp
then
SYSTEMDATE=`date -u +%4Y%2m%2d%2H%2M%2S`
read TIMESTAMP < /etc/timestamp
if [ ${TIMESTAMP} -gt $SYSTEMDATE ]; then
# format the timestamp as date expects it (2m2d2H2M4Y.2S)
TS_YR=${TIMESTAMP%??????????}
TS_SEC=${TIMESTAMP#????????????}
TS_FIRST12=${TIMESTAMP%??}
TS_MIDDLE8=${TS_FIRST12#????}
date -u ${TS_MIDDLE8}${TS_YR}.${TS_SEC}
test -x /etc/init.d/hwclock.sh && /etc/init.d/hwclock.sh stop
fi
fi

The main functions of this part...

Read more

Fast Pesticide Residue Detector: Efficient and convenient device for rapid analysis of pesticide residue in fruits and vegetables. It accurately measures pesticide residue in agricultural products, ensuring food safety and dietary health. It is widely used in industrial and commercial administration, vegetable wholesale markets, supermarkets, shopping malls and other fields.

Hardware Technology Implementation Features

• High Sensitivity and Accuracy: The detector employs advanced detection technology, capable of detecting very low concentrations of pesticide residues, ensuring precise and sensitive test results.
• Fast Detection and High Throughput: Utilizing advanced electronic and optoelectronic systems, the pesticide residue detector provides quick and accurate test results, enhancing detection efficiency. Some models also handle large sample volumes, further enhancing their high-throughput detection advantage.
• Automation and User-friendliness: It uses automated control technology to perform testing processes such as sample introduction, detection, and cleaning automatically, reducing manual operation time and errors. User-Friendly Interface: Its intuitive design simplifies operation, requiring minimal specialized skills.
• Versatility and Wide Applicability: In addition to pesticide residue detection, some pesticide residue analyzers also offer multiple detection methods to meet various pesticide testing needs. This makes the instrument valuable across various fields such as agricultural product quality and food safety.

With food safety concerns increasingly prominent, pesticide residue detection has become a crucial step in ensuring food quality and safety. Traditional pesticide analyzers are often limited by processing capabilities and power consumption, hindering rapid and accurate detection demands. Forlinx Embedded recommends the FET3568-C SoM as the solution.

FET3568-C is a high-performance, low-power processor, particularly suitable for embedded devices and IoT applications. In pesticide residue analyzers, the FET3568-C platform provides robust support for efficient operation with its outstanding computational power and power management capabilities.

• With powerful computing power. The powerful CPU cores can process large volumes of data to finish the pesticide residue detection and analysis within a short time. This is crucial for scenarios requiring real-time detection and output of results, effectively enhancing detection efficiency.
• Excellent power consumption control In the pesticide residue analyzer, low power consumption means extended battery life, which is crucial for users who need to conduct long-term detection in fields or laboratories. Additionally, low power consumption helps reduce device heat generation, thereby enhancing device stability and reliability.
• Rich peripheral interfaces such as UART, SPI, I2C, etc., facilitate communication with various sensors and external devices. In the pesticide residue analyzer, these interfaces can connect key components such as photodetectors and sensors, enabling rapid data acquisition and transmission. Additionally, the RK3568 supports various storage media, making it convenient for users to save and export test data.
• In addition to hardware performance improvements, the FET3568-C also enables software optimization for pesticide residue analyzers. Based on the powerful computing capabilities of RK3568, the analyzer can run more complex algorithms and models, thereby improving detection accuracy and precision. Additionally, the RK3568 supports various operating systems and programming environments, providing developers with flexible development options.

Rockchip's RK3568 significantly enhances the performance and reliability of pesticide residue analyzers. Its powerful computing capabilities, excellent power management, and rich peripheral interfaces enable pesticide residue analyzers to better meet the demands for rapid and accurate...

Read more

Marine instrument panels are critical display and monitoring devices on ships, crucial for ensuring maritime safety, efficiency, and comfort. Real-time monitoring of vital ship information such as position, speed, heading, and engine status through marine instrument panels enables prompt adjustments and decision-making. They not only enhance the precision and reliability of ship operations but also help reduce accident risks, ensuring safe navigation. Moreover, the digital and intelligent design of marine instrument panels allows crew members to manage and control ships more efficiently, improving operational efficiency. They are key tools for ship operation and management.

With the continuous advancement of maritime technology, there is an increasing demand for intelligence and digitization in modern ships. As a core component for ship information display and monitoring, the performance and stability of marine instrument panels are crucial to meet modern maritime needs for information display, data monitoring, and navigation safety. Specific objectives include:

• Providing a clear and intuitive instrument display interface enables crew members to quickly access navigation information.
• Facilitating compatibility with various data interfaces enables seamless data transmission with onboard sensors and equipment.
• Ensuring that instrument panels can operate stably in harsh maritime environments, with high resistance to interference and waterproof performance, is essential.

Based on the above characteristics, the hardware platform of modern marine instrument panels should possess the following features:

• High-performance processor: Ensures fast response and accurate display of navigation information, equipped with powerful data processing and graphic rendering capabilities.
• Rich Data Interfaces: Integrated with multiple data interfaces such as display ports, serial ports, Ethernet ports, USB ports, etc., enabling seamless connection with various sensors and devices onboard ships for easy data display, real-time acquisition, and transmission.
• Reliability Design: The hardware itself demands high quality and stability to ensure long-term reliable operation in harsh maritime environments.

Based on a modern marine instrument screen hardware platform, Forlinx Embedded recommends FET3588J-C as the hardware development solution.

Product Characteristics

• High-performance processor: Quad-core 64-bit Cortex-A72 + quad-core Cortex-A55 architecture with integrated 6 TOPS NPU for enhanced AI learning and edge computing capabilities in diverse operational scenarios.
• Rich Display Interfaces: Offers multiple interfaces such as HDMI, eDP, DP, MIPI-DSI, supporting various display types including up to 8K output, meeting diverse requirements for maritime instrumentation screens. At the same time, it supports four-screen display function, which enables the crew to monitor multiple important parameters at the same time and improve work efficiency.
• High-efficiency Graphics Processing: Integrates ARM Mali-G610 MP4 quad-core GPU, fully compatible with OpenGLES 1.1, 2.0, and 3.2, OpenCL up to 2.2, and Vulkan 1.2. Enables maritime instrumentation screens to efficiently handle complex graphic tasks such as real-time rendering and 3D map display, enhancing user operational experience.
• Versatile Peripheral Interfaces: Features include dual Gigabit Ethernet, USB 3.1, PCIe 3.0, and 10 UART ports, enhancing data speed and efficiency. This strengthens maritime instrumentation screen functionality, meets navigation needs, and ensures stable data transmission and efficient device communication.
• Robust and Reliable Performance: The RK3588J platform meets industrial-grade temperature range standards and has undergone rigorous testing to provide stable performance support for high-end applications. During maritime navigation, stable and reliable instrumentation screens are crucial for ensuring the safety of vessels....

Read more

▊ IP Settings

Two IP configuration methods:

(1)Set a default static IP;

(2)Set a temporary static IP ( it is disabled after power cycling).

1. Static IP settings

(1) Open /etc/network/interfaces and modify the configuration vi /etc/network/interfaces

As follows, configure eth0 as static and eth1 as dynamic:

(2) DNS settings

Open rc.local with the command vi /etc/rc.local and add the following to it:

echo "nameserver 8.8.8.8" > /etc/resolv.conf

(3) Block information update&restart

sync

reboot

2. Temporary network settings

Alternatively, the commands can be used temporarily to set the IP and gateway. However, please note that this method's configuration will be lost after a restart.

ifconfig eth0 172.16.0.171//Set eth0 static IP
route add default gw 172.16.0.1 //Set gateway
echo ''nameserver 8.8.8.8'' > /etc/resolv.conf //Set DNS

▊ Adding Startup Auto-run Content

1. Adding the following to the startup script

Enter vi /etc/rc.local

As an example of booting with the output ''hello world,'' add the following content:

Note: Add the startup auto-run content before exit 0;

2. Adding startup auto-run items

To create a startup auto-run item in the /etc/rc5.d/ directory

vi /etc/rc5.d/S99test.sh

As follows:

#!/bin/bash

echo "helloworld!"

chmod 777 /etc/rc5.d/S99test.sh

S99 indicates the startup priority as 99, which can be adjusted by the user based on demand.

3. Power-on self-starting 4G dialing method

Previously it was mentioned that startup applications can be directly added to /etc/rc.local. However, 4G slightly differs from other applications because it uses a separate 4G module that requires initialization time. Based on practical tests, the 4G module takes 3-5 seconds after startup to function properly. Therefore, before initiating 4G dialing, a delay of 3-5 seconds is necessary. Modify as follows:

vi /etc/rc.local

Add the following:

Note: The delay time cannot be less than 3s.

▊ WiFi

1. Static IP Settings (WiFi)

WiFi login script: /usr/bin/fltest_cmd_wifi.sh

The second-to-last line of the script assigns a dynamic IP to wlan0. If there is a need to set a static IP, it can be done as follows:

2. Power-on self-starting settings (WiFi)

Also put the WiFi script in the/etc/rc.local.

In this case, it is necessary to add an ''&'' symbol at the end to run the script in the background. Otherwise, it might block and prevent access to the file system.

▊ Boot

1. SSH connection failure

(1) When SSH cannot connect, check if ping is possible. If ping fails, it could be due to network issues. The computer and the device should be on the same subnet. The default IP for eth0 is 192.168.0.232. Users can directly connect them or connect both to the same router. Then, set a 192.168.0 subnet IP on the computer;

(2) If ping is successful, first confirm whether the factory image can connect normally. If the factory image can connect normally, check what services are starting up at boot causing the issue; ensure that services starting at boot are backgrounded. Failure to do so may cause process blocking, preventing SSH login. Consider reflashing the factory image if necessary;

(3) Ensure that the board's IP address is being pinged. This can be tested by unplugging the Ethernet cable and then pinging from the computer.

Forlinx Launched FET3576 System on Module powered by the Rockchip RK3576 processor!

FET3576-C system on module(SoM) is powered by the Rockchip RK3576 processor. This high-performance, low-power, feature-rich application processor is tailored for the AIoT and industrial markets. With 4 x ARM Cortex-A72 and 4 x ARM Cortex-A53 cores, plus a built-in 6TOPS NPU, it enhances your AI applications. Featuring board-to-board connection design for easy setup, it’s rigorously tested in Forlinx’s lab for stability in industrial conditions. With a 10 to 15-year life-cycle, ensure continuous supply.

Rockchip RK3576 SoM Features:

• 8nm processing technology;

• 4x 100-pin board-to-board connectors to maximize processor performance;

• Compatible design with FET3588-C;

• Firewall supports device access control and priority management;

• H.265 decoding up to 8K resolution;

• Multiple display interfaces: HDMI/eDP, MIPI DSI, Parallel, EBC, DP;

• Supports three displays working together with different content;

• Various high-speed peripherals: PCIe 2.1, USB 3.2, CAN-FD, etc.

Product Description

The peritoneal dialysis machine is an advanced medical device designed for performing peritoneal dialysis, a treatment for acute and chronic renal failure. This process involves infusing dialysate into the patient's abdominal cavity, where the peritoneum serves as a semipermeable membrane to exchange solutes and fluids, effectively removing metabolic waste and toxins while correcting fluid and electrolyte imbalances. The device comprises a main unit, control unit, and heater, available in both powered and gravity-driven models.

This technology significantly enhances the quality of life for patients, allowing them to connect the peritoneal dialysis catheter to an automated machine before sleep. The machine performs dialysis treatments overnight, typically for 8 to 10 hours. In the morning, patients can disconnect the catheter and continue their daily activities seamlessly.

Hardware Key Components

• Central Control Unit: Manages the operation and data processing of the device. Modern systems feature intelligent controls that monitor and record real-time parameters, such as infusion volume, dwell time, drainage time, outflow volume, and dialysate temperature.
• Heater: Ensures the dialysate is warmed to the optimal temperature, improving efficiency and patient comfort.
• Power Unit: Facilitates the delivery and drainage of dialysate to and from the patient's peritoneal cavity.
• Sensors and Monitoring System: Utilizes various sensors to ensure real-time monitoring and safety of the dialysis process.
• User Interface: Provides an intuitive platform for setting parameters, monitoring status, and receiving alerts.

Main Challenges in Hardware Design

• Precise Control and Monitoring: Demands accurate control and monitoring of parameters like temperature, pressure, and flow rate, requiring high hardware accuracy and stability.
• Portability and Compact Design: Essential for home-based dialysis, necessitating a balance between size, weight, and performance.
• Safety and Reliability: Critical for medical equipment, requiring thorough consideration of electrical and mechanical safety, and prevention of cross-contamination.
• Cost-effectiveness: Balancing performance, safety, and reliability with reduced hardware costs to alleviate patient financial burdens and enhance market competitiveness.

Recommended Hardware Platform: Forlinx T113 SoM

The T113 SoM stands out as a highly competitive solution for addressing the hardware challenges of peritoneal dialysis machines. Here are five reasons for its recommendation:

• High-Performance Computing: Integrates dual-core Cortex-A7 CPU, 64-bit XuanTie C906 RISC-V DSP with clock speeds up to 1.2GHz, providing robust computing power for precise control and real-time monitoring.
• Extensive Connectivity: Offers diverse connectivity options (USB, SDIO, UART, SPI, CAN, Ethernet) for flexible data exchange and communication, enhancing compatibility and future upgrade potential.
• Multimedia Support: Capable of decoding and encoding multiple formats with various display and audio interfaces, improving the user interface and feedback experience.
• Stable and Reliable Performance: Undergoes rigorous testing for environmental stress and long-term stability, ensuring consistent operation and high patient satisfaction.
• Cost-effective: Features compact, low-power consumption design ideal for portable devices, with competitive pricing to reduce overall machine costs and ease patient financial burdens.

In conclusion, the T113 SoM's combination of high performance, rich connectivity, multimedia support, compact size, and reliable operation makes it an excellent core hardware solution for peritoneal dialysis machines. It effectively addresses the need for control, monitoring, and user experience while reducing costs and enhancing market competitiveness.

1. GPIO Wake-up

The supported system sleep modes can be viewed with cat /sys/power/state.

To achieve functionality similar to the 6ul, use the "wake-up" function in ''gpio-keys.c''. Add a GPIO node specifying the wake-up GPIO pin. During sleep, a message indicates only GPIO0 supports wake-up; testing confirmed only GPIO0 can wake up.

cat /proc/interrupts indicates that the interrupt for key1 has been successfully registered.

Testing has been conducted to verify that both freeze and mem modes can wake up.

2. Network Wake-up

Firstly, NIC support for Wake-on-LAN is required. Use the ethtool tool to check NIC information. The default setting for wake-on is ''d'', which means network wake-up is disabled. The ''supports Wake-on'' option is ''ug'', where ''u'' allows any unicast data and ''g'' allows magic packets. The wake-on can be set to ''ug'' for eth0 using the following command: ''ethtool -s eth0 wol ug''.

Test for u:

echo freeze > /sys/power/state//Enter freeze sleep mode

Waking up can be achieved by pinging the IP of this network port in any local area network.

Test for g:

ethtool -s eth0 wol g//Set wake-on to g

At this point, the ping fails, but the mac can be specified through the wol to wake up.

Testing revealed that Wake-On-LAN is only possible in freeze mode. Observations showed that after entering mem mode, the network LED does not light up; whereas, in freeze mode, the network LED continues to blink normally. This indicates that the PHY (physical layer) is not functioning in mem mode, and therefore, it cannot trigger an interrupt for wake-up.

It is also possible that this interrupt pin is connected to gpio3 _ A2.

To fully meet the growing demand in the AIoT market for high performance, robust computing power, and low power consumption, Forlinx Embedded presents the all-new FET3576-C SoM, developed based on the Rockchip RK3576 processor!

Integrated with 4 x ARM Cortex-A72 and 4 x ARM Cortex-A53 high-performance cores, featuring a built-in 6 TOPS powerful NPU, the FET3576-C SoM empowers your AI applications. With a board-to-board connection design and plug-and-play capability, it facilitates easy installation and maintenance for your products.

The product undergoes rigorous testing at Forlinx Embedded Laboratory ensuring stability and reliability for your products. With a 10-15 year life-cycle, it assures continuous supply.

FET3576-C SoM release marks a new milestone in the collaboration between Forlinx Embedded and Rockchip. As we enter the era of mobile intelligence, we are committed to working together to provide customers with excellent products and high-quality services.

01 Eight-core High-performance Chip with Advanced Video Decoding Capabilities

RK3576 is a high-performance, low-power application processor designed by Rockchip specifically for the AIoT market. It features four ARM Cortex-A72 cores and four ARM Cortex-A53 high-performance cores, along with a built-in 6TOPS powerful NPU for advanced computing tasks. Additionally, it includes an embedded 3D GPU, a dedicated 2D hardware engine with MMU, and H.265 hardware decoding, supporting up to 8K resolution for enhanced display performance.

02 Firewall Achieves True Hardware Resource Isolation

RK Firewall for managing access rights from master to slave devices and memory areas for true hardware resource isolation

03 Supercharge Your AI Applications With 6TOPS Computing Power NPU!

RK3576 processor is equipped with a powerful 6TOPS NPU, supporting INT4/INT8/INT16/FP16/BF16/TF32 operations. It can operate in dual-core collaboration or independently, facilitating multitasking and parallel processing across various scenarios. It supports multiple deep learning frameworks such as TensorFlow, Caffe, Tflite, Pytorch, Onnx NN, and Android NN.

04 Ultra-HD Display + AI Intelligent Repair

RK3576 processor supports high-definition H.264 and H.265 encoding/decoding, and features five display interfaces: HDMI/eDP, MIPI DSI, Parallel, EBC, and DP. It enables triple-display setups, 4K@120Hz Ultra HD display, and super-resolution capabilities. Intelligent image restoration enhances blurry images and improves video frame rates, meeting diverse display requirements across multiple scenarios.

05 FlexBus New Parallel Bus Interface

FlexBus features a flexible parallel bus interface capable of simulating irregular or standard protocols, supporting 2/4/8/16-bit data parallel transmission at clock speeds up to 100MHz. Additionally, it includes a rich array of bus communication interfaces such as DSMC, CAN-FD, PCIe 2.1, SATA 3.0, USB 3.2, SAI, I2C, I3C, and UART.

06 Continuously Updated User Profile

Comprehensive resources including carrier board schematics ensure simplified development and streamlined production processes for you.

07 Wide Range of Industry Applications

Forlinx Embedded FET3576-C SoM is versatile across industrial, AIoT, edge computing, and smart mobile terminals. With Forlinx's robust technical support services, accelerate your product's time-to-market and seize the lead in your industry.

 Carrier Board

OK3576-C Development Board

To minimize your development workload, we can provide starter kits that can be used as complete development platforms for evaluation and application development.

OK3576-C Single Board Computer by Forlinx is powered by Rockchip RK3576 processor, featuring 4x ARM Cortex-A72@2.3GHz + 4x Cortex-M53@2.2GHz, 2GB/4GB LPDDR4 RAM, and a 6TOPS NPU. It employs 4 100-pin board-to-board connectors to easily access all processor function pins, offering seamless functionality and ease of customization, and supports Linux...

Read more

Basic Knowledge of Video Codec Technology From Video Formats to Frame Formats

Video Package Format

MP4, AVI, and MKV are all suffixes for local video files and are used in Windows to indicate which application the operating system should use to open them. In the streaming media world, these are known as ''video encapsulation formats'' because, in addition to the audio and video streams, they also contain some ancillary information and a way of organizing the video and audio. The user experience of videos in different formats on different platforms varies largely due to the differences brought by the organization of audio and video. A video format is an identifier given to a video file by video playback software to be able to play the video file. In short, the video format specifies the communication protocol with the player.

The "video packaging format" is a "packaging" of the encoded video and audio with playback-related protocol data.

The "video protocol" is for web streaming media, and some articles will classify the "video protocol" as a "video encapsulation format". Both "video protocol" and "video encapsulation format" carry audiovisual content and metadata, as well as other information required by the protocol/format. Taking FFMpeg as an example, it does not distinguish between video formats and video protocols; however, with GStreamer, you may need to specify the "video protocol", but it does not distinguish the "video encapsulation format".

Video streaming

In terms of video streams, you must have heard terms like ''h264 stream,'' ''yuv stream,'' ''encoded stream,'' ''decoded stream,'' ''raw stream,'' ''raw stream,'' ''compressed stream,'' or ''uncompressed stream'' and so on in your daily life. In general, when mentioning "video streams," there are only two forms:

1. Encoded streams (such as h264, yuv);

2. Raw streams (whether compressed or uncompressed).

Uncompressed stream data, when decoded, is referred to as ''raw stream.'' One can imagine a video as being composed of a series of continuous ''images'' over time, and because the internal ''images'' of the video are in the ''YUV'' format, it is often also referred to as a ''YUV stream.''

Stream data that has been compressed by compression algorithms is referred to as ''encoded stream,'' and due to the prevalence of the H.264 compression/encoding algorithm, it is also commonly known as ''H.264 stream.''

Summary: "H.264 stream," "encoded stream," and "compressed stream" refer to the compressed/encoded video streams, while "YUV stream," "decoded stream," and "uncompressed stream" denote the video streams that have not been compressed/encoded. ''Raw stream'' is a term with ambiguity, dependent on context, which can refer to either the former or the latter.

In daily life, the vast majority of video files we encounter are encoded/compressed, and in network transmission scenarios, the majority are also encoded/compressed. During video playback, viewers see a decoded video stream frame by frame converted to RGB.

Encoding/compression is a very important technology in the field of streaming media: the process from an H264 bitstream to a YUV stream is called decoding, and the reverse is called encoding.

Frame format

In the field of streaming media, "streaming" is important, and the basic element of "frames" is equally important. The reason is that for video encoding/compression, its core is to encode a series of temporally continuous frame data into as small a space as possible; whereas for video decoding, it is to try to restore a series of encoded/compressed frame data to its original state as much as possible.

Coding/compression algorithms that can be recovered by 100% are called lossless compression and vice versa are called lossy compression.

"A "frame" can be associated with an "image" that we normally see, except that the images we normally encounter are in RGB format, whereas video frames are usually in YUV format.

With the maximum compression rate achieved,...

Read more

ECG monitor is a kind of medical equipment that is used to monitor and record human ECG in real-time. It can continuously observe the electrical activity of the heart through the display, providing doctors with reliable and valuable indicators of cardiac activity, thus guiding real-time management. ECG monitor has a wide range of applications in the medical field, especially for patients with abnormal ECG activity, such as acute myocardial infarction, various arrhythmias, etc., which plays an important role in auxiliary diagnosis.

Application Scenario

ECG monitor is widely used in various places of the hospital, such as ICU, CCU, operating room, ward and so on. It is suitable for critically ill patients or patients with certain risks after operation, as well as patients who need to monitor ECG signals continuously for a long time. By using an electrocardiogram monitor, doctors can promptly detect abnormalities in patients' physiological indicators, thereby taking appropriate treatment measures to ensure the patients' safety.

Features:

1. Accurate monitoring:The electrocardiogram monitor can real-time monitor the patient's cardiac signals, collect the weak signals of cardiac electrical activity through electrodes attached to the patient's body, and display them on the screen after internal circuit processing. In addition to cardiac signals, an electrocardiogram monitor can also simultaneously monitor other physiological parameters such as respiration, blood pressure, blood oxygen saturation, etc., providing doctors with comprehensive physiological information.

2. Alarm function: The electrocardiogram monitor has an alarm function, which can be set with different alarm thresholds according to the patient's condition and the doctor's requirements. When the monitored parameters exceed the set values, the monitor will emit audio and visual alarms to promptly remind medical staff to take action.

3. Data recording and analysis: The electrocardiogram monitor can automatically record the patient's cardiac data and generate electrocardiograms for analysis. Doctors can analyze the electrocardiogram to understand the patient's cardiac condition, providing a basis for subsequent diagnosis and treatment.

4. Stable operational capability: The electrocardiogram monitor can effectively shield interference factors such as electromyographic signals and electromagnetic signals, ensuring the accuracy and reliability of cardiac data. It can continuously monitor patients' physiological parameters for 24 hours, assisting doctors in promptly detecting changes in the patient's condition.

Folinx Solutions

As an important equipment in the medical field, ECG monitor plays a vital role in monitoring the physiological parameters of patients continuously, stably and accurately. In order to meet the high performance, high stability, multi-function and other requirements of modern medical ECG monitor, for product development, we recommend the embedded FETMX8MP-C SoM based on NXP i.MX8MPlus processor as the development platform of ECG monitor.

Technical Features:

• High performance: The CPU is a 1.6GHz quad-core 64-bit Cortex-A53 architecture with a Neural Processing Unit (NPU) running up to 2.3TOPS.
• Network Interface: The SoM natively supports 2 Gigabit network interfaces, which makes data transmission and interaction with external medical information systems (LIS/HIS) efficient and stable.
• Display and Expansion Interface: It also supports screen interfaces such as LVDS and HDMI, which can meet the display needs in different scenarios, such as dual-screen simultaneous display or heterodyne display, and the highest resolution of HDMI can be reached4K. In addition, communication interfaces support USB 3.0, PCIE Gen 3, SDIO, CAN FD, etc. to connect to various sensors or medical devices.
• Industrial-grade design and stability: The whole board adopts industrial-grade design and undergoes the stringent 7x24 hours continuous...

Read more

As the embedded industry continues to evolve, the need for efficient and reliable screen integration has become increasingly important. Whether you’re working with MIPI or LVDS displays, understanding the nuances of screen porting can make all the difference in delivering a seamless user experience.

In this comprehensive guide, we’ll dive into the key considerations and best practices for screen porting, covering both MIPI and LVDS transitions. By the end of this article, you’ll be equipped with the knowledge to navigate the complexities of screen integration and ensure a successful project.

MIPI Screen Porting: The Initialization Sequence Unraveled One of the most critical aspects of MIPI screen porting is the initialization sequence. Most MIPI displays require a specific set of initialization commands to function properly. Analyzing the initialization sequence provided by the screen manufacturer and translating it into the appropriate driver format is a crucial first step.

Our experts delve into the various formats of initialization sequences, guiding you through integrating them into your Uboot and kernel drivers. Understanding the structure and logic behind these sequences allows you to seamlessly port your MIPI screens, ensuring a smooth startup and optimal display performance.

Navigating the LVDS Landscape: Clocks, Registers, and Calculations LVDS screen porting presents its own set of challenges, with a focus on accurate clock configurations and intricate register settings. Whether you’re working with single-channel, dual-channel, single-hex, or dual-hex LVDS displays, the nuances of these parameters can make or break your integration efforts.

In this section, we delve into the step-by-step process of calculating the appropriate clock frequencies, modifying the necessary registers, and ensuring a successful LVDS screen porting. From the Uboot to the kernel stage, we provide you with the tools and knowledge to tackle even the most complex LVDS scenarios.

Bridging the Gap: Migrating from MIPI to LVDS For those facing the task of transitioning from MIPI to LVDS displays, this guide offers a comprehensive roadmap. We explore the Uboot-level configurations, kernel-stage modifications, and the all-important parameter adjustments required to seamlessly migrate your screen technology.

By understanding the intricacies of both MIPI and LVDS displays, you’ll be equipped to navigate the challenges of cross-platform integration, ensuring a smooth and efficient transition for your embedded system.

Embark on Your Screen Porting Journey with Confidence Mastering the art of screen porting is essential for embedded system developers who strive to deliver exceptional user experiences. This comprehensive guide equips you with the knowledge and strategies to tackle the complexities of MIPI and LVDS screen integration, empowering you to tackle even the most daunting screen porting challenges with confidence.

Ready to take your embedded system to new heights? Dive into the insights and best practices outlined in this article and revolutionize your screen porting process today.

A Comprehensive Guide to Screen Porting for the Forlinx Embedded 8M Series

Introduction:

In March of this year, I attended the Embedded World Exhibition, which focuses on embedded systems. During my visit, I explored the Forlinx booth. Forlinx is renowned for developing System on Modules (SoMs) and Evaluation Boards for industrial PCs. I previously acquired an evaluation board from Forlinx last year. This year, I am excited to present the new Forlinx OK3588-C board in this video.

Presenting the OK3588-C Development Board (featuring a Rockchip RK3588)

Today, we will explore the Forlinx OK3588-C board. Allow me to switch off the camera and transition to the desktop view.

Here, I have the hardware manual for the OK3588 board. If you require this hardware manual or the necessary SDKs to develop software for this board, please contact Forlinx, and they will provide you with the required resources.

SoM Appearance Diagram:

The evaluation board comprises two primary components. Firstly, this is the physical appearance. Here, we have the System on Module (SoM) mounted on a carrier board, which connects all peripherals to the SoM.

Let's begin by examining the System on Module. This module includes the Rockchip RK3588 main processor, two DRAM ICs, and eMMC storage for non-volatile data. Various components on the module generate the required voltages for the chip's operation. The Rockchip RK3588 is a robust processor.

RK3588 Description:

Displayed here is a block diagram of the RK3588. It features a dual-cluster core configuration. One cluster consists of a quad-core Cortex-A76 processor clocked at 2.6 GHz, and the second cluster includes a quad-core Cortex-A55 processor, clocked at either 1.5 or 1.8 GHz. This setup allows for power-saving capabilities by disabling the A76 cores when full performance is not required.

Another notable feature is the high-performance Neural Processing Unit (NPU), which is advantageous for tasks related to artificial intelligence and machine learning. In the future, I hope to demonstrate the NPU's capabilities.

The chip also includes a multimedia processor supporting various video decoders, even up to 8K resolution, and an embedded Mali-G GPU. For external memory interfaces, it has two eMMC controllers and support for LPDDR4 and LPDDR5. Additionally, it includes standard system peripherals, such as USB OTG 3.1, PCIe interfaces, Gigabit Ethernet, GPIO, SPI, and I²C.

Development Board Interface Description:

The carrier board includes numerous peripherals. There is a 12V power supply, a power switch, a reset switch, up to five camera connectors, microphone and speaker connectors, USB 2.0 host, and two USB 3.1 OTG ports. These USB ports can function as either hosts or devices. It also features two HDMI ports (one input and one output), a real-time clock with a battery, eDP ports, ADC connectors, an SD card slot, a fan connector, and M.2 slots for Wi-Fi and cellular cards.

The board also includes two full-size PCIe connectors, user buttons, CAN interfaces, an RS485 interface, a USB-to-serial adapter, and two Gigabit Ethernet ports. The overall setup is impressive.

Operation:

Let's power on the board. I have also connected a PCIe card to a free slot. Before proceeding, let's open the serial terminal to monitor the output.

The board is booting, and the kernel is starting successfully. Currently, we are running a minimal BusyBox root file system. In a future video, I will demonstrate how to build a custom Linux for this board. For now, this setup is sufficient.

We are running kernel version 5.10.66, built for ARM64 architecture. The board has eight processors, consisting of different Cortex-A cores. The available memory is 3.6 GB, with 155 MB currently in use. Background processes and the Mali GPU likely consume some memory.

We have eight I²C buses available, with one connected to the display connector for Display Data Channel (DDC) management.

The eMMC storage has multiple partitions. The board features seven...

Read more

Software version: Linux 4.19

Design Idea: Detect screen touch events to determine whether the screen is being used or not in an auto-break application. If the screen detects input events, it will remain on. If no touch events are received for a period of time, the screen will transition from on to a dimmed state, reminding the user that it is about to enter the screen-off mode. If no touch events occur after dimming, the screen will enter the screen-off mode. When a touch event occurs again, the screen will transition from screen-off mode to the on state.

Currently, the approach to implement automatic screen-off is to treat touch events as a fixed path that can be applied to familiar boards. To enhance convenience in application, two additional alternative approaches are provided below:

▊ The first implementation method

You can apply the evtest command to get the path to/dev/input/event1 (event1 is the name of the touch event on my board). You can then pass the path to your program as a parameter.

For example, you can modify your program to accept command-line arguments to specify the path of the device file to open

int argc, char *argv[];

Opens a file with the passed in parameters as the device file path

int fd = open(argv[1], O_RDONLY);

You can compile and run the program, passing it/dev/input/event1 as a command-line argument, like this:

./your_program /dev/input/event1

▊ The second implementation method is to fix the screen touch node in the device tree.

Look for the screen touch node in the device tree and note its address.

On the I2C bus, the address of the touch node is simply 2-0038

So we can use grep to filter out touch nodes based on their addresses.

ls -l /sys/class/input | grep "0038" | awk -F ' ' '{print $9}' | grep "event"

The following command is used in the application to find the touch event based on the touch address.

char *command_output = exec("ls -l /sys/class/input | grep '0038' | awk -F ' ' '{print $9}' | grep 'event'");
Use the sprintf function to splice the path containing the event, and then read the event.                         Examples of using Sprintf: int main() {
    char str[100];
    int num = 123;
float f = 3.14;
    //Write the formatted data to the string
    sprintf(str, "%d%.2f", num, f);
    //print the generated string
    printf("The output is. %s\n", str);
    return 0;
}

Some customers rely on battery power for their products and have limited battery capacity. If a screen is used in the product, the screen will be one of the main sources of energy consumption. Therefore, turning off the screen in time can effectively extend the battery life and improve the user experience. In addition, the auto-screen-off function not only extends the life of the screen but also effectively prevents the risk of information leakage and privacy exposure. Generally speaking, the automatic screen-off function plays an important role in improving the performance of the device, saving energy and protecting privacy.

Knowledge points involved:

1. Struct input _ event: a data structure used to represent Linux input event

This structure usually contains various information of the input event, such as event type, event code, value, etc. When dealing with input devices such as keyboards and mice, you can use this structure to store and pass information about input events.

Specifically, the struct input _ event structure typically contains the following fields:

• Struct timeval time: The timestamp of the event occurrence.
• Unsigned short type: The type of event (e.g., key press, release, etc.)
• Unsigned short code: Code of the event (such as which key was pressed).
• Int value: The value of the event (key press/release, etc.)

By defining such a structure, it is easy to package together the various attributes of an input event for processing and passing in the program. When reading the events of the input device, this structure can be used to store the specific information of each event, which is convenient for subsequent analysis and response to the input events.

2. Functions and differences of read function and select function

The read () function and the select () function are both functions used in Linux systems to handle I/O operations, but there are some differences in what they do and how they are used.

(1)Read () function:

The read () function is used to read data from a file descriptor, such as a file, socket, and so on.It is a blocking system call, that is, when there is no data to read, the program will be blocked until there is data to read or an error. The read () function reads data from the file descriptor into the specified buffer and returns the actual number of bytes read, or -1 if an error occurs.

(2)Select () function:

The select () function monitors multiple file descriptors to determine whether they are in a readable, writable, or abnormal state.

Through the select () function, multiplexing can be achieved, that is, one of multiple file descriptors is selected for I/O operation without blocking and waiting. The select () function blocks the process until at least one of the specified file descriptors is in a readable, writable, or exception state, or the specified timeout has passed. The select () function is usually used to listen to multiple file descriptors at the same time, so that when any file descriptor is ready, the corresponding read and write operations can be performed to improve the efficiency of the program.

In summary, the read () function is a blocking operation to read data from a single file descriptor, while the select () function is a function to multiplex the state of multiple file descriptors to help the program manage multiple I/O operations more efficiently. The select () function is typically used in situations where you need to listen to multiple file descriptors at the same time.

In the program, events are read from the input device through the read () function. If no event is reported, the read () function blocks the program and does not return until an event occurs or an error occurs. Therefore, if there is no event reported, the program will stay at the read () function and will not perform subsequent printing operations. If an event is reported, the read() function reads the event data and returns the number of bytes of the event. In this case, the program...

Read more

The research and development laboratory serves as the technological backbone and innovation engine of a high-tech enterprise, equipped with complete facilities, standardised processes, and strict standards. This guarantees the advanced functionality, stable operation, and reliable quality of products in the face of intense market competition, enabling them to stand out. Over the past eighteen years, the R&D laboratory has played a vital role in helping tens of thousands of companies get their products to market quickly, and in providing thousands of companies with a stable batch supply of boards and other products. Behind these impressive achievements is the robust support provided by the R&D laboratory.

Self-built multi-million labs, testing in line with stringent national standards

Folinx Embedded Three R&D laboratories: a Physical Environment Laboratory, an Electromagnetic Compatibility Laboratory, and a Stability Laboratory. There are total 10 major items, each designed to simulate the extreme conditions that may be encountered in real-world applications. This ensures that the product is able to perform in a wide range of complex environments.

1. Physical environment laboratory

(1) High and low temperature/temperature change/humidity test

High and low temperature test: The operating environment temperature of the equipment (product) can have a certain impact on the normal operating performance of the equipment, and in severe cases, it can lead to equipment failure or damage. High and low temperature test is to examine the adaptability of electronic and electrical products to such environmental temperatures—by simulating extreme high temperatures (up to +125°C) and low temperatures (down to -55°C), testing the product's performance under extreme temperatures.

Temperature variation test: It requires the high and low temperature test chamber. It assesses the product's ability to withstand such environmental temperature changes through one or multiple rapid temperature change tests.

Humidity Test: Changes in environmental temperature or humidity can have a certain impact on the normal operating performance of equipment. In severe cases, this can lead to equipment failure or damage. Humidity test: It examines the adaptability of electronic and electrical products to such environmental temperature and humidity changes. Humidity range is 20% ~ 98% RH.

High and Low Temperature and Humidity Test Chamber

(2) Vibration test/shock/impact test

Vibration Test is conducted to simulate the various vibration environmental impacts that the product may encounter during transportation, installation and use. The test is used to determine whether the product can withstand the vibration of various environments. The frequency range is 2-2000 Hz, with a maximum vibration acceleration of up to 981 m/s².

Shock/Impact Test is a standard method used to assess the safety, reliability and effectiveness of a product when subjected to external impact or action. This test simulates the impacts and collisions that the product may be subjected to in use. It covers half-sine, front-peak sawtooth, back-peak sawtooth, triangular, rectangular, trapezoidal, and bell-shaped waves, with a rated thrust of 10kN(1000kgf).

Vibration Test System

(3) Salt Spray Test

Some customers will use the product in a salty and humid environment, so the salt spray test is needed. The salt spray test simulates the climate environment of the ocean or salty and humid areas, and is used to examine the salt spray corrosion resistance of products, materials and their protective layers.

Salt Spray Corrosion Chamber

(4) Drop Test

To assess the resilience of a product to a fall due to careless handling during moving, Forlinx Embedded employs a drop tester to simulate the accidental dropping of a product. This verifies the structural integrity and functional retention of the product or determines the minimum level of robustness required for safety...

Read more

In modern cities, the medical rescue system is crucial for urban safety. Emergency centers command rescue operations, essential for saving lives. With the advancement of IoT technology, many cutting-edge technologies are gradually integrated into the medical emergency system, enabling ambulances to be networked, digitized, and intelligent. Thus, 5G smart ambulances emerge. 5G-enhanced ambulances look similar to regular ones in appearance. However, by integrating 5G networks into the vehicle, developers instantly endowed it with additional "superpowers".

For instance, 5G-enhanced ambulances can achieve synchronized transmission of multiple high-definition live videos, leveraging 5G's high bandwidth, low latency, and reliability. Based on this, it can synchronously return the medical images, patient signs, illness records and other information of emergency patients to the hospital emergency center without damage, which is convenient for the emergency center to grasp the patient's condition in advance and give professional guidance to the rescuers on the bus.

Forlinx's 5G Smart Gateway FCU2303 provides reliable support for medical ambulance.

Rapid transmission of information

Bridge the gap for medical device information transmission.

Modern ambulances are equipped with advanced medical equipment such as electrocardiogram monitors, ventilators, and defibrillators to enhance rescue efficiency. Various types of diagnostic and therapeutic equipment can efficiently transmit physiological data to the Hospital Information System (HIS) through the multiple Ethernet ports, serial ports, and DI/DO of the FCU2303 industrial-grade smart gateway. This meets the data collection and transmission requirements of ambulances.

Enabling high-definition audio and video consultations

Medical imaging equipment such as cameras, microphones, displays, and ultrasound machines are deployed on the ambulance. Through the FCU2303 industrial-grade smart gateway, information is transmitted, providing real-time, lossless transmission of audio-visual images from the ambulance to the hospital emergency center. This setup offers a high-bandwidth, low-latency, and highly connected secure network, meeting the remote video consultation needs of the ambulance. It aims to secure more time for patients by implementing a rapid rescue and treatment mode where patients essentially “Be in the hospital” upon boarding the ambulance.

Enabling reliable integration of multiple technologies

• FCU2303 Smart Gateway, designed based on the NXP LS1046A processor, features a quad-core CPU with a high clock frequency of 1.8GHz. With a fanless design, it ensures stable operation of medical rescue systems for extended periods in environments ranging from -40°C to +85°C;
• It supports 5G and 4G modules, which can be easily switched with a single DIP switch. It provides users with high bandwidth, low latency, and large connectivity services. It also supports dual-band Wi-Fi, enabling both STA and AP modes;
• FCU2303 supports expandable device storage with PCIe 3.0 high-speed interface, enabling support for solid-state drives (SSDs) using the NVMe protocol (M.2 interface). This meets the requirements for small size, large capacity, and fast speed;
• It comes standard with 8 x Gigabit Ethernet ports (flexible configuration of 2/4/6/8 ports, all with independent MAC addresses), 4 RS485 ports, 4 RS485/RS232 multiplexing interfaces, 2 DI (Digital Input), 2 DO (Digital Output), and 1 USB HOST 3.0 port. This ensures the connectivity of various medical devices, enabling full vehicle networking for ambulances;
• The software integrates a variety of third-party components including Samba, Lighttpd, Docker, IPSEC, OpenSSL, and Python 3 or higher versions. It supports protocols such as TCP/IP, UDP, DHCP, TFTP, FTP, Telnet, SSH, Web, HTTP, IPtables, and provides an open system API for easy user customization and development.

In the future, smart ambulances...

Read more

According to global fire statistics, about 30% of fires are caused by electrical faults, with as much as 70% of these fires being preventable and avoidable through technical means. Electrical fire monitoring systems are a technical means to detect early signs of fires such as current leakage and abnormal temperature increases. By triggering alarms promptly, they significantly reduce the probability of electrical fires occurring.

The electrical fire monitoring system is specifically designed to monitor electrical equipment and circuits in real time, aimed at preventing, detecting, and promptly responding to the fire risks caused by electrical faults. By integrating diverse sensors and advanced monitoring devices, the system continuously monitors key parameters such as current, voltage, and temperature, thereby ensuring the safe and stable operation of the electrical system.

Application Scenarios

Electrical fire monitoring system is widely used in all kinds of residential, commercial buildings and industrial facilities. As the number of modern electrical equipment increases, so does the risk of electrical fires. The system can monitor the status of electrical equipment in real-time, detect potential safety hazards in time, and effectively prevent fire accidents through the alarm and automatic control functions, thus ensuring the safety of people's lives and property.

Product Features

Real-time and Accurate Monitoring: The system can continuously monitor various parameters of electrical lines and equipment around the clock, such as current, voltage, temperature, etc., to ensure that any abnormality can be found in time.

Efficient Early Warning Response: Once a potential fire risk is detected, such as overloading, short-circuiting, or temperature abnormality, the system triggers an alarm immediately and informs the relevant personnel quickly using acoustic and visual signals or remote notification.Stable and Reliable Operation: The product is manufactured with industrial-grade design standards and high-quality materials to ensure stable operation in various harsh environments and reduce the possibility of false alarms and missed alarms.

Intelligent Data Analysis: The system provides real-time monitoring functions and collects and analyses historical data to help users identify potential problems in the electrical system, providing strong support for preventive maintenance.

Combined with the product characteristics of the electrical fire monitoring system, Forlinx Embedded recommends the FET6254-C platform as the hardware design solution for the main control unit of the electrical fire monitoring system.

FET6254-C embedded board exhibits the following significant advantages:

• Performance and Reliability: Adopts a quad-core industrial-grade processor with Arm Cortex-A53 architecture to ensure high-speed and stable operation performance.
• Interface Richness: FET6254-C provides a variety of interfaces including LVDS, Gigabit Ethernet, UART, CAN-FD, etc., which comprehensively meets the demand for hardware interfaces in the monitoring system and ensures efficient and accurate data transmission and smooth connection of devices.
• Dual-core Architecture: FET6254-C has independent M-cores and A-cores, which run without interfering with each other. The M-core is used to interface with other modules (e.g. emergency lighting, emergency alarms) to guarantee the continuous execution of critical tasks, and even if the A-core system fails, the M-core can still work normally to maintain system stability.
• Flexible Scalability: The modular design of the FET6254-C enables the system to respond easily to a variety of customized requirements and achieve flexible expansion.

In summary, the hardware solution for electrical fire monitoring systems based on the FET6254-C SoM, with its rich interface resources, high-performance processing capabilities, unique dual-core architecture, and flexible scalability,...

Read more

Purpose of Trimming

Customers sometimes have certain requirements for the boot time after power-on, so it is necessary to tailor the kernel to optimize the boot time and reduce it. Low system power consumption.

Brief Introduction to Makefiles, Kconfig and .config Files

• Makefile: A file in text form that compiles the source files
• Kconfig: A file in text for the kernel's configuration menu.
• .config: The configuration on which the kernel is compiled
• Kconfig and Makefile files are usually present in the directory structure of the Linux kernel.
• Distributed at all levels of the catalogue
• Kconfig constitutes a distributed database of kernel configurations, with each Kconfig describing the kernel associated with the source files of the directory to which it belongs.
• Configuration menu. Read out the configuration menu from Kconfig when the kernel graphically configures make menuconfig, and save it to.config after the user finishes the configuration.
• When the kernel is compiled, the main Makefile calls this.config to know how the user has configured the kernel.

Introduction to Makefile and Kconfig Syntax

● Makefile

The Makefile subdirectory is contained by the top-level Makefile. It is used to define what is compiled as a module and what is conditionally compiled.

(1) Direct compilation obj-y +=xxx.o

It means that xxx.o is compiled from xxx.c or xxx.s and compiled directly into the kernel.

(2) Conditional compilation obj-$(CONFIG_HELLO) +=xxx.o

The CONFIG_XXX of the .config file determines whether a file is compiled into the kernel or not.

(3) Module compilation obj-m +=xxx.o

It means that xxx is compiled as a module, i.e. it is compiled when make modules is executed.

● Kconfig

Each config menu item has a type definition. bool: boolean type, tristate: three states (built-in, module, remove), string: a sequence of characters, hex: hexadecimal, integer: a whole number

Function: determine the menu item displayed when make menuconfig.

1) NEW _ LEDS: The name of the configuration option. The prefix "CONFIG _" "is omitted.

2) tristate: Indicates whether the item is programmed into the kernel or into a module. The display as < >, if selected to compile as a kernel module, it will generate a configuration CONFIG_HELLO_MODULE=m in .config. Choosing Y will directly compile into the kernel, generating a configuration CONFIG_HELLO_MODULE=y in .config.

3) bool: This type can only be checked or unchecked. It is displayed as [ ] when making menuconfig, that is, it cannot be configured as a module.

4) dependon: This option depends on another option, only when the dependon is checked, the prompt message of the current configuration item will appear to set the current configuration item.

5) select: Reverse dependency, when this option is checked, the item defined after select is also checked.

6) help: help information.

tristate and bool followed by strings are the configuration item names displayed in make menuconfig.

Definitions in Kconfig like "menuconfig NEW_LEDS" or "menu "Video support for sunxi"" are typically top-level directories of a directory, where in menuconfig you can directly trim the corresponding driver by searching for that configuration item.

Catalogue Hierarchy Iteration :

In Kconfig, there are statements like "source "drivers/usb/Kconfig"" used to include (or nest) new Kconfig files, allowing each directory to manage its own configuration content without having to write all those configurations in the same file, making it easier for modification and management.

Partially Driven Tailoring

1. Tailoring Ideas

Taking the GPADC function as an example, the location of the driver in the source code kernel is:drivers/input/sensor/sunxi_gpadc.c，

So we can go to the Kconfig file in that path, and directly search for "menu” in the Kconfig file, which generally corresponds to the top-level directory of that driver.

We can see that the configuration option is named INPUT_SENSOR, corresponding...

Read more

Problems Description:

When using the Forlinx RK3588 SoM and a homemade carrier board, the system enters MaskRom mode as soon as it's powered on. The difference between the Forlinx carrier board and the homemade carrier board lies in the value of the ground capacitors in Figure 1, where one is 10uF and the other is 100nF.

Solutions:

The MaskRom mode of OK3588-C can only be pulled low to GND by the BOOT _ SARADC _ IN0 when the CPU starts to detect.

The OK3588-C development board enters MaskRom mode by tapping the BOOT _ SARADC _ IN0 to GND. As shown in the figure 1: This part of the circuit has a 100 nF capacitor C3 to ground. If this capacitor is replaced with a larger one, such as a 10 uF capacitor, it will cause the development board to enter MaskRom mode as soon as it is powered on.

Figure 1

This is because capacitors have the property of blocking direct current while allowing alternating current to pass, and they also exhibit charging and discharging characteristics. When the power is turned on, the capacitor charges instantaneously, and the voltage across the capacitor cannot change abruptly. Initially, the voltage across the capacitor is zero while it charges, and then it rises exponentially according to a certain pattern until it reaches a steady state. Entering a steady state is equivalent to an open circuit. The charging process is shown in Figure 2.

Figure 2

The charging and discharging time of a capacitor increases as its capacitance value increases. A 10uF capacitor has a longer charging time, and it enters a steady state slowly. When the OK3588-C SoM starts up, if the CPU detects that the signal level of the BOOT_SARADC_IN0 pin is within the low voltage range, it assumes that this pin is pulled to GND, thus entering MaskRom mode. The solution is to remove the 10uF capacitor or replace it with a 100nF capacitor.

Pressure displacement analyzer is a professional instrument used to measure the deformation of materials under force. It can measure the pressure, strain, displacement and other mechanical parameters of the material, and analyze and process the parameters through the built-in software system and algorithm, so as to obtain the mechanical properties of the material. Pressure and displacement analyzer is widely used in material science, machinery manufacturing, construction engineering, aerospace and other fields.

With the continuous progress of science and technology and the rapid development of industrial manufacturing, the requirements for the mechanical properties of materials in industrial production are also rising, so more accurate and reliable measuring instruments are needed to meet the demand. The emergence of stress-strain displacement analyzers fills the gap in material mechanics performance testing equipment, greatly enhancing the accuracy and efficiency of material testing.

The characteristics of stress-strain displacement analyzers to be considered during use include:

• High-precision measurement: It can measure the displacement change of the object under the action of pressure with high precision to ensure the accuracy and reliability of the measurement results；
• High reliability: It can measure stably for a long time under extreme conditions, and is suitable for various complex environments and application scenarios；
• The operation is simple, and the complex measurement task can be realized through simple operation, so that the work efficiency is improved；
• Multi-functional: It can perform various functions such as automatic recording, data processing, result analysis, and report generation to meet the needs of different application scenarios；
• Intuitive display: Pressure displacement analyzers usually have LCD displays, which can intuitively display measurement results and parameters, making it easy for users to carry out real-time monitoring and data analysis；
• Convenient data processing: Measurement data can be stored in the internal memory or external devices, and support a variety of data format export, convenient for users to carry out later data processing and analysis.

Forlinx Embedded recommends using FETMX8MM-C as the product implementation solution.
In this solution, the main functions of the i.MX8MM-C SoM are:

• The human-machine interaction module displays real-time data transmitted from the MCU via MIPI, and performs drawing and data display；
• Data processing and storage is achieved through USB interface conversion to ULPI LINK for communication with the MCU end. Data is received and stored in TF cards or USB drives, then processed to output in a more concise and understandable form；
• Network transmission and remote control are facilitated through a Gigabit Ethernet port, allowing for remote monitoring of screens, network backups, and system parameter restoration.

Advantages:

• Equipped with an ARM Cortex-A53 quad-core CPU running at 1.8GHz and paired with 2GB of DDR4 RAM, it offers high performance and computational power, providing a significant advantage in data processing；
• The compact size of only 56mm * 36mm meets the requirements of miniaturization and portability of equipment and reduces the size of products；
• Support 4-line mipi display, maximum 1.5g bps transmission, high-definition output image；
• Long supply cycle, join NXP product long-term supply plan, guarantee at least 10 years of supply period；
• The operating environment temperature ranges from -40°C to 85°C, meeting the requirements for industrial and general industrial applications.

The above is the pressure displacement curve analysis solution provided by Forlinx Embedded based on the FETMX8MM-C SoM. We hope it can assist you in your selection process.

HMI (Human-Machine Interface) is a medium for interaction and information exchange between systems and users. It is essential in fields involving human-machine communication and can be seen in many industries. As technology advances, HMI continues to evolve. In addition to data collection, control, and display, future HMI will incorporate new interactive forms to enable machines to operate more intelligently and interact more efficiently with humans.

The increasing demand for more intelligent human-machine interactions also raises higher requirements for processors used in HMI applications. To assist engineers with terminal development requirements in selecting the main controller, in this article, the author will provide a detailed explanation of the three key elements that will influence the next generation of HMI.

Smarter Interaction

AI support will help the new generation of HMI achieve more powerful functions. For example, AI face recognition can be used to realize human access to devices, and AI gesture recognition can also be used to realize contactless control between people and devices. At the same time, it also allows the equipment to monitor and analyze the current system status more accurately. For example, in the medical field, intelligent HMI systems can allow doctors to interact with medical devices through gestures.

Balance of Power Consumption And Performance

AI function support puts forward higher requirements for the performance of processors, and the high integration and performance improvement of chips will inevitably increase power consumption and generate more heat. In order for devices with limited size to be able to adapt to a more diverse and complex environment, it is very important to have multiple power consumption mode options - the freedom to choose between high power consumption, low power consumption, and ultra-low power consumption modes. This not only allows performance to be properly optimized but also helps to better control costs, achieving a balance between power consumption and performance.

Enhanced Communication Capabilities

The increase in real-time industrial communication protocols has also brought new challenges to the new generation of HMI applications. For example, the HMI applied in the smart factory not only needs to carry the task of exchanging information between people and equipment, but also needs to complete the function of communicating with other machines and equipments, which means that the HMI needs to have a stronger connection and control function.

FET6254-C SoM launched by Forlinx Embedded not only meets the traditional HMI's human-computer interaction needs but also can realize the three key elements mentioned above, empowering the new generation of HMI.

FET6254-C System on module is built on the TI Sitara™ AM6254 industrial-grade processor, featuring a quad-core Arm Cortex-A53 architecture with a maximum frequency of up to 1.4GHz. It enables edge AI capabilities, making the HMI smarter and more intelligent. During the development process, rigorous environmental temperature testing, pressure testing, and long-term stability testing were conducted to ensure that it can operate stably in harsh environments.

Not only the performance is guaranteed, but also the power consumption can be very low. Through a simplified power architecture design, the AM62x processor exhibits extremely low power consumption performance, with power as low as 5mW in deep sleep mode. With a core voltage of 0.75V, the operating power can be kept below 1.5W, greatly reducing system power consumption.

AM62x processor, as the next-generation MPU product in the TI Sitara™ product line, offers richer resource interfaces compared to the previous generation classic processor, the AM335x. It includes features such as 2 x Gigabit Ethernet with TSN support, 3 x CAN-FD, 9 x UART, 2 x USB 2.0 , 2 x LVDS interfaces, RGB, camera, audio, and more. This enhances the product's scalability...

Read more

1. Compile the fw_printenv tool

Execute under the uboot source path, and then generate the executable file of the fw _ printenv under tools/env.

. /opt/fsl-imx-x11/4.1.15-2.0.0/environment-setup-cortexa7hf-neon-poky-linux-gnueabimake env

2. Configure fw_env.config file

Modify the fw_env.config file under tools/env in the uboot source directory according to the mtd partition, the location and size of the UBOOT environment variables, etc. See the instructions in the fw_env.config file and the /tools/env/README file for specific modifications.

Among them, Device offset, Env size, and Flash sector size should correspond respectively to the three macro definitions CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, and CONFIG_ENV_SECT_SIZE in the include/configs/xxxx.h file in the U-Boot source code directory.

vi include/configs/mx6ul_14x14_evk.h

Take the test 256nand as an example:

CONFIG_ENV_OFFSET = 0x600000

ONFIG_ENV_SECT_SIZE = 0x20000

Open the tools/env/fw_env.config and modify as shown in the following figures:

Take the test 1gnand as an example:

CONFIG_ENV_OFFSET = 0x1000000

ONFIG_ENV_SECT_SIZE = 0x20000

nand model number MT29F8G08ABACA

Refer to the manual to change the ENV_SECT_SIZE value to 256K.

Open the tools/env/fw_env.config and modify as shown in the following figures:

nand model number MT29F8G08ABABA

Refer to the manual to change the ENV_SECT_SIZE value to 512K.

Open the tools/env/fw_env.config and modify as shown in the following figures:

3. Copy the file

Copy tools/env/fw_env.config to the /etc path of the development board;

Copy tools/env/fw_printenv to the root file system of the development board under the path /usr/bin.

And create a soft link to fw_setenv ln -s /usr/bin/fw_printenv /usr/bin/fw_setenv

4. Read and write environment variable test

Read environment:

Write environment variable:

The uboot phase has been modified synchronously.

5. Problems and solutions

Problem: make env reports an error in the uboot source code

Solution: Comment out the CC in the top-level Makefile and use the environment variable in the CC.

FET-MX8MP-SMARC System on Module(SoM) is developed based on the NXP i.MX 8M Plus processor, focusing on machine learning, vision, advanced multimedia, and highly reliable industrial automation. It caters to applications such as smart cities, industrial IoT, smart healthcare, and intelligent transportation.

With powerful quad-core or dual-core ARM® Cortex®-A53 reaching up to 1.6GHz and an NPU achieving 2.3 TOPS, it integrates ISP and dual camera inputs for efficient advanced vision systems. Multimedia features include video encoding (including H.265) and decoding, 3D/2D graphics acceleration, and various audio and voice functions. Real-time control is achieved through Cortex-M7, with a powerful control network using CAN-FD and dual Gigabit Ethernet, supporting Time-Sensitive Networking (TSN). 

It features high-speed communication interfaces such as 2 x USB 3.0, 1x PCIe 3.0, and 1x SDIO 3.0, meeting the requirements of 5G networks, high-definition video, dual-band WiFi, high-speed industrial Ethernet, and other applications.

• Contact for Price

FET-MX8MP-SMARC SoM

High-speed Communication Interface

4K Picture Quality and HiFi Voice Experience

HDMI interface supports up to 4K display output; it also features LVDS, MIPI-DSI display interface, the latest audio technology,
Cadence® Tensilica® HiFi 4 DSP @ 800 MHz, 18x I2S TDM, DSD512, S/PDIF Tx + Rx, 8-channel PDM microphone input, eARC, ASRC.

Advanced Multimedia Technology

3D/2D Graphic Acceleration

Machine Learning and Vision

Built-in NPU with 2.3 TOPS of AI computing power to meet lightweight edge computing needs

Dual Image Signal Processor (ISP)

Product Application

Carrier Board

OK-MX8MPQ-SMARC Development Board

To minimize your development workload, we can provide starter kits that can be used as complete development platforms for evaluation and application development.
OK-MX8MPQ-SMARC Single Board Computer from Forlinx is powered by the i.MX 8M Plus processor from NXP, featuring 4x Cortex-A53@1.6GHz + 1x Cortex-M7, 2GB/4GB LPDDR4 RAM, and 16GB/32GB eMMC ROM. With a split design and 314 pins, it offers seamless functionality and ease of customization and supports Linux 6.1.36 system. Featuring open system architecture design, it can provide technical information for your secondary development.

• GET A QUOTE
• CARRIER BOARD SPECS

Explore more about this SoM now!

1. LVDS Interface Specification

Forlinx Embedded OK6254-C development board provides 2 x 4-lane LVDS display serial interfaces supporting up to 1.19Gbps per lane; the maximum resolution supported by a single LVDS interface is WUXGA (1920 x 1200@60fps, 162MHz pixel clock).

In addition, the interface supports the following three output modes:

• (1) Single-channel LVDS output mode: at this time, only 1 x LVDS interface displays output;
• (2) 2x single-channel LVDS (copy) output mode: in this mode, 2 x LVDS display and output the same content;
• (3) Dual LVDS output mode: 8-lane data and 2-lane clock form the same display output channel.Forlinx Embedded OK6254-C development board is equipped with dual asynchronous channels (8 data, 2 clocks), supporting 1920x1200@60fps. All signals are by default compatible with Forlinx Embedded's 10.1-inch LVDS screen, with a resolution of 1280x800@60fps.

2. Output Mode Setting

(1) Single LVDS output mode:

We need a single LVDS screen cable. The black port of the cable is connected to the embedded OK6254-C development board, and the white port is connected to the embedded 10.1-inch LVDS display screen. Connection method as shown in the figure below:

Note that the red line section corresponds to the triangle position, so don't plug it in wrong.

(2) 2x single LVDS (duplicate) output mode:

This mode uses the same connections as the Single LVDS Output Mode. Two white ports link to two 10.1-inch LVDS screens from Forlinx Embedded, and a black port on the right connects to the OK6254-C board's LVDS interface for dual-screen display.

(3) Dual LVDS output mode:

The maximum resolution supported by a single LVDS interface on the OK6254-C development board is WUXGA (1920 x 1200@60fps). To achieve this high-resolution display output, dual LVDS output mode is required.

It is worth noting that the connection between the development board and the screen in this mode is the same as in [Single LVDS Output Mode], but the LVDS cable's and the screen's specifications have been improved.

3. Screen Resolution Changing Method

OK6254-C development board device tree is easy to modify, we need to open the OK6254-C-lvds.dts (single 8-way configuration) and OK6254-C-lvds-dual.dts (dual 8-way configuration) files.

Open OK6254-C-lvds.dts

Open OK6254-C-lvds-dual.dts

The above figure is the single LVDS and dual LVDS screen resolution information, the default resolution of 1024 * 600, and the maximum resolution support of 1920x1200, you can modify the corresponding parameters according to the Screen User’s Manual.

4. Compilation Configuration

Because we only modified the device tree, we don't need a full compilation. After compiling the kernel, a new Image and multiple device tree files will be generated in the images directory. Here we only need to compile the kernel separately.

• (1) Switch directory: cd OK6254-linux-sdk/
• (2) Execution environment variables:.. build.sh
• (3) Execute the instructions that compile the kernel separately: sudo./build. Sh kernel.
• (4) Pack all the device tree files to the development board /boot/ directory and replace them, then sync save and reboot scp images/OK6254-C* root@172.16.0.225:/boot/

We have modified the corresponding file. How should we select the screen after replacing it?
At present, there are three kinds of screen switching control methods: kernel device tree designation, Uboot menu dynamic control, Forlinx Desktop interface and Uboot menu application. Today, I will briefly introduce the dynamic control of Uboot menu.

During Uboot, pressing the space bar will take you to the Uboot menu. There are three options in the menu:

Enter 0 to enter the Uboot command line;

Enter 1 to restart Uboot;

Enter 2 to enter the Display Configuration menu.

There are three options in the menu:

Enter 0 to return to the previous menu;

Enter 1 will toggle what option 1 displays to configure Screen 1 LVDS; Note: Screen 1 supports single LVDS, dual LVDS, and off (i.e., LVDS...

Read more

What is AMP?

AMP (Asymmetric Multi-Processing) can be simply described as: Each core of a multi-core processor is isolated from the others, enabling them to run different operating systems or bare-metal (unmodified or native) programs relatively independently. This operational mode is particularly suitable for applications requiring high real-time performance.

FET3568-C SoM AMP

The RK3568 processor on Forlinx's FET3568-C SoM features a quad-core Cortex-A55 architecture, classified as a homogeneous multi-core design.

The main difference between the RK3568's AMP SDK and Linux SDK lies in the different multiprocessor modes they use. The Linux SDK adopts the SMP mode, where a single Linux operating system manages all cores; while the AMP SDK uses the AMP mode, which divides the cores into two parts, with one part running the Linux operating system and the other part running bare-metal programs.

The bare-metal program operating mode, due to its direct hardware access characteristics, can efficiently handle high real-time tasks, meeting the stringent requirements for real-time performance in areas such as smart grid, power grid protection, power system security control, and industrial automation.

Advantages

(1) Lower cost:

The traditional approach to address the insufficient real-time performance of Linux system control is to use an external microcontroller to specifically execute high real-time programs.

The AMP system on the FET3568-C SoM simplifies the hardware architecture and reduces the hardware cost by separating a core as a real-time core to perform high real-time tasks.

(2) High real-time performance:

Because of the low real-time nature of the Linux system, it cannot be used to perform tasks that require high real-time performance. The real-time performance of bare-metal program or real-time operating system is much better than that of Linux system, while the high frequency of FET3568-C SoM makes A55 core have powerful real-time performance when running real-time system.

Inter-core Communication

Like other processors with multi-core heterogeneous architectures, AMP uses shared memory to transfer data between the A-core (Linux) and the real-time cores (bare-metal or real-time operating system).

Through physical memory DDR allocation, the hardware layer is divided into two parts: the TXVring Buffer (Transmit Virtual Ring Buffer) and the RXVring Buffer (Receive Virtual Ring Buffer); where the real-time core sends data from the TXVring area and reads the received data from the RXVring area, and vice versa for the A-core.

Example of AMP Usage

Currently, the Forlinx Embedded FET568-C SoM has provided usage examples for GPIO, UART, and SPI interfaces, utilizing RPMSG for inter-core communication. Other interfaces are still being adapted and will be opened later. Bare metal programs can be debugged using JLINK emulation in the tools provided.

The following is a brief example of the use of the UART interface in a bare-metal application:

(1) Hardware connection

This example uses UART5 and uses a jumper cap to short TX5 to RX5 on the OK3568-C development board.

(2) Device tree configuration:

To prevent Linux from taking up the resources of UART5 and causing the real-time core to be unable to use UART5, it is necessary to first add resource protection for UART5, including clock and pinctrl, to the rockchip_amp node in the device tree.

(3) Configuration of bare metal program

Introduction to UART interface:

//Pin configuration: select the transceiver pin of UART5. /* uart5 tx */
HAL_PINCTRL_SetIOMUX(GPIO_BANK3, GPIO_PIN_C2, PIN_CONFIG_MUX_FUNC4);
/* uart5 rx */HAL_PINCTRL_SetIOMUX(GPIO_BANK3, GPIO_PIN_C3, PIN_CONFIG_MUX_FUNC4);
/* uart5 m1 */ HAL_PINCTRL_IOFuncSelForUART5(IOFUNC_SEL_M1);

//Communication configuration: Baud rate is 115 200, no check, data bit is 8, no flow control, stop bit is 1.

/* uart5 config */struct HAL_UART_CONFIG demo_uart_config = {
.baudRate = UART_BR_115200, // Baud rate
.dataBit...

Read more

The Serial Peripheral Interface (SPI) communication bus is widely used for its high speed, full-duplex, synchronous characteristics. With only four lines required for data transmission, it effectively saves the number of chip pins, while also bringing spatial optimization and convenience to PCB layout. Because of its simplicity and ease of use, more and more chips are now choosing to integrate the SPI communication protocol.

The TI AM62x processor, a new generation MPU product in the TI Sitara™ product line, features up to 4 x SPI interfaces and 1 x OSPI interface (also known as QSPI). This rich SPI interface configuration allows simultaneous communication with multiple devices, significantly enhancing system scalability and flexibility.

OK6254-C development board launched by Forlinx Embedded is equipped with the AM62x processor, and its NOR Flash memory is operated through the OSPI bus connection with the processor to fulfill its functionality.

SPI Workflow and Timing

We first need to look at how the SPI works – typically the SPI is connected to an external device via 4 pins:

• MISO: Master Device Input/Slave Device Output Pin
  This pin sends data in slave mode and receives data in master mode;
• MOSI: Master Device Output/Slave Device Input Pin
  This pin sends data in master mode and receives data in slave mode;
• CLK: serial port clock
  As the output of the master device and the input of the slave device;
• NSS: Select from Slave Device
  This is an optional pin to select the slave device.

SPI Workflow:

• The host first pulls down the NSS signal to ensure that it starts to receive data;
• When the receiving end detects the edge signal of the clock, it will immediately read the signal on the data line, thus obtaining a bit of data;
• Since the clock is sent with the data, it is not important to specify the transmission speed of the data, although the device will have the highest speed at which it can operate;
• When the master sends to the slave, the master generates the corresponding clock signal, and then the data will be sent to the slave one by one from the MOSI signal line;
• When the host receives data from the slave and requires the slave to transmit data back, the host will continuously generate a predetermined clock signal, and the slave will then send data through the MISO line.

The SPI operating timing diagram is shown below:

Features of SPI Bus in AM62x Processor

TI has designed the SPI MISO and MOSI as d0 and d1 in the AM62x chip. The setting “ti,pindir-d0-out-d1-in=” in the device tree determines which one is set as input and which one is set as output.

The default attribute value is 0, i.e., d0 is the input and d1 is the output;
When the attribute value is 1, d0 is an output and d1 is an input.

SPI Application of TI's AM62x

1. Menuconfig Configuration：

Check this item and the SPI driver will be compiled into the kernel.

makemenuconfiDeviceDrivers ->SPIsupport ->Usermode SPI device driver support(Note: SPI driver compilation is in the Folinx Embedded OK6254-C single board computer.)

2. Device tree Configuration:

(1) Select the SPI to be used, here we use spi0, and the node is & main _ spi0;

(2) Multiplex the pins used by this node to the appropriate function.

(3) Describe the attributes of the node. See the notes for the functions of specific configuration items.

3. Compile and Burn:

Enter the following command in the source path:

Compilation is successful if no error is reported.

Put the OK6254-C.dtb file in image under the source path into the /boot directory of the development board and reboot the board.

4. SPI Test：

Short circuit spi0 _ D0 and spi0 _ D1

After rebooting the development board, you see two more spidev devices in the /dev directory.

Use our test program

The following printing information indicates success.

spimode: 0
bitsper word: 8
maxspeed: 42000 Hz (42 KHz)
FFFF FF FF FF FF
4000 00 00 00 95
FFFF FF FF FF FF
FFFF FF FF FF FF
FFFF FF FF FF FF
...

Read more

As engineering vehicles become smarter, onboard dashboards and 360°surround view systems are now standard configuration. The onboard dashboard monitors vehicle status in real-time, while the 360° surround view system offers a complete view of the surroundings, helping drivers better get the vehicle’s surroundings. To meet market demand and enhance the safety performance and operational efficiency of engineering vehicles, we offer the following solutions: onboard dashboard and 360° surround view system for engineering vehicles.

Function Description:

• Real-time Monitoring: Through the onboard dashboard, drivers can instantly access the operational status of engineering vehicles, such as engine speed, vehicle speed, hydraulic oil pressure, etc. Simultaneously, the 360° surround view system can instantly collect image data of the vehicle's surrounding environment, offering a comprehensive perspective to assist drivers in better understanding their surroundings.
• Data Display and Interaction: The on-board instrument panel has a clear and intuitive interface, which can display various data and information. Drivers can interact with the instrument panel through the touch screen or other input devices to achieve information inquiry, parameter setting, and other functions.
• Remote Monitoring and Diagnosis: Through the communication module, this solution can achieve communication with the remote monitoring center, upload the vehicle operation status data and image data of the 360° Around View system, and receive remote control commands. This helps the management personnel conduct remote management of vehicles and improve operation efficiency.
• Stability and Reliability: Both the hardware and software designs of this solution possess high stability and reliability, enabling them to operate stably for a long time in complex vehicle environments without being prone to malfunctions or damage.
• Easy to Operate and Maintain: This solution offers drivers seamless usage with minimal maintenance costs.

Forlinx Embedded recommends the FETT507-C SoM as a hardware solution. Here are the optimizations and extensions of the solution:

1. Support for AHD Analog High-definition Cameras: The FETT507-C SoM integrates AHD analog high-definition camera input and adopts the MIPI_CSI solution to enable signal acquisition from four AHD analog cameras. This not only provides a comprehensive view but also assists drivers in better understanding the surroundings of the vehicle, thereby enhancing driving safety.

2. Stable CAN Data Acquisition: By utilizing a stable and mature SPI-to-CAN conversion solution, real-time vehicle operational data can be collected, providing robust support for vehicle monitoring and data analysis.

3. Flexible Expansion with Multiple Interfaces: Supporting the I2C interface allows for convenient integration of audio chips for in-vehicle audio data acquisition or connection to other external sensors. Additionally, it supports four display output interfaces including RGB, LVDS, HDMI, and CVBS, with a maximum display resolution of 4K, meeting the display needs of different sizes and resolutions.

4. Communication and Positioning Capabilities: The FETT507-C SoM integrates GPS and 4G modules to enable daily vehicle communication, remote access, and positioning functions, providing support for remote vehicle monitoring.

5. Real-time Video Stream Storage: The SoM supports external SD card connection for real-time video stream storage, facilitating easy playback and data analysis.

6. GPIO Interface and Button Functionality: The provision of GPIO interfaces caters to various physical button function requirements, facilitating user operation and control.

7. Support for Multiple Operating Systems: The FETT507-C system on module supports various operating systems, including Linux 4.9 and Android 10.0, offering users greater possibilities for...

Read more

Dust is an open source of pollution due to dust on the ground, human-driven and driven to fly into the atmosphere, and is an important part of the total ambient air. Suspended particulate matter in the ambient air lasts for a long time and can be inhaled. Once the inhalable particulate enters the human body, it will accumulate in the respiratory system and cause many diseases, which is harmful to human beings.

Dust monitoring is a real-time on-line monitoring measure to prevent and control air pollution. The dust monitoring equipment can monitor the atmospheric particulate matter concentration, PM value, temperature, humidity, wind speed, wind direction and other data in real time, and the dust pollution can be prevented and rectified in time by means of real-time data monitoring and alarm.

The online monitoring system can save a lot of manpower and material resources and provide quantitative data support for on-site treatment and administrative enforcement. After the online monitoring system is installed, continuous and uninterrupted monitoring will be carried out. It mainly monitors respirable particulate matter and is complemented by a video monitoring system, a noise monitoring system, a meteorological system, a data acquisition system, and a communication system.

The online automatic monitoring system is mainly used for online dust, environmental protection, meteorological station, tunnel and other online dust monitoring, unorganized smoke and dust pollution source emissions, residential areas, commercial areas, road traffic, construction areas, etc.; online real-time automatic monitoring of ambient air quality, and can obtain evidence through the camera. The real-time data from the weather station monitoring and the tunnel subway station can be transmitted to the data platform in time through the wired or wireless network for easy management and control.

System Components

The system consists of a data collector, a sensor, a video monitoring system (optional), a wireless transmission system, a background data processing system and an information monitoring management platform. The monitoring sub-station integrates various functions such as atmospheric PM1.0, PM2.5, PM10 monitoring, ambient temperature and humidity and wind speed and direction monitoring, noise monitoring, video surveillance (optional), etc.; the data platform is a networked platform with Internet architecture, which has the monitoring function of each sub-station and various functions such as alarm processing, recording, querying, statistics, report output, etc. of the data. The system can also be linked with various pollution control devices to achieve the purpose of automatic control.

Implementation Scheme

The online dust monitoring host can be developed using the FETMX6ULL-C SoM recommended by Forlinx Embedded.

Hardware Design: FETMX6ULL-C SoM supports 8 x RS232/RS485/TTL and multi-channel I/O interfaces, which can be connected to dust sensors and other environmental monitoring equipment. At the same time, the industrial design enables it to operate stably in harsh outdoor environment, which ensures the reliability of the monitoring system.

Network Communication: FETMX6ULL-C System on Module supports 2 x dual 100m Ethernet and standard TCP/IP and UDP protocol stacks. Monitoring data can be transmitted to the monitoring center or cloud server in real time through the network to realize remote monitoring and management.

Wireless Communication: It supports 4G and WiFi wireless communication, and after a long time of stable testing, it can ensure the stable transmission of monitoring data, and even in the absence of wired network, it can also realize the online monitoring function.

Screen Display: FETMX6ULL-C supports a variety of LCD screen designs, which enables the monitoring system to select the appropriate display screen according to actual needs, and realize the intuitive display and operation of data.

Based...

Read more

Command

1. The video recording was unsuccessful with the command ffmpeg -framerate 25 -f v4l2 -i /dev/video4 recording1.mp4 . According to the official ffmpeg documentation, -r and -framerate have the same function, but the actual test shows that they are different. -framerate is used to limit the input while -r is used to limit the output

2. Video can be recorded with the command ffmpeg -r 25 -f v4l2 -i /dev/video4 recording1.mp4 , but problems such as frame error and frame repetition will occur.

3. Use ffmpeg -f v4l2 -r 25 -thread_queue_size 128 -i /dev/video4 -vcodec libx264 -b:v 800k-preset ultrafast recording1.mp4 to achieve dual camera video recording at the same time.

Parameter Description:

⚫ -f Set the output format, the output format is v412 frame
(The commands found earlier all use the framework avfoundation, a full-featured framework for handling multimedia data on iOS, macOS, watchOS, and tvOS. The v412 framework used in this command is a framework for video device drivers in the Linux kernel, which provides a unified interface to the application layer and supports flexible expansion of various complex hardware).

⚫ -r Set frame rate, set frame rate to 25fbs.

⚫ -thread_queue_size
(The thread _ queue _ size is applied to the first input specified after it. The term "thread_queue_size" can be applied to all inputs and determines at the application level. How many packets from that input can be queued while waiting for ffmpeg to receive and process them on its main thread. A few capture devices, primarily dshow, use "rtbufsize" to store incoming frames while waiting for them to be transferred to the application-level queue for that input. These two options do not adjust the value of the other, so they should be set manually. The default is 8. Common Warnings: Thread message queue blocking; consider raising the thread_queue_size option (current value: 8). To solve this problem, the official explanation: This option sets the maximum number of packets queued when reading from a file or device. (In low-latency/high-rate real-time streams, packets may be dropped if they are not read in a timely manner; increasing this value prevents this.)

⚫ -i Set input stream, set input from video4

⚫ -vcodec Set the video encoder，（-vcodec and-codec:v equal in value）

Encoders are library files that implement a certain encoding format. Encoding and decoding of video/audio in a certain format can only be achieved if an encoder for that format is installed.

Here are some of FFmpeg's built-in video encoders.

• libx264: The most popular open source H.264 encoder
• NVENC: NVIDIA GPU-based H.264 encoder
• libx265: Open source HEVC encoder
• libvpx: Google's VP8 and VP9 encoders
• libaom:AV1 Encoder

⚫ -B:v Video bit rate

⚫ -preset specifies the output video quality, which will affect the file generation speed. The following values are available:

Ultrafast,superfast,veryfast,faster,fast,medium,slow,slower,veryslow,placebo from fast to slow, the ultrafast transcoding rate is the fastest, and the video is often the most blurred.

⚫ recording1.mp4 Name and file type of the output videoYou can use ffmpeg-formats to get all the file types supported by ffmpeg, where the annotation before the file is as follows:

D.=Demuxing supported（Support for video/audio encapsulation）
.E=Muxing supported（Support decapsulation of video/audio）

Method：

Software:

⚫ Ubuntu：

1.Devepoment board networking

2. sudo apt-gat update upgrades apt-gat to the latest version (optional)

3. sudo apt-get install ffmpeg uses apt-gat to obtain ffmpeg

4. Enter relevant commands

Hardware:

Connect the Forlinx self-made analog camera module to support two cameras. Video4-7 are nodes generated by the TVIN, with the upper left corresponding to video7, lower left corresponding to video6, lower right corresponding to video5, and upper right corresponding to video4....

Read more

Taking the FETMX6ULL-C platform as an example, if you want to use VPN, you need to open the tun configuration in the kernel in the following way:

Kernel Compilation

Choose either of the two methods below:

1. Modify the.config file directly

Locate the.config file in the kernel source path.

Find the CONFIG _ TUN in the file and modify it as follows:

Replace the kernel's config file with .config.

* Subject to actual use.

Recompile the kernel.

2. Configure the TUN using the graphical configuration interface

Make menuconfig.

Locate the following locations:

Save and exit after modification, which can be seen in.config

Replace the kernel's config file with .config.

* Subject to actual use.

Recompile the kernel.

Update kernel:

The arch/arm/boot/zImage file is generated after compilation, and the kernel can be replaced either by updating the kernel separately or by re-burning it.

Use this file to replace the file with the same name in the target path of the flashing tool.

Refer to the single-step kernel update chapter of the FETmx6ull-c User's Manual to replace the zImage file separately.

Compilation module:

In the kernel source code, some of the drivers are compiled in the form of modules, which are loaded from the specified path by the kernel version number when the system boots. When we recompile the kernel and update the kernel, the kernel version number in the system will be changed, the kernel version number can be viewed through the uname -r command. When you update the kernel, the uname -r version number changes, but the version number in the path where the module is stored (/lib/modules/) does not change. It may cause the module to fail to load, typically after updating the kernel, WiFi cannot be used.

As seen below, the name under uanme -r and the name under /lib/modules/ are not the same, so you can't load the module when you go to the/lib/modules/$(uname -r) directory when booting up, and you need to change both names to be the same.

You can solve this problem in two ways:

1. Modify the module load path and change to the version number of the kernel;

2. Repackage modules;

The first method has two disadvantages:

a. Not suitable for batch modification;

b. Not suitable for changing the module driver;

So it is possible to repackage the module when compiling the kernel:

After executing the above operation, .tmp/root/modules.tar.bz2 will be generated, which can replace the file with the same name under the target path in the flashing tool.

It is also extracted directly in the file system:

Edge Computing Access Screen is designed to provide an edge computing-based solution for access control systems. It can realize face recognition, data processing, fingerprint recognition and other functions, and improve the security and convenience of the access control system. In terms of application scenarios, intelligent monitoring and access control system is an important part of intelligent building security. The application of edge computing technology can increase the monitoring effect and response speed, avoid the security risks in the process of data transmission, and protect the privacy of users. Edge computing devices can process authentication faster and improve the response speed and security of access control systems.

Hardware requirements for edge computing access control screen

(1) Processor

Select a high-performance and low-power embedded processor, the processor itself needs to come with arithmetic power to meet the needs of edge computing.

(2) Memory

Configure appropriate memory and flash for system and application data.

(3) Interface

Provide necessary interfaces between the carrier board and other devices, such as GPIO, UART, I2C, SPI, etc.

(4) Communication module

Support Wi-Fi or 4G to facilitate data transmission with the cloud platform.

(5) Sensor

Integrate multiple sensors, such as face recognition, fingerprint recognition, and RF card reader.

Edge Computing Access Control Screen Design

The FET3568-C SoM is recommended to be used as the hardware platform of edge computing access control screen. The system on module has a quad-core ARM Cortex-A55 processor with a main frequency of 2.0 GHz, and its own NPU has a computing power of 1TOPS, which can meet the needs of lightweight edge computing tasks.

• Memory: FET3568-C SoM supports LPDDR4 and eMMC storage, and can be configured with appropriate memory and flash memory to meet the needs of the access control system.
• Interface: Native GPIO, UART, I2C, SPI, Gigabit port, etc. can communicate with other lines.
• Communication module: FET3568-C supports wireless communication technologies such as Wi-Fi, Bluetooth, and GPS. The appropriate communication module can be selected according to the requirements.
• Sensors: FET3568-C supports multiple sensor interfaces, such as GPIO, I2C, SPI, etc., and can easily integrate multiple sensors, including face recognition, fingerprint recognition modules, etc.
• Power supply module: According to the requirements of the access control system, the appropriate power supply chip can be selected to provide stable and reliable power supply for the entire carrier board.
• Peripheral expansion: USB and SD card slots are convenient for secondary development and function expansion.

Originally published at www.forlinx.net.

Overview Description

In modern urban public transport, bus scanning and swiping machines are a convenient and fast payment method that allows passengers to pay their fares more conveniently and quickly, avoiding the problem of finding change as well as the time and security problems associated with cash transactions; it can automatically calculate fares and facilitate statistics and analysis of data, which largely improves the efficiency of bus operation and management; the device not only provides passengers with convenient and efficient bus payment and information services but also enhances the experience of public transportation services.

The intelligent bus card reader is equipped with a universal NFC card reader module and an embedded QR code scanner, which can be compatible with the recognition of both public transportation IC card payments and QR code scanning for payment. The system has an open interface for secondary development and docking. Passengers can use smart cards for payment, mobile NFC payment, and QR code scanning payment. It can have an embedded PSAM card slot and can be compatible with universal transit cards, UnionPay, credit cards, and other payment methods, making it a vehicle terminal that supports all payment methods and can be applied globally.

What is even more remarkable is that it comes with a high-definition facial recognition camera, which enables in-vehicle mobile facial payment functionality. In particular, with the trend towards autonomous buses in the future, multi-functional vehicle terminals can also be effectively utilized.

Features:

Two-dimensional code scanning: Support a variety of common two-dimensional code formats.Credit card payment: Support multiple payment methods such as bus card, bank card, IC card, NFC, etc.

Information display: Provide high-definition display screen, real-time display of the welcome message, ticket price, deduction status, etc.

Audio prompt: Built-in speaker supporting functions such as payment success notification.

Data statistics: Payment data can be uploaded to achieve real-time statistics and analysis of data, providing a basis for the optimisation of the public transport system.

Remote Positioning: Support remote GPS positioning.

Main Functional Interface Programme:

Integrated Barcode/IC Card Scanner for Buses Based on FET113i-S - Overall Solution Recommendation:

• FET113i-S SoM is developed based on the industrial-grade processor Allwinner T113-i, with a main frequency of 1.2GHz, equipped with a multi-core and multi-architecture design: integrating dual-core Cortex-A7 CPU, 64-bit XuanTie C906 RISC-V CPU, and DSP;
• On-board 256MB + 256MB and 512MB + 8GB configurations to meet product planning options;
• Support a variety of peripheral interfaces: USB, CAN, I2S, GPIO, UART, SPI; can connect camera module, card module, speaker, 4G/5G, GPS, etc.;
• Powerful multimedia audio and video processing capabilities support a variety of display interfaces, including RGB, MIPI-DSI, LVDS interfaces, support H.265 (4K@ 30fps), MPEG-4 (1080p @ 60fps), JPEG (1080p @ 60fps) and other full-format decoding. JPEG/MJPEG (1080p @ 60fps) format encoding; supports 8-bit parallel CSI, CVBS video input, CVBS, RGB, 2-channel LVDS, 4-channel MIPI DSI video output; also suitable for audio-related applications through DSP support.

Due to individual differences in oral structure, some traditional oral dental films are difficult to fully adapt to the special conditions of the patient's mouth and may require multiple adjustments and break-ins, and traditional mass production methods cannot meet the demand for personalized dental films. The traditional approach relies heavily on mold production, but this makes it difficult to respond to the needs of individual patient variability.

Manufacturing methods usually require a long production cycle, with patients needing to obtain, fit, and adjust the model throughout multiple visits, which increases the time cost of the entire process, and a cumbersome fabrication process that involves multiple processes, including model acquisition, plaster model fabrication, and dental film fitting, which makes the entire fabrication process more costly, including material and labor costs.

Meeting the personalized and customized needs of dental health-care is the basis of dental film manufacturing, which happens to be a perfect match for the technical characteristics of 3D printing, thus creating a rapid growth of the dental 3D printing market, as well as fierce competition.

A good 3D printing device must have a convenient and user-friendly human-machine interface that allows doctors or technicians to easily operate and monitor the printer status.

Not only that but also a wealth of peripheral interfaces, such as USB, RS232/485, CAN, I2C, etc., can fully meet the needs of a variety of external devices and sensors, etc., to set aside enough scalability.

To meet the hardware requirements of the main control board for dental and dental 3D printers, Flying Embedded has introduced the FET3568-C platform, which has a rich set of peripheral interfaces including USB, RS232/485, CAN, I2C, etc., and provides powerful connectivity for dental and dental 3D printers. At the same time, the chip platform reserves enough scalability to meet the needs of external devices and sensors, and provides flexible expansion space for the functions of dental equipment.

Details of the scheme for realizing the 3D printer in the stomatology department:

• ARM architecture processor: FET3568-C is based on Rockchip's RK3568 core processor, providing powerful computing capabilities and low power consumption design, suitable for efficient control of oral and dental 3D printers.
• Motion control and sensor interfaces: The abundant peripheral interfaces of RK3568 chip are used to connect stepper motors, temperature sensors and so on, to realize motion control and real-time monitoring of system status.
• HMI: Equipped with a 7-inch or 10.1-inch high-resolution capacitive touch screen, it provides a convenient and friendly user interaction interface. The touch screen is designed according to the current user's operating habits, making the operation more intuitive and easy to use.
• 4K display support: Additional interfaces support 4K display, such as HDMI and eDP, for external high-resolution display devices. This ensures clarity and precision of the print control operation.
• Optical connection: Integrated external optical interface for print control to ensure accuracy and efficiency of dental and dental 3D printers.
• Network connection and communication interface: The network function of FET3568-C platform is used to realize the remote monitoring and upgrading of equipment. At the same time, other devices and sensors are connected through USB, RS232/485, CAN and other interfaces.

Summary:

The FET3568-C-based dental and dental 3D printer implementation takes full advantage of the platform's powerful performance and rich peripheral interfaces. The optimization of the human-machine interface, the support of a 4K display, and the connection of multiple sensors ensure efficient, convenient, and precise operation of the equipment, providing advanced digital solutions in the field of oral dentistry.

Against the backdrop of rapid development in communication and networking technologies, smart factories are gradually achieving data-driven, networked, and intelligent management. In this trend, the utilization of the Industrial IoT has become an indispensable key step in achieving industrial data collection and control.

Traditional industrial data collection and control systems typically require connection to multiple data collection devices, perform high-speed communication, handle complex data processing, and achieve high-definition multimedia display functions. The embedded system based on ARM+FPGA architecture has rich peripheral interfaces, high-definition display high-speed transmission, and other functions, which are more capable of high-speed industrial data acquisition tasks. The flexibility and performance of this embedded system make it an ideal choice to meet the needs of smart factories, which can effectively improve the efficiency and accuracy of industrial data processing.

In the industrial data acquisition and control system, high-speed data acquisition system and embedded human-computer interaction system cooperate closely to build an intelligent industrial management system. The main task of the high-speed data acquisition system is to collect the key data in the industrial production process in real time and ensure the accuracy and timeliness of the data. This involves high-speed communication with multiple data acquisition devices, as well as sophisticated data processing and multimedia display capabilities.

As the main control center, the embedded human-computer interaction system coordinates and manages each module and resource, and is responsible for receiving the data from the FPGA terminal. It not only visualizes the data to the user, but also achieves more flexible control through human-computer interaction. The system also realizes the connection with the industrial MES + ERP system through the communication module, and transmits the collected data to the cloud for storage. This design not only improves the efficiency of data processing, but also greatly reduces the risk of manual data entry, and realizes the intelligent management of industrial data.

The whole system architecture provides a more comprehensive and efficient data management solution for enterprises. This not only helps to reduce human errors in the production process, but also makes better use of human resources and improves production efficiency. With the continuous development of communication and network technology, such industrial data acquisition and control system will become an important support for industrial intelligence in the future.

The main control device of the industrial data acquisition control system can adopt Forlinx Embedded FET6254-C SoM, which is based on TI's AM62x series industrial processor design, with the main frequency up to 1.4GHz, is a multi-core heterogeneous processor, adopting the Cortex-A53+Cortex-M4F combination of processing core + control core architecture; the functional safety features can be realised by the M4F core and its dedicated peripherals, and the startup and operation of the M4F core no longer depend on the A53 core. The M4F core and its dedicated peripherals enable functional safety features, and the M4F core is no longer dependent on the A53 core for startup and operation.

It can provide excellent data processing capability and human-computer interaction experience, and can control the motor drive module in real time to meet the requirements of data processing, task scheduling and human-computer interaction of the real-time control system.

It support parallel bus support for ARM high-speed communication with the FPGA to provide access. FET6254-C supports TI processor-specific general-purpose memory controller interface GPMC, high data read and write rate of up to 100MB / s, support for multiple chip selection, the configuration is more flexible, and at the same...

Read more

The FET113i-S SoM is developed and designed based on Allwinner T113-i industry processor, with a main frequency of 1.2GHz. It is equipped with multi-core and multi-architecture: integrated dual-core Cortex-A7,CPU64-bit XuanTie C906RISC-VCPU and DSP, which not only provides efficient computing power, but also has rich multimedia functions and complete interface resources; stamp hole design makes product more durable, and the development board draws out as much processor core resources as possible, which is a cost-effective choice for key areas such as industry, power, transportation and so on!

This article will briefly share the process of adapting Forlinx T113i-S development board to LVDS screen display.

Development platform: Forlinx T113i-S development board

To modify the T113i screen, you need to modify the kernel and uboot respectively. Take the LVDS 1024 * 600 screen as an example.

1. Enter the following path;

2. Open OK113I-C-Linux.dts;

3. Modify the resolution parameters as shown in the figure below (for specific parameters, please refer to the screen manual of the screen you are using):

4. Save and exit after modification, and then start to modify uboot and enter the following path;

5. Open display-menu.c;

6. Modify the resolution parameters as shown in the figure below:

7. After modification, compile uboot under the initial path of the source code;

8. Complete compilation after successful compilation./build. Sh.;

9. After successful execution. /build.sh, pack image burned to the board to observe the phenomenon.

Our above parameter modification can be successfully adapted to a new display, of course, the specific operation of different master control platform boards will be different, but the overall idea is the same, specific can be based on the corresponding platform to view the relevant information to determine the specific steps.

More info

An intelligent service robot is a robot that integrates advanced technologies such as artificial intelligence, perception technology, and machine learning. Its purpose is to provide a variety of services and support to meet the needs of people in daily life, business, and industrial fields. These robots can sense the environment, understand speech and images, perform tasks, and interact naturally and intelligently with human users.

Areas of Application:

Business Services: It includes services such as reception, shopping assistance, and information inquiry, and can be used in places such as shopping malls, hotels, and exhibitions.

Health Care: It provides services such as drug delivery, patient companionship and health monitoring for hospitals and nursing homes.

Educational Assistance: It is used in educational scenarios to provide auxiliary teaching, answering questions and other services.

Family Services: Provide cleaning, handling, home control and other services to improve the quality of life.

The hardware structure of the service robot includes several key components. The functions and roles of these hardware components are as follows:

Controls: As the core of the robot, the control device is responsible for receiving and processing the data provided by the sensors, executing the corresponding algorithms, and issuing instructions to the driving device to achieve the various functions of the robot. High-performance, low-power ARM chips are often chosen for the control unit, ensuring that the robot has sufficient computational and storage capacity.

Drive unit: This includes motors and drivers, which are used to execute the motion and action commands of the robot. The motor is responsible for providing power, while the driver converts electronic signals into mechanical motion. This part is the motion system of the robot, which determines the execution of actions such as walking, turning, and the mechanical arm.

Camera: As the ''eyes'' of the robot, the camera is used to capture images and facial information of the external environment. These image data can be used for tasks such as environmental perception, navigation, target recognition, allowing the robot to better understand and adapt to the surrounding environment.

Sensors: Sensors provide the robot with various perceptual abilities, including vision, touch, hearing, and distance sensing, among others. Angle sensors and current sensors reflect the robot's own state, while temperature sensors, laser sensors, ultrasonic sensors, infrared sensors, etc. are used to collect external environmental information, allowing the robot to perceive and understand the surrounding situation more comprehensively.

Display and Audio: As an important part of human-computer interaction, display and audio devices realize the presentation and interaction of user interface. The touch display provides an intuitive graphical user interface, while the voice interaction system enables the robot to understand the user's instructions and respond accordingly, thus better communicating with the human user.

Folinx Embedded has launched the FET3588J-C SoM as the main control platform for this intelligent inspection robot product to meet customers' needs for machine vision and high-speed interfaces.

FET3588J-C SoM is developed and designed based on Rockchip's RK3588 processor, integrating Cortex-A74-core-6 + 4-core Cortex-A55 architecture. The main frequency of A76 core is up to 2.4GHz, and the main frequency of A55 core is up to 1.8GHz, which can efficiently process the information collected by patrol inspection;

The built-in NPU with comprehensive computing power of up to 6 TOPS greatly improves the calculation speed and energy efficiency of neural networks, providing robots with powerful AI learning and edge computing capabilities, enabling them to intelligently adapt to different work scenarios.

RK3588J supports a 48-megapixel...

Read more

After checking the schematic of the OK1028A-C and the "QorIQ LS1028A Reference Manual", it is found that there are 8 FlexTimers (FTM) available by defaultLS1028on the board, with each FTM having 8 pwm channels.

The default backlight uses the pwm generated by FTM1, and we use FTM7 to do the pwm test.

As shown in the figure below:

LS1028 RCWSR12 registers 12-14 are pin multiplexed for I2C4.

As shown in the figure below:

The I2C4 pin can be multiplexed into six pin functions. The OK1028A-C sets the pins to rx and tx of can2 , you can see T6_CAN2_RX, U7_CAN2_TX in the schematic "OK1028A-C_V1.1".

We can set I2C4 to the pwm pin by modifying the rcw file.

OK1028A-C supports the pwm function by default, so we do not need to transplant the driver. All we need to do is to modify the pinmux and add the corresponding device node of pwm in the device tree. Modify packages/firmware

In the /rcw/ls1028ardb/RSQPP0x85bb/rcw1500gpu600.rcw file, the setting for IIC4_PMUX is to configure the pin as a pwm output.

Change IIC4 _ PMUX = 2 to IIC4 _ PMUX = 4

As shown in the figure below:

After completing the above settings, we need to modify the device tree code and add pwm configuration. The path of our modified file is as follows:

packages/linux/linux/arch/arm64/boot/dts/freescale/fsl-ls1028a.dtsi.

Then add the pwm7 device

Pwm7: pwm@2860000 {
                        compatible = "fsl,ls1028a-ftm-pwm";
                        reg =;
                        #pwm-cells =;
                        clock-names = "ftm_sys";
                        clocks = <&ftm_sysclk>;
                };

As shown in the figure below:

▐   Start the OK1028A-C system

root@forlinx:~#cat /sys/kernel/debug/pwm View our current pwm devices

As shown in the figure below:

We have now opened a pwm controller and can see that FTM1 supports 8 channels, with the backlight using pwm channel 1. Compile the modified device tree file and firmware, burn them intoFolinx EmbeddedLS1028A-CDevelopment Board, and boot up the system.

root@forlinx:~#cat /sys/kernel/debug/pwm View our current pwm devices.

As shown in the figure below:

At this time, although the pwm device we added is turned on, it is still different from the pwm0 device. Each channel of the newly added pwm device has no set period and duty cycle.

So in the next step, we do not need to add driver code, but use sys to set pwm parameters directly. Pwmchip8 is the pwm device we added.

▐  Enable pwm channel used

root@forlinx:~#echo 1 > /sys/class/pwm/pwmchip8/export Initialize pwm channel 1

root@forlinx:~#echo 2 > /sys/class/pwm/pwmchip8/export Initialize pwm channel 2

root@forlinx:~#cat /sys/kernel/debug/pwm CommandCheck out our current pwm devices:

If you want to cancel the corresponding pwm channel, you can use "echo 1 > /sys/class/pwm/pwmchip8/unexport".

“echo 2 > /sys/class/pwm/pwmchip8/unexport” command.

Since we can only enable pwm one way at a time, configure and turn on pwm1 first.

root@forlinx:~#echo 1000000 > /sys/class/pwm/pwmchip8/pwm1/period Configure the pwm1 period to be 1000000 in ns, which is 1kHZ.

root@forlinx:~#echo 500000 > /sys/class/pwm/pwmchip8/pwm1/duty_cycle Configure the duty_cycle to 500000, the on time in a cycle is the duty cycle,...

Read more

Install Wire Guard in the RK3588 Forlinx Desktop image

Solution: Mount the Forlinx Desktop image file into the development environment for installation.

(1) Download qemu-user-static in the development environment

sudo apt-get install qemu-user-static

(2) Mount the img image of Forlinx Desktop to a directory, I have mounted it to the test directory.

sudo mount focal-rootfs.img test/

(3) Use the chroot command to enter the test directory

sudo chroot test/

(4) Install WireGuard

apt-get install wireguard-dkms wireguard-tools wireguard

Solutions that cannot be used after installation:

To add the TUN and WireGuard options to the kernel, proceed as follows:

1. Modify the build. Sh in the SDK to add the $KMAKE menu config;

2. Execute. /build.sh, search for TUN and wireguard in the graphical configuration interface and check them off;

Save and Exit.

3. Overwrite OK3588-Linux _ defconfig with.config

cp kernel/.config kernel/arch/arm64/configs/OK3588-Linux_defconfig;

4. Re-flash the image;

5. Set the IP.

Forklift is an indispensable equipment in modern industrial production and logistics transportation, but at the same time, it is also a mechanical equipment with certain risks. If operated improperly or managed poorly, it can easily lead to safety accidents, causing injuries and property losses. Therefore, improving the safety awareness and management level of forklift drivers is of great significance in ensuring the safety and smooth operation of enterprise production and logistics transportation.

In the safety protection and protective devices, it is stated that forklifts must be equipped with a driver authorization information collector. This collector is used to bind the driver's personal identity information with biometric information such as fingerprints, iris, facial features, or magnetic cards. The forklift can only be started after the driver's permission is verified.

The forklift facial recognition driver authorization collector is primarily used for driver permission management. With high-precision cameras and facial recognition algorithms, this system can accurately identify and determine the driver’s identity information. It helps ensure that only authorized individuals can operate the forklift, improving safety and security in the workplace.

Only drivers who have undergone professional training and obtained authorization will have their information entered into the system and be granted permission to operate the forklift. Once the system detects an unauthorized person attempting to operate the forklift, it immediately triggers an alarm and takes measures to prevent the forklift from starting, ensuring the safety of operations.

The forklift facial recognition driver authorization collector has the following notable features:

• Facial recognition: By using cameras to capture facial information, it can accurately identify the facial features of drivers in a short period of time with high precision, without the need for manual intervention, greatly improving management efficiency.
• Security: The system is designed with high security in mind. It effectively prevents others from impersonating drivers and provides dual protection for forklift operations.
• Integration: The system can not only operate independently but also seamlessly integrate with other security devices, access control systems, etc., forming a comprehensive security management system to further enhance safety.
• Scalability: The system supports the integration of finger print recognition and card recognition systems, allowing for the expansion of corresponding functions based on specific needs.

The overall solution for the forklift driver authorization collector based on FET3568J-C system on module is as follows:

FET3568J-C industrial-grade SoM is provided by Forlinx Embedded, which serves as the core of the forklift driver authorization collector. It features a four-core 64-bit Cortex-A55 architecture with a high frequency of up to 1.8GHz, providing powerful performance support. Additionally, it is equipped with a built-in NPU with 1TOPS computational power, meeting the requirements for lightweight edge AI computing.

The SoM has advantages such as high performance, low power consumption, and low cost.

Forlinx RK3568J industrial-grade SoM provides abundant interface resources, making it easy to connect with external modules.

• Supports DVP, MIPI-CSI, USB, and network camera interfaces.
• Supports RGB, LVDS, HDMI4, MIPI, and eDP display interfaces, making it convenient to connect external displays for facial recognition and comparison display.
• Supports 2*1000M Ethernet ports, WiFi, 4G, and 5G interfaces, enabling remote monitoring, control, and data transmission functionalities.
• Supports 3*CAN bus interfaces, allowing the collector to communicate with the forklift system through CAN bus interfaces to obtain vehicle status and driver information.
• Supports GPIO interfaces, allowing connection and control of other devices on the forklift through GPIO...

Read more

The default display orientation for the Android interface on the Forlinx Embedded i.MX8MP platform is landscape, but some products may require a portrait display. To address this requirement, Forlinx Embedded provides the following methods for modification:

The Android system controls the screen orientation through the persist.vendor.orientation property, which can have values of 0, 90, 180, or 270.

Configuration path: frameworks/native/services/su**ceflinger/Su**ceFlinger.cpp

Modify in processDisplayHotplugEventsLocked:

Su**ceFlinger::processDisplayHotplugEventsLocked() {
             continue;
         }
+       /* Rotate desktop */
+       char rotationvalue[PROPERTY_VALUE_MAX] = "";;
+       property_get("persist.vendor.orientation", rotationvalue, "-1");
+       int rotation = atoi(rotationvalue);
+       ALOGI("Primary Display Orientation is set to rotation %2d.", rotation);
+       switch (rotation) {
+               case 0:
+                       internalDisplayOrientation = ui::ROTATION_0;
+                       break;
+               case 90:
+                       internalDisplayOrientation = ui::ROTATION_90;
+                       break;
+               case 180:
+                       internalDisplayOrientation = ui::ROTATION_180;
+                       break;
+               case 270:
+                       internalDisplayOrientation = ui::ROTATION_270;
+                       break;
+               default:
+                       break;
+       }
+ const DisplayId displayId = info->id;
         const auto it = mPhysicalDisplayTokens.find(displayId);

After modification, you need to add the relevant configuration in the environment variable.

Path: device/nxp/imx8m/evk_8mp/system.prop

persist.sys.timezone=Asia/Shanghai
persist.sys.language=zh
persist.sys.country=CN +persist.vendor.orientation=90

Rotate 90 degrees here to write 90, 180 degrees to write 180, 270 degrees to write 270.

If you encounter a failure to set the value of a property:

Add the followings in device/nxp/imx8m/sepolicy/property_contexts;

+persist.vendor.orientation     u:object_r:debug_prop:s0
vendor.wc_transport.                u:object_r:vendor_wc_prop:s0
...

Read more

A blood cell analyzer is one of the widely used instruments in clinical laboratory testing in hospitals. It classifies white blood cells, red blood cells, and platelets in the blood using the resistance method. It can also provide data related to blood such as hemoglobin concentration and hematocrit. In clinical applications, it can be used for white blood cell counting, neutrophil counting, lymphocyte counting, red blood cell counting, and other clinical tests. It is an important reference for doctors to diagnose patients' conditions.

Function requirements

• Detection parameters: The instrument should be able to detect common blood parameters including red blood cells, white blood cells, platelets, hemoglobin, and white blood cell differentials.
• Sample handling: The instrument should be capable of automated sample loading, sample distribution, cleaning, and waste disposal.
• Accuracy: The instrument should have high measurement accuracy and repeatability to meet clinical diagnostic requirements.
• Usability: The instrument should have a user-friendly interface that is easy to operate, allowing laboratory personnel to use it with ease.
• Data analysis: The instrument should have the capability to automatically generate test reports and perform basic data analysis based on the test results.

Hardware design requirements

• Controller: A high-performance microprocessor is used as the main controller of the instrument, which is responsible for realizing various control logic and data processing.
• Power supply module: Use a stable power supply module to ensure consistent instrument performance in various environmental conditions.
• Detection Module: According to the blood indexes to be detected, design the corresponding detection module, such as optical detection module, electrical detection module, etc.
• Detection Module: According to the blood indexes to be detected, design the corresponding detection module, such as optical detection module, electrical detection module, etc.
• Human-computer interaction: Use a touch screen as the operation interface, which is convenient for laboratory staff to use. At the same time, it has a printing function, which can print out the test results.
• Data storage: Data can be stored through built-in memory chip and SD card.

Design scheme

For the functional characteristics of the blood analyzer, Forlinx Embedded recommends the FETMX8MM-C system on module as the hardware development platform, which is equipped with ARM Cortex-A53*4+ARM Cortex-M4 processor with 1.8GHz main frequency. It supports LPDDR4 and eMMC storage to configure the appropriate memory and flash on demand.

i.MX8MM SoM With multiple interfaces:

• It includes display interface, supports external screens of various specifications and sizes, and is compatible with resistive capacitive touch, providing excellent human-computer interaction experience.
• USB interface is convenient to connect external devices, such as U disk, mouse, WiFi, 4G, printer, etc.
• The network interface includes 10/100/1000M Ethernet, 4G module and WiFi module to realize efficient communication with hospital HIS and laboratory information system LIS.
• The SPI bus is used to extend the FPGA to support various applications such as motor control, gate valve control, and AD sampling.
• The serial port is used to communicate and control with the bar code machine, the lower electromechanical structure and other equipment.
• For external storage, TF and SD cards are supported for storing computing data, analyzing results, and so on.

The FETMX8MM-C Core board has a wide range of applications in the medical field, providing high-performance and multi-functional processing power for medical devices, and helping to realize a smarter and more convenient medical information system.

System sleep and wake-up technology is the key technology in power management. It allows the system to minimize power consumption when idle, putting external devices, the chip's internal IP, and the clock into a low-power state or a completely power-off state to greatly extend battery life. Additionally, when needed by the user, the system can quickly restore the power, clock, working state of the internal IP of the chip, and external devices, ensuring that the user’s experience is not disrupted.

The embedded OK113i-S development board supports two sleep modes: freeze and mem. These two methods can be operated through the/sys/power/state file node, and the user can trigger the corresponding sleep state by writing freeze or mem to the file node.

Before hibernation, the system configures the wake up source. Once the system enters the sleep state, it can be awakened by these wake-up sources, such as keys, RTC, etc., when needed. This design allows users to choose when and how to wake up the system quickly according to their needs, achieving a balance between power consumption minimization and fast recovery. This mechanism enables the system to greatly reduce power consumption in the sleep state, while retaining the convenience of the user to use the system quickly after waking up.

This article will introduce how to put the embedded OK113i-S development board into sleep mode, and how to achieve timed wake-up through the RTC clock.

01 Two Sleep Modes

freeze

Freezing I/O devices, placing them in a low-power state, allows the processor to enter an idle state, resulting in the fastest wake-up time but higher power consumption compared to other methods. Based on the test results with the OK113i-S development board powered only through the serial port, it was found that the current is approximately 0.112A at 5V.

mem

Suspend to the memory. The computer stores the current running state and other data in the memory, closes the hard disk, peripherals and other devices, and enters the waiting state. At this time, the memory still needs power to maintain its data, but the whole machine consumes very little power. When the computer resumes from a suspended state, it reads the data stored in memory and restores itself to the exact state it was in before it was suspended.

This allows for a faster recovery time compared to a full system startup. The measured OK113i-S development board is powered by 5V when only the serial port line is connected, and the current is about 0.076 A.

1. cat /sys/power/state to see what modes are supported by the OK113i-S development board:

2. echo freeze > /sys/power/state Enter freeze mode:

3. echo mem > /sys/power/state Enter mem mode:

02 Timed wake-up via RTC

Note: Internal RTC is required here. The external RTC does not support wake-up function. We will mention this later.

Enter the kernel configuration of the development board:

root@ubuntu: /home/forlinx/work/linux/OK113i-linux-sdk# ./build.sh menuconfig

Select the function according to the box in the following figure:

After the configuration is completed, save it, and then modify the device tree file to open the internal RTC function.

Compile after saving:

After the compilation is successful, it is packaged into an image. After the programming is completed, we test it at the serial port terminal.

Enter the serial port terminal for test:

echo “+15”> /sys/class/rtc/rtc0/wakealarm

You can use this 15-second timer by setting the desired time. Once the timer is set, it will begin counting down and the Real-Time Clock (RTC) will keep track of the time. If the device goes into hibernation mode within the 15-second timer window, it will not trigger the wake-up (Note that the internal RTC is required here, and the external RTC does not support wake-up)

echo mem > /sys/power/state

(The input of the two instructions here should be compact. If the interval between the two instructions is too...

Read more

With advantages such as modularity, high efficiency, and easy deployment, fully intelligent picking robots have been applied to agricultural fields. From pinpointing to harvesting, from cutting to collecting, it can cover the entire process of agricultural crop picking.

The operational target of agricultural robots is crops, and the characteristics of crops impose higher requirements on the movements of agricultural robots. The end effector of the agricultural robot needs to have flexible handling capabilities when in contact with the operational target. This emphasizes the importance of stability, accuracy, agility, and lightweight in the application of agricultural robots.

Agricultural Robots Main features:

Intelligent navigation: Agricultural harvesting robots are equipped with advanced navigation systems, allowing them to autonomously navigate in farmland, achieve precise positioning, and avoid colliding with obstacles.

Visual perception: Equipped with machine vision system, it can identify the maturity of fruits or vegetables, realize intelligent identification and positioning, and ensure accurate picking operation.

Flexible arm: Equipped with a mechanical arm with multiple degrees of freedom, it can flexibly adapt to fruits of different shapes and sizes to achieve efficient and accurate picking.

Data acquisition: Agricultural picking robot can collect real-time data in farmland, such as soil moisture, plant growth status, etc., which provides a scientific basis for agricultural management.

Automatic charging: Equipped with intelligent charging system, when the power is low, it can automatically return to the charging station, reduce manual intervention and improve operation efficiency.

With the rapid development of agricultural science and technology, the introduction of agricultural picking robots is pushing agricultural production towards a more intelligent and efficient direction. The FETMX8MP-C CPU board is recommended to be used as the main control scheme of the agricultural picking robot. The advantages of the platform are as follows:

• High performance, the CPU uses 1.6GHz quad-core 64-bit Cortex-A53 architecture, which provides the robot with efficient processing capability, enabling it to analyze the data collected in the farmland in real time；
• Built-in powerful neural processing unit (NPU), with a maximum running rate of 2.3 TOPS,provides powerful artificial intelligence computing power for robots;
• Abundant high-speed interface resources: It has two Gigabit Ethernet ports, two USB 3.0/2.0 interfaces, PCIe Gen 3, SDIO 3.0 interface and CAN interface (including one CAN-FD) to meet the high-speed connection needs of various sensors and communication devices, so that the robot can achieve intelligent visual perception and positioning, and improve the accuracy and efficiency of picking;
• All-weather work, the full industrial design ensures the stable operation of the robot in a variety of complex environments, and realizes the agricultural production service of the weather.

With the powerful performance of NXP i.MX8MP processor, agricultural picking robots will continue to evolve in the future to better adapt to the diversity and complexity of agricultural production. This combination will promote the development of modern agriculture in a more intelligent and digital direction, and improve the efficiency and sustainability of agricultural production.

OK7110-C RISC-V Single Board Computer(SBC) adopts a “carrier board + SoM” structural design. The SoM adopts FET7110-C of the JH7110 processor, which is designed and developed by StarFive Technology. OK7110-C development board adopts the open-source RISC-V architecture, with a frequency of 1.5GHz, and integrates the quad-core RISC-V architecture.

The JH7110 RISC-V chip has been mass-produced, featuring high performance, multi-function, and low power consumption, providing powerful GPU processing capability, supporting multi-video coding and decoding, and supporting 2xPCIe 2.0, 2xGigabit Ethernet and 2xCAN 2.0. The SoM supports Linux 5.15.0 operating system, which is suitable for the development of industrial vision-related applications.

Introducing the OK7110-C RISC-V Single Board Computer(SBC)/Development Board - Your Gateway to Enhanced Connectivity and Innovation. With versatile peripheral interfaces including HDMI, MIPI-DSI, camera, Ethernet, USB3.0, PCIe2.0, UART, RS485, CAN2.0, SPI, audio, TF card slot, 4G/5G, and more, this board empowers you to unleash the full potential of your projects. Experience seamless integration, high-speed data transfer, and reliable communication, all in one compact and powerful development board.

• Product Brief

Equipped with High-performance RISC-V Processor JH7110

JH7110 is a high-performance RISC-V SoC launched by StarFive Technology, which has been mass-produced in 2022 and is built for the embedded industry.
It features efficient computing, high-speed connectivity, and visual processing capabilities, meeting the requirements of industrial scenarios.

High-performance Quad-core 1.5 GHz MPU

JH7110 is equipped with a 64-bit high-performance quad-core RISC-V processor core.
The stable operating frequency of the CPU is 1.5 GHz, the CoreMark score is 5.09 CoreMark/MHz, and the performance is better than Cortex-A55.

Powerful GPU Rendering Capabilities

JH7110 GPU uses IMG BXE-4-32 MC1 architecture to provide strong processing power.

It operates at a frequency of 600MHz and supports mainstream APIs such as OpenCL 3.0, OpenGL ES 3.2, and Vulkan 1.2.

It provides sufficient computing power support for computer vision, in-depth learning, graphics rendering, and other applications.

Dynamic Power Control Matching Different Application Scenarios

JH7110 is divided into 8 independently switchable power domains. The CPU frequency can be adjusted via software, allowing customers to dynamically adjust the frequency
based on application scenarios and achieve power consumption control.

Outstanding Multimedia Processing Capabilities

JH7110 provides MIPI-CSI and DVP camera access modes, supports ISP, and supports up to 4K @ 60fps video decoding and 1080p @ 30fps video encoding.
It supports HDMI (4K @ 30fps), RGB (1080p @ 30fps) and MIPI-DSI (2K @ 30fps) display output interfaces, and can also realize dual-screen display.

Rich Interfaces for Wider Applications

More info about RISC-V Single Board Computer

Elevators, as special equipment, belong to traditional industries. But with the development of emerging technologies such as IoT, 5G, and artificial intelligence, many industries are undergoing revolutionary changes.

In addition, the digitalization and intelligent construction management needs of urbanization in recent years have also led to continuous changes in elevator manufacturing, production, and maintenance. The digitization of elevator information management, real-time monitoring, fault prediction, emergency rescue, and maintenance management have become new demands.

The development of elevator IoT technology provides a foundation for the implementation of smart elevators. Emergency rescue, diagnosis of elevator safety hazards, fault prediction, and on-demand maintenance all rely on elevator IoT. As the foundation and key component of elevator IoT, the IoT gateway is responsible for establishing a bridge between the elevator control system and remote server data exchange.

The richness of the elevator IoT gateway interfaces, efficiency and capabilities of edge computing, ease of use, universality, as well as maintenance and management convenience determine the level of data collection and transmission in elevator IoT.

The elevator IoT gateway is mainly used for real-time monitoring and displaying the elevator's operational status. It collects relevant data about elevator operation through various high-precision sensors built into it. The gateway then uses a microprocessor to analyze abnormal data and transmits the data through methods such as 3G, 4G, GPRS, Ethernet, RS232/RS485, and USB.

The comprehensive elevator management platform, hosted on the cloud platform, handles functions such as elevator fault alarms, trapped passenger rescues, daily management, quality assessment, hazard prevention, and multimedia transmission.

Elevator IoT Features:

The gateway is able to collect signals of elevator going up and down, stopping, leveling, door opening and closing, current floor, elevator speed, and single trip distance.

• It can monitor elevator fault information in real-time, such as entrapments, elevator jamming, abnormal door operations, and over-speeding or bottoming out.
• It can store various operational data, fault data, and elevator maintenance work information.
• It can transmit real-time operational data of elevators through 4G wireless network to the elevator operation real-time monitoring platform, and can also simultaneously report to the cloud platform.

FETMX6ULL-S SoM Solution Recommendation:

To achieve stability and high efficiency, Forlinx Embedded recommends using FETMX6ULL-S industrial SoM as the core solution of elevator IoT gateway. The SoM adopts NXP Cortex-A7 800MHz master, and comes standard with EMC and high and low temperature, which keeps the quality of hardware and system in all cool conditions.

FETMX6ULL-S industrial SoM Main features

• The FETMX6ULL-S SoM is based on NXP's ARM Cortex-A7 architecture i.MX6ULL low-power processor design, running at 800MHz. The SoM is designed with stamp holes, and the unique power management architecture makes the SoM consume less power.
• Rich Interfaces:
  Support 8 x UART and communicate with multiple serial devices at the same time;
  Support 2 x Ethernet to realize dual network redundancy;
  Support 2 x USB;
• Rich peripheral modules, supporting WiFi, Bluetooth, 4G and other modules.
• It adopts the 4.1.15 operating system, supports OTG, SD/TF card batch burning mode, and supports single-step kernel update, making it convenient for process development and bulk production.
• The SoM has a compact size of only 44*35mm, with an 8-layer PCB featuring immersion gold process. It is equipped with industrial-grade components and has a wide operating temperature range of -40°C to +85°C, ensuring stable operation of the product in harsh environments.

Integrating the FETMX6ULL-S industrial-grade SoM with elevator IoT technology...

Read more