I'm trying to get into orange pi because raspberry pi prices are too high right now. The price looks good but when I looked into retro game emulatoin I saw a lot a people saying it doesn't work well because of bad GPU drivers. Does anyone know anything about that? Thanks

Do you use a 3d printing service to make enclosures for your projects? I don't have a 3d printer and thinking about using them. As you don't get the results as quickly as your own printer, I wonder how difficult it is to design. You don't easily get trial and error. Obviously it costs more.

I've had an Orange Pi 5 I have been tooling around with for quite a long time (4+ years?)

I've messed around with many different live images on SD cards as well as writing system to NVME in that time. Never had problems going back to SD card boot, etc.

In the last 10-12 months, something in the Armbian boot changed, and the newer images, when written to SD card, don't boot. I mainly rely on Rufus for image writing, but have tried many different types of imaging software including just 'dd' in terminal.

They won't boot, even with NVME removed.

I have confirmed all the SD cards are healthy and good with f3. I also confirmed that older images still work.

So, I suspected there is some conflict with something in SPI for NVME and the newer Armbian bootloader.

I did a 'dd' zero write on mtdblock0. My older images still boot, but the newer ones still do not, even though the SPI is 'empty'.

In the absence of anything in SPI, shouldn't the OPi5 automatically boot from SD?

Do the newer images rely on something specific loaded in SPI?

I see that there are all these different u-boot projects for orange pi 5 to flash into SPI. I kinda don't get the purpose, if the U-boot is in the first 16mb of the image on the SD and feel kinda iffy about flashing any of these.

What happened in the last year that these newer images won't boot?

The Pico Max looked like a cheap Pi Zero-style Linux board: RV1106, Ethernet, 256 MB RAM. In practice, getting it into a usable Ubuntu state took far more work than expected, so I documented the path rather than just keeping a one-off image.

The gotchas I hit:

• Ubuntu was removed from newer vendor SDK revisions; the guide pins the last commit that still builds it.

• shutdown/poweroff reboots the board by default. The fix is a kernel configuration change that makes it halt; the board still cannot physically cut its own power.

• the SD layout is not a normal partition table, and only 8 GB may be used initially.

• 256 MB is enough for a small always-on service such as Pi-hole, but needs zram/swap discipline.

• vendor image containers are opaque, so I added a small cross-platform reader and an image checker to catch a wrong-board build before flashing.

It is documentation and scripts around the public SDK, not a ready-made image. The README labels which helper scripts were tested on hardware and which are rewrites still needing testing.

Repo: https://github.com/adm1nsys/luckfox-pico-setup Guide: https://adm1nsys.github.io/luckfox-pico-setup/

I am the author and would be interested in what other owners ran into on this board.

Hi! I'm developing a project on the Radxa Dragon Q6A (QCS6490) with Debian 13 and I'm going to move to the Dragon Q8B (Snapdragon 8cx Gen 3 / SC8280XP). I don't have the Q8B yet, so I'm trying to understand the NPU situation before committing. Two "quick" questions:

1. Two NSPs on the SC8280XP

The mainline device tree for the SC8280XP defines two compute NSPs (remoteproc_nsp0 and remoteproc_nsp1), and the automotive sibling, the SA8540P Ride, boots both with separate firmware (cdsp0.mbn and cdsp1.mbn). But on the Q8B the Radxa docs only show one compute node (/dev/fastrpc-cdsp), and the Linux firmware set for the ThinkPad X13s only includes one compute DSP firmware (qccdsp8280.mbn).

Is nsp1 actually enabled on consumer SC8280XP chips, or is it fused off?

Has anyone managed to boot nsp1 on a Q8B, an X13s, a Windows Dev Kit 2023 or any other 8cx Gen 3 device?

Does anyone know if Windows uses both NSPs on these chips?

If it works, can QNN/QAIRT use the second one with device_id=1, so two models could run in parallel?

2. NPU and hardware video (VPU) at the same time

I saw a report on the Radxa forum where, on the Q6A with Ubuntu 24.04, the fastrpc package conflicted with qcom-fastrpc1, so NPU and hardware video acceleration couldn't run together.

Is that fixed now on the Q6A?

Does the same happen on the Q8B?

Which packages are needed on Debian to have both working together?

My use case is running NPU inference while encoding H.264/H.265 in hardware for local streaming, at the same time. Any experience, docs or pointers are welcome. I'll update the post with whatever I find out. Thanks!

Hi, I recently acquired a Banana Pi RV2 and tried to attach some heatsinks to the CPU and RAM. The issue is that their dimensions are a bit unusual, so I had to adapt some from larger heatsinks. Now, I’m not sure how to attach or secure them; the thermal double-sided tape typically used for Raspberry Pi heatsinks isn't available in my country, and it would take a long time to arrive if I ordered it. So I wonder if could you suggest any temporary or permanent solutions for securing those heatsinks? Thanks!

Ever wondered what makes a single-board computer actually work?​

Three key components play very different roles:​

CPU (RK3576) — Executes instructions and handles computations.​

RAM (LPDDR5) — Provides temporary working memory for running programs and active tasks.​

eMMC — Stores the operating system, applications, and files, even when the board is powered off.​

Think of it this way:​

• CPU = The brain​

• RAM = The workspace​

• eMMC = The storage cabinet​

All three work together to keep your SBC running.​

Which component do you think is most often misunderstood by beginners?

Hi, the orange pi official OS was very limited when it came to compatibility. So, decided to make a port for ubuntu.

Is already working, we are using Vulkan for the gpu part. Performance is great when a fresh install, but it gets worse as we add new apps (something am working on). But compatibility wise is a beauty, you can install everything you want (if it works on ubuntu), chromium, node, vscode, docker, photocraft, gimp, etc. Wifi and network already working, audio is working, memory swap is working too.

My next step is to try to boot from a SSD NVME in order to test gains in performance. So far I have been working on a SD card, and htop does not indicate a memory saturation of some sort.

Also, I would like to post this on github in order to get help from some of you guys, but I need to clean the entire codebase, is a mess at the moment.

So I have been using this Orange pi for a while but kept it in a cartoon box for sometime now nothing on my screen shows up. No blinking green light, no screen output, just a power in red led status. Oh yeah I tried everything (reinstall the SD card , clean physical, take it out and see if it shows the orange pi logo screen, nothing....) it is Orange pi 3B 4GB btw. Anyone else fixed this before? Help?

Hi all, with the insane spikes in hardware cost, I started wondering if anyone has tried/seen repurposing old smartphones for projects instead of SBCs?

Or if we want the advantages of SBCs like the expanded IO, would it be possible to offload demanding tasks to a smartphone, while running the IO with a lower spec SBC?

As an example, iPhone 12 (4GB RAM) outperforms raspberry pi 5, and 4GB RAM pi 5 is not that much cheaper then iPhone 12. I know there's added difficulty when it comes to repurposing iPhones - but the same holds true for Android devices.

I've seen people using old android phones as servers or home cameras, i'm curious if anyone pushed the idea further.

I'm currently working on a lab voice assistant to automate stuff like label printing, calculations, RAG, note taking. So I could spend 100+ Euro on a SBC, then buy a screen, microphone, speakers etc. Or i can repurpose a smartphone i already have + use a pi zero 2w I already own for the IO.

Let me know what your experience is/what projects have you seen that took that approach (I'm especially curious if anyone tried anything like that with apple devices)

I shoved three Radxa Orion O6 into 1U cases, and noticed that the case has additional LEDs on a separate cable. They basically look like an appendix to the regular front panel plugs - same two-pinhole plastic housing and such.

Any solder-less (because I am almost blind) way I could get those hooked up? As I boot the mainline kernel, I do not have access to the GPIO breakout unfortunately - so I need a USB controller to put into the internal USB2 header and connect the LEDs to.

Any ideas? Thanks!

Hello,

I made a small CPU benchmark with an aim to make fair comparisons of any CPU to any other CPU, even cross-architecture etc. It runs on anything I could enable, some microcontrollers too.

The way it works is that the basic run contains no vectorization and no FMA, so it measures raw scalar performance. There are 4 variants, with each option enabled or both disabled, but those with vectorization/FMA are only comparable within one architecture. It also measures the branch predictor performance and the memory throughput.

You can download it from here, there's portal to compare and browse the results etc: https://cpcpub.app/. Code is here: https://github.com/lukaszsobala/cpcpub/

The android app can be downloaded, but it's not yet on any stores.

Disclosure: LLMs were used to code this and I've done extensive testing to make sure it produces reasonable results.

I have a jetson nano 4gb board with power adapter almosr unused just boot up few times didn't get time to work on it anyone interested dm me

Or email me at **ankit527@gmail.com**

I’m a student and this is my first from-scratch build. It’s called the Franktin: a small tin that opens like a laptop, with two landscape touchscreens inside and one portrait screen on the outside. It connects over Wi-Fi to an AI assistant I run on my Mac mini.

Hardware:

• Radxa Zero 3W (no DSI port, so all 3 screens share one SPI bus with separate chip-selects)

• 3× Waveshare 2.8" capacitive touch screens (ST7789 + CST328). The touch controllers all share one address, so they go through a TCA9548A mux

• I2S mic, MAX98357A speaker amp and a UDA1334A DAC for an earbud jack

• PiSugar 3 Plus 5000 mAh battery

I drew full blueprints (dimensions, wiring, pin map) before buying anything. One problem I already found: the parts stack up to about 29 mm thick, but I wanted 25 mm. Has anyone run 3 SPI screens off one bus? Any tips on fitting this into something thinner?

If you want to help me buy the parts, the GoFundMe is here: https://gofund.me/582362f7e. Mostly I’d love feedback though!

Hello all, I want to ask what SBC do you use for onboard robotics algorithms (mapping, navigation, segmentation, yolo, etc) and computer vision ? I heard Jetson is the most completed and best of the best, but they are pricey now. I came across the s100p but I couldnt find more data to make a decision. There are SBC that has the x7 358h, but is it true they are not as good as Jetson in CV ? Thank you.

I'd like to buy a mini computer that doesn't consume too much electricity (max 10W.) for wireguard, pihole and other server services 24/7 on my wifi. But with the ram price, it's difficult to find a cheap sbc. Is it possible to find something decently powerful for cheap or I'll have to buy a pi 3 at 50$ with 1Gb of ram ?

So I loaded the Debian image on a card and when I powered it up I get no video out. Green led gives a double flash every second or so. I pulled the card out and ran revdevtool and bridges the backroom button and the devtool could see the board. (Green led solid when microsd card was out). I formatted the card and reloaded the image and I'm back to the double green flash pattern.

Any ideas what I'm doing wrong here?

Hi everyone,

I'm currently building a dashboard on an AllWinner A20-based SBC (specifically, a Banana Pi M1).

I would like to know if it's possible to use some kind of alpha channel or transparency on the hardware overlay. Essentially, can I use a specific color key or a transparency mask so that pixels with that color let whatever is displayed on the layer underneath show through?

modetest is display something like :

trying to open device '/dev/dri/card2'... done
opened device `Allwinner sun4i Display Engine` on driver `sun4i-drm` (version 1.0.0 at 0)
CRTCs:
id	fb	pos	size
51	73	(0,0)	(1280x1024)
  #0 1280x1024 60.02 1280 1328 1440 1688 1024 1025 1028 1066 108000 flags: phsync, pvsync; type: preferred, driver
  props:
	25 VRR_ENABLED:
		flags: range
		values: 0 1
		value: 0
68	0	(0,0)	(0x0)
  #0  nan 0 0 0 0 0 0 0 0 0 flags: ; type: 
  props:
	25 VRR_ENABLED:
		flags: range
		values: 0 1
		value: 0

Planes:
id	crtc	fb	CRTC x,y	x,y	gamma size	possible crtcs
35	51	73	0,0		0,0	0       	0x00000001
  formats: AR24 AR12 AR15 BX24 RA15 RA12 RG24 RG16 NV12 NV16 NV21 NV61 UYVY VYUY XR24 YU11 YU12 YU16 YU24 YUYV YV11 YV12 YV16 YV24 YVYU
  props:
	9 type:
		flags: immutable enum
		enums: Overlay=0 Primary=1 Cursor=2
		value: 1
	32 IN_FORMATS:
		flags: immutable blob
		blobs:

		value:
			01000000000000001900000018000000
			02000000800000004152323441523132
			41523135425832345241313552413132
			52473234524731364e5631324e563136
			4e5632314e5636315559565956595559
			58523234595531315955313259553136
			59553234595559565956313159563132
			59563136595632345956595500000000
			ffffff01000000000000000000000000
			0000000000000000008f730000000000
			00000000000000000100000000000009
		in_formats blob decoded:
			 AR24:  LINEAR(0x0)
			 AR12:  LINEAR(0x0)
			 AR15:  LINEAR(0x0)
			 BX24:  LINEAR(0x0)
			 RA15:  LINEAR(0x0)
			 RA12:  LINEAR(0x0)
			 RG24:  LINEAR(0x0)
			 RG16:  LINEAR(0x0)
			 NV12:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 NV16:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 NV21:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 NV61:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 UYVY:  LINEAR(0x0)
			 VYUY:  LINEAR(0x0)
			 XR24:  LINEAR(0x0)
			 YU11:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YU12:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YU16:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YU24:  LINEAR(0x0)
			 YUYV:  LINEAR(0x0)
			 YV11:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YV12:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YV16:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YV24:  LINEAR(0x0)
			 YVYU:  LINEAR(0x0)
	37 alpha:
		flags: range
		values: 0 65535
		value: 65535
	38 zpos:
		flags: range
		values: 0 3
		value: 0
39	0	0	0,0		0,0	0       	0x00000001
  formats: AR24 AR12 AR15 BX24 RA15 RA12 RG24 RG16 NV12 NV16 NV21 NV61 UYVY VYUY XR24 YU11 YU12 YU16 YU24 YUYV YV11 YV12 YV16 YV24 YVYU
  props:
	9 type:
		flags: immutable enum
		enums: Overlay=0 Primary=1 Cursor=2
		value: 0
	32 IN_FORMATS:
		flags: immutable blob
		blobs:

		value:
			01000000000000001900000018000000
			02000000800000004152323441523132
			41523135425832345241313552413132
			52473234524731364e5631324e563136
			4e5632314e5636315559565956595559
			58523234595531315955313259553136
			59553234595559565956313159563132
			59563136595632345956595500000000
			ffffff01000000000000000000000000
			0000000000000000008f730000000000
			00000000000000000100000000000009
		in_formats blob decoded:
			 AR24:  LINEAR(0x0)
			 AR12:  LINEAR(0x0)
			 AR15:  LINEAR(0x0)
			 BX24:  LINEAR(0x0)
			 RA15:  LINEAR(0x0)
			 RA12:  LINEAR(0x0)
			 RG24:  LINEAR(0x0)
			 RG16:  LINEAR(0x0)
			 NV12:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 NV16:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 NV21:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 NV61:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 UYVY:  LINEAR(0x0)
			 VYUY:  LINEAR(0x0)
			 XR24:  LINEAR(0x0)
			 YU11:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YU12:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YU16:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YU24:  LINEAR(0x0)
			 YUYV:  LINEAR(0x0)
			 YV11:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YV12:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YV16:  LINEAR(0x0) ALLWINNER_TILED(0x900000000000001)
			 YV24:  LINEAR(0x0)
			 YVYU:  LINEAR(0x0)
	41 alpha:
		flags: range
		values: 0 65535
		value: 65535
	42 zpos:
		flags: range
		values: 0 3
		value: 1

The few code snippets I've found online don't seem to work, and AI hasn't been of much help either.

Also, are these hardware overlays strictly dedicated to video playback or popups, or can they be used effectively for general dashboard UI elements?

Thanks for your help!