1. A Review of the HP Elitedesk 705 G4 Mini Pc (Raspberry Pi Killer With a Caveat)

    Fri 31 May 2024

    The HP Elitedesk G4 705 is mini PC is part of the tinyminimicro home lab 'revolution' started by servethehome.com about five years ago.

    This revolution consists of Lenovo (tiny), HP (mini) and Dell (micro) computers and is based on the realisation that these small computers are often a much better value-for-money1 than a Raspberry Pi.

    Elitedesk 705 G4

    Click on the image for detailed specifications

    This particular computer, the Elitedesk G4 705 has an AMD Ryzen 3 PRO 2200GE quad-core processor, with a single-core performance almost double the performance of a Raspberry Pi 52.

    I got my unit3 with 16 GB RAM for €115 ($124) including taxes and shipping. The Raspberry Pi 5 with (max) 8 GB of RAM costs 91 Euro, almost exactly the same price as this computer without the 8 GB RAM upgrade. Yet, with the Pi, you still need:

    1. power supply (€13)
    2. case (€11)
    3. SD card or NVME SSD (€10-€45)
    4. NVME hat (€15) (optional but would be more comparable)

    Meanwhile my particular Elitedesk came with a Samsung-based 256GB NVME drive that's €40+ new and comparing it with an SD card doesn't make any sense, the included Samsung SSD is multiple orders of magnitude faster in every conceivable metric4.

    Why this CPU?

    The Intel Core i5-6500T is a populair processor for these mini PCs, it's an affordable quad-core CPU that's slightly faster than the AMD Ryzen PRO 3 2200GE in my unit (also quad-core). I noticed that the Intel i5-6500T-based mini PCs with similar storage and RAM capacity sold for around €160. Thats around 40% more expensive. This is why I think the configuration with this AMD processor is a better value-for-money over i5-6500T-based systems.

    There is a reason to spend the extra money on the i5-6500T: it supports Quick Sync which accelerates video transcoding. This is ideal for media player and streaming applications and it's well-supported. Although hardware-accelerated transcoding may work fine with the AMD 2200GE, I've no experience with it.

    The Caveat

    The CPU fan is noisy.

    The particular unit I got has a fan that is audible at idle. It doesn't seem like a defective fan to me, although it could be a bit worn-down as it's second-hand. I'm unlucky as the fan noise resonates with the top half of the case, which can only be alleviated by putting a bit of weight on top. I'm very sensitive to fan noise and I would never tollerate this machine on my desk next to me.

    Under heavy load, the fan is very, very loud.

    However, when you do home lab work, it's often not about sustained CPU usage. It's more about executing some commands of workflows that result in brief bursts of CPU usage and in that case, the fan won't spin up that much.

    Power consumption (down the rabbit hole)

    I measured around 11 Watts idle power consumption running a preinstalled Windows 11. After installing Debian 12 the system used 18 Watts at idle and so began a journey of many hours trying to solve this problem.

    The culprit is the integrated Radeon Vega GPU. To solve the problem you have to:

    1. Configure the 'bios' to only use UEFI
    2. Reinstall Debian 12 using UEFI
    3. install the appropriate firmware with apt install firmware-amd-graphics

    If you boot the computer using legacy 'bios' mode, the AMD Radeon firmware won't load no matter what you try. You can see this by issuing the commands:

    rmmod amdgpu
    modprobe amdgpu
    

    You may notice errors on the physical console or in the logs that the GPU driver isn't loaded because it's missing firmware (a lie).

    This whole process got me to around 12 Watt at idle. To get to ~10 Watts idle you need to do two things:

    1. run powertop --auto-tune (saves 1 Watt)
    2. Unplug the monitor (run headless) (saves 1 Watt)

    You have to put the powertop --auto-tune command in /etc/rc.local:

    #!/usr/bin/env bash
    powertop --auto-tune
    exit 0
    

    Don't forget to apply chmod +x /etc/rc.local

    Given the whole picture, 10-11 Watt at idle is perfectly okay. A Raspberry Pi 4 or 5 does around 3-4 Watts at idle so it feels proportional.

    KVM Virtualisation

    I'm running vanilla KVM (Debian 12) on the Elitedesk G4 and it works totally fine. I've created multiple virtual machines without issue and performance seemed perfectly adequate.

    Evaluation and conclusion

    If the CPU fan noise is something you can deal with, this machine is a good homelab server at a great price. The small formfactor feels like a good fit and if you don't need GPIO pins for tinkering with hardware projects - just a good home server - this Mini PC seems to be a good option.

    From a 'new computer' perspective, the Raspberry Pi 5 is still a cheap option. However, large organisations replace their computer hardware on a three to five year cycle and that gear hits the second-hand marked at a price point the Raspberry Pi 5 can't compete against. Especially because the Pi is limited to just 8 GB of memory, which doesn't cover some home-lab use cases.

    I love the idea of the Raspberry Pi and I still have a ton of Pi 4s. This solar-powered blog is hosted on a Pi 4 because of the low power consumption.

    Yet, I think any mini PC variant that is priced at or below €200 is almost always a better choice over the Pi 5.


    1. These computers are often second-hand enterprise gear that can be found all over the internet for decent prices 

    2. I'm looking at an average single-core Geekbench 6 score of ~600 for the Pi 5 and ~1100 for the 2200GE 

    3. The base price included the external power brick. 

    4. I measured multi-GB/s sequential read/write and 100MB+ random 4k read/write. 

    Tagged as : Hardware
  2. Recycle Your Old Laptop Display and Turn It Into a Monitor

    Sat 13 March 2021

    During a cleaning spree I decided that it was time to recycle two old laptops that were just collecting dust on a shelf for many years. Although I didn't have any purpose for them anymore, I realised that the displays were still perfectly fine.

    This is the display of my old 13" Intel-based MacBook.

    screen

    Somehow it felt wasteful to just throw the laptops out, I wondered if it would be possible to use these displays as a regular monitor?

    It turns out: yes this is possible and it is also quite simple. My blogpost covers the same topic, with a few more pictures1.

    There is a particular LCD driver board that can be found all over ebay and the well-known Chinese webshops.

    controller2

    These boards cost around $20 and come with most things you need to get the display operational.

    The board includes:

    1. A small controller print for the on-screen display (center)
    2. A high-voltage power supply for the backlight (left)
    3. The data cable to drive the actual display (right)
    4. Support for audio-passthrough + volume control (right corner)

    The board doesn't include:

    1. A 12-volt power supply
    2. Some kind of frame to make the display and board one easy to handle unit

    controller3

    The board supports HDMI, VGA and DVI for signal input so it should work with almost any computer.

    This particular board (M.NT68676.2) is used to power many different panel models. Although the board itself may be the same, it's important to order the board that is specifically tailored to the particular LCD panel you have. The panels seem easy to identify. This is the Macbook LCD panel type (LP133WX1 TL A1):

    model

    That TL/A1 part of the model is critical to finding the appropriate controller.

    I also have an old Dell Vostro screen that uses the exact same driver board, but the cables are different. Also, it may be the case that the boards are flashed with the appropriate firmware for the particular panel. So I would recommend not to gamble and get the driver board that exactly matches the model number.

    To make everything work, we first connect the high-voltage module to the backlight power cable...

    hv

    ...and we also connect the LCD driver cable:

    driver

    When I connected everything for the first time, the display didn't work at all. It turns out that the board shipped with a second, separate interface cable and I had to swap those cables to make the display work properly.

    Power supply

    According to the sales page, the board requires a 12-volt 2A adapter, but in practice, I could get away with a tiny, much weaker power supply.

    adapter

    I found an old adapter from a Wi-Fi access-point (long gone) which is rated for just 0.5A. It did power both the board and the screen perfectly. It worked with both the Macbook display as the Dell display so it doesn't seem to be a fluke.

    Although I didn't measure actual power consumption, we know that it can't be more than just 6 Watt because that's what the power adapter can handle.

    Laptop displays need to be power efficient and that may also make them interesting for low-power or battery-powered projects.

    We've only just begun

    The display works, but that was the easy part.

    display

    The hardest part of this proces (not pictured) was switching the on-screen-display from Chinese (which I don't master) to English. But there is more work ahead.

    At this point we end up with just a fragile LCD panel connected to a driver board through a bunch of wires. The whole setup is just an unpractical mess. There are at least two things left to do:

    1. Mount the driver board, OSD controller and high-voltage unit to the back of the LCD panel
    2. Make some kind of stand

    For the old Dell display, I used a bit of wood and hot glue to make a wooden scaffold on which I could mount the driver board with a few screws. It won't win any prizes for sure but it's just an example of what needs to be done make the display (more) manageable.

    amateur

    It still doesn't have a stand but that's for another day. I can imagine that if you own a 3D printer, you can make a nice case with a stand, although that will increase the cost of the project.

    Evaluation

    What I like most about this kind of project is the fact that for very little money, you can recycle a perfectly fine and usable display that will probably last for another five to ten years. The project takes very little effort and it is also not difficult to do.

    You can augment existing hobby projects with a screen and due to the relatively low power consumption, it may even be suitable for battery-powered projects.

    And with a bit of work you can make a nice (secondary) monitor out of them. Finally you have an excuse to dust off one of your unused Raspberry Pis that you had to have but didn't have any actual use for.

    The thrift-store is cheaper

    If your goal is just to get a cheap LCD display, it may be cheaper to go to the nearest thrift-store and buy some old second-hand display for $10. But that may have some drawbacks:

    • It will be much larger than the laptop screen
    • It is powered by 110/220 volt so less suitable for a battery-powered setup
    • overall power consumption will be higher

    So it all depends on your particular needs.

    Closing words

    If you also repurposed a laptop monitor for a project or just as a (secondary) screen, feel free to share your work in the comments.


    1. I posted the article on slashdigit to hacker news and it got quite an interest

    Tagged as : Hardware
  3. A 12.48 Inch (1304x984) Three-Color E-Paper Display by Waveshare

    Tue 22 December 2020

    Introduction


    Update September 2023: A small horizontal and large vertical row of pixels died. Demo of defective display here.


    I'm running a solar-powered blog and I wanted to add a low-power display to show the daily solar 'harvest'1 and maybe some additional information.

    So I decided to use an e-paper display. I wanted a display that would be readable from a distance, so bigger would be better. I therefore chose the Waveshare 12.48 inch e-paper display2.

    "e-paper display"

    an example based on data from the summer, generated with Graphite

    This particular display costs $179 excluding taxes and shipping at the time this article was written.

    Specifications

    Waveshare sells a two-color (black and white) and a three-color version (black, white, red). I bought the three-color version. The three-color version is the (B) model.

    Specifications:

    Screen size     :      12.48 inches
    Resolution      :      1304 x 984
    Colors          :      black, white, red
    Greyscale       :      2 levels
    Refresh rate    :      16 seconds
    Partial refresh :      Not supported
    Interfaces      :      Raspberry Pi, ESP32, STM32, Arduino
    

    The two-color variant of this display has a refresh rate of 8 seconds.

    This display is clearly quite slow. Furthermore, the lack of partial refresh support could make this display unsuitable for some applications. I was OK with this slow refresh rate.

    The image below demonstrates different fonts and sizes. I think DejaVuSansMono-Bold looks really well on the display, better than the font supplied by Waveshare.

    "e-paper display"

    The Interfaces

    The display includes a microcontroller that in turn can be driven through one of four interfaces:

    1. A Raspberry Pi (Worked)
    2. An ESP32 (Not tested)
    3. An Arduino (Didn't work)
    4. An STM32 (Not tested)

    I've tried the Arduino header with an Arduino Uno, but the supplied demo code didn't work. I did not investigate further why this was the case. It could be a problem with voltage regulation.

    "e-paper display"

    In the image above, the black plastic backplate is removed.

    Image quality

    These e-paper displays are mostly sold as product information displays for supermarkets and other businesses. However, the quality is good enough to display images. Especially the support for red can make an image stand out.

    Below is an example of an image that incorporates the third (red) color.

    "e-paper display"

    The display seems suitable to display art.

    "e-paper display"

    It looks quite good in real life (sorry for the glare).

    How the display shows three colors

    The display acts like it is actually two displays in one. A black and white display, and a red and white display.

    First, the black and white image is drawn. Next, the red and white image is put on top.

    Because the display has to draw two images in succession, it takes 16 seconds to refresh the screen. This explains why the black-and-white version of this screen does a refresh in eight seconds: it doesn't have to refresh the red color.

    Please note that the entire process of displaying content on the screen takes much longer.

    A demonstration:

    Displaying an image is cumbersome (On Raspberry Pi 3B+)

    At the time this article was written, I could not find any information or tools for this display3.

    Many Waveshare e-paper displays are popular and have a decent community support. However, it seems that this display is rather unknown.

    Therefore, it seems that there are no tools available to display an arbitrary image on this display. You can use the example Python code to display an image but you have to follow these steps:

    1. Create a black-and-white version of the image
    2. Create a red-and-white version of the image, that contains only data for the red parts of the image
    3. If the source image doesn't match the required resolution, you have to resize, crop and fill the image where appropriate.

    Both 'black' and 'red' images need to exactly match the resolution of the display (1304x984) or the library will abort with an error.

    As I found this proces tedious, I automated it.

    A new tool to make displaying an image easy

    I've used the python library as supplied by Waveshare and created a command-line tool (Github) on top of it to perform all the required steps as described in the previous section. I'm using Imagemagick for all the image processing.

    The script works like this:

    ./display -i <image file> [--rotate 90] [--fuzz 35] [--color yellow]
    

    The --fuzz and --color parameters may require some clarification.

    The color red is extracted from an image but it's not always perfect. By applying the --fuzz parameter (the argument is a percentage), it is possible to capture more of the red (or selected color) of an image.

    The --color option specifies which color should be 'converted' to red. By default this color is 'red' (obviously). The 'solar chart' (at the start of this article) is an example where a yellow line was converted to red.

    Very slow: it takes about 55 seconds to display an image using the Raspberry Pi 3B+. Half of that minute is spend converting the images to the appropriate format using Imagemagick.

    Informational: The Python program includes a modified version of the Waveshare Python library. This library has been altered to prevent double conversion of images, which significantly degrades image quality.

    Slow performance

    If you use the provided Python library (Python3 compatible) it takes about 30+ seconds to draw an image on the screen. (This excludes the image processing performed with the 'display' tool.)

    Further testing showed that the Python library converts and dithers the image before it is sent to the display. And it does so for both black and red. Dithering is performed by looping in Python over every of the 1.3 milion pixels.

    Each of these loops (for black and red) take about 10 seconds on the Raspberry Pi 3B+, which explains why it takes so long to update the display. Therefore, I think the combination of Python + the Raspberry Pi 3B+ is not ideal in this case.

    Evaluation

    I wanted to share my experience with this display to make other people aware of its existence. The tool I created should make it simple to get up and running and display an image.

    It clearly has some drawbacks but due to the size, resolution and third color, it seems to be unique and may therefore be interesting.

    Although I never tried the display with an ESP32, I think its an ideal for the purpose of a low-power picture frame.

    This article was discussed on Hacker News (briefly). This resulted in about 9000 unique visitors for this article.

    Appendix A - Remark on other displays

    Please note: Waveshare also sells a smaller 10.3 inch black-and-white e-paper display for a similar price with some significant benefits:

    Screen size     :      10.3 inches
    Resolution      :      1872 x 1404
    Colors          :      black and white
    Greyscale       :      16 levels
    Refresh rate    :      450 miliseconds
    Partial refresh :      Supported
    

    This particular display is smaller but has a higher resolution, supports 16 grayscale levels and updates in half a second. This display may better suit your particular needs. For example, I believe that this display may have been used in this project, a solar-powered digital photo frame.

    Appendix B - How to make the display work on a Raspberry Pi

    This information is straight from the Waveshare site but I include it for completeness and ease of use.

    PART I: Enable the SPI interface with raspi-config

    1. sudo raspi-config
    2. select Interfacing Options
    3. Select SPI
    4. Select Yes
    5. Reboot the Raspberry Pi

    PART II: Install the required libraries

    Install BCM283

    Website

    wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.60.tar.gz
    tar zxvf bcm2835-1.60.tar.gz 
    cd bcm2835-1.60/
    sudo ./configure
    sudo make
    sudo make check
    sudo make install
    

    Install wiringPi

    website

    sudo apt-get install wiringpi
    cd /tmp
    wget https://project-downloads.drogon.net/wiringpi-latest.deb
    sudo dpkg -i wiringpi-latest.deb
    gpio -v
    

    Caution: The library seems to be deprecated. The Raspberry Pi 4 is supported but future versions of the Raspberry Pi may not.

    The wiringPi library is used as part of a compiled library called "DEV_Config.so" as found in the ./lib directory.

    @raspberrypi:~/epaper_display $ ldd lib/DEV_Config.so 
        linux-vdso.so.1 (0x7ee0d000)
        /usr/lib/arm-linux-gnueabihf/libarmmem-${PLATFORM}.so => /usr/lib/arm-linux-gnueabihf/libarmmem-v7l.so (0x76f1e000)
        libwiringPi.so => /usr/lib/libwiringPi.so (0x76f00000)
        libm.so.6 => /lib/arm-linux-gnueabihf/libm.so.6 (0x76e7e000)
        libc.so.6 => /lib/arm-linux-gnueabihf/libc.so.6 (0x76d30000)
        libpthread.so.0 => /lib/arm-linux-gnueabihf/libpthread.so.0 (0x76d06000)
        librt.so.1 => /lib/arm-linux-gnueabihf/librt.so.1 (0x76cef000)
        libcrypt.so.1 => /lib/arm-linux-gnueabihf/libcrypt.so.1 (0x76caf000)
        /lib/ld-linux-armhf.so.3 (0x76f46000)
    

    Install Python3 and required libraries

    sudo apt-get update
    sudo apt-get install python3-pip
    sudo apt-get install python3-pil
    sudo pip3 install RPi.GPIO
    sudo pip3 install spidev
    

    Apendix C - E-paper hacking

    I see myself as a consumer and I don't have any desire to hack the display for lower refresh-rates or partial refresh support, with the risk of damaging the display in the process.

    However one resource about this topic I find very informative is a video from the Youtube Channel "Applied Science" (By Ben Krasnow), called "E-paper hacking: fastest possible refresh rate".

    Apendix D - Available libraries

    Example code for all supported platforms can be found in this github location.

    I also found this github repository that may support this display. This code (also) didn't work for me on my Arduino uno. This could be due to a voltage mismatch, but I'm not willing to solder and potentially destroy the display.

    Apendix E - Links to other e-paper projects

    Very large and expensive display (Medium paywall)

    E-paper calendar

    Solar-powered digital photo frame


    1. During fall and winter, there is almost no power generation due to the very sub-optimal location of my balcony. 

    2. You can go larger but at a cost

    3. My google skills may be at fault but that point is now moot. 

    Tagged as : Hardware

Page 1 / 1