Published March 3, 2026 © MIT

VAULT-TEC Air Terminal

Made a Terminal PC from fallout, powered by Raspberry Pi 5

BeginnerFull instructions provided20 hours3,985

Things used in this project

Hardware components

Raspberry Pi 5

LILYGO TTGO T DISPLAY S3 LONG

Software apps and online services

Autodesk Fusion

Arduino IDE

Hand tools and fabrication machines

3D Printer (generic)

Story

Greetings Everyone and Welcome to the wasteland.

1 / 2

Meet the all-new Vault-Tec Air Terminal, my twist on terminals from the Fallout games. It's a fully working Ubuntu-driven computer powered by a Raspberry Pi 5, paired with an M.2 HAT.

The Fallout twist here is the addition of a secondary monitor that displays the room’s air-quality TVOC readings, presented as RADS, similar to radiation readings in Fallout. This secondary display is a TTGO T-Display ESP32-S3 Long, featuring an ultra-wide 640x180 pixel screen, which shows real-time room air-quality data measured using an SGP40 air-quality sensor.

To make the build feel different and unique, I used a Square 4-inch waveshare HDMI display as the main screen, running a retro-styled terminal interface that closely resembles an actual Fallout terminal. This interface is an Ubuntu application called Cool-Retro-Term.

For the enclosure, I designed and 3D-printed the body, then painted and weathered it with artificial rust and mold patina. Small details such as knobs, logos, and surface greebles were added to make the terminal feel authentic, like a real piece of hardware from the Fallout world.

This article covers the complete build process of the Vault-Tec Air Terminal, from hardware and electronics to finishing and detailing.

So, let’s get started with the build.

MATERIALS REQUIRED

Following were the materials used in this project:

Raspberry Pi 5
M.2 PCIE Hat
M.2 NVME SSD
Waveshare 4-Inch HDMI Square Display
TTGO T Display S3 Long
3D Printed parts
DC STEP DOWN MODULE 5V 8A
SGP40 Probe
DC Barrel Jack
Automotive Filler
Red Oxide primer
Sanding Equipment
Beige Spray Paint
Acrylic paint Brown and Green for Patina
Acrylic Clear Coat Spray

INDOOR AIR QUALITY METER

1 / 3

Here’s how the Vault-Tec Air Terminal’s air quality meter works. On the backside of the terminal, we added an SGP40 sensor housed inside a PG7 connector–based probe. The sensor continuously monitors the room’s air quality. Under normal conditions, my room’s air quality typically ranges between 50 and 100, which is displayed on the secondary screen.

The UI is designed to replicate a Fallout-style aesthetic, using bar indicators and text labeled RADS as an homage to the Fallout universe. To demonstrate changes in TVOC levels, I lit an incense stick and placed it near the sensor. This significantly increased the TVOC concentration, which could be seen immediately as higher numerical readings and corresponding increases in the on-screen bars.

FALLOUT TERMINAL

1 / 3

The Fallout franchise is a retro-futuristic, post-apocalyptic RPG universe that mixes 1950s sci-fi optimism with the harsh reality of nuclear fallout. My entry point into the series was Fallout: New Vegas, and it immediately set the standard for me with its writing, atmosphere, and freedom of choice.

One of the things that fascinated me most about Fallout is how differently technology evolved compared to our real world. In this universe, transistors were never widely adopted. Instead, technological progress continued to revolve around 1950s-era vacuum tube technology, even as society believed it had reached an advanced future. This single divergence shaped nearly every aspect of the Fallout world.

This is especially visible in Fallout’s computer terminals. They were never designed to be comfortable or visually appealing. Instead, they are purely functional machines, built for control, logging, and authorization. Interacting with them feels deliberate, using a physical keyboard to unlock doors, control turrets, access security systems, or read archived corporate and government communications.

Most of these terminals were developed by RobCo Industries, founded by Robert House, who also plays a major antagonistic role in New Vegas.

Physically, Fallout terminals feel imposing. Thick metal casings, exposed vents, mechanical switches and knobs, and the constant glow and flicker of CRT screens emphasize their electro-mechanical nature. They feel more like industrial control panels than consumer electronics. Even centuries after the nuclear war, many of these terminals still function, which suggests that while vacuum tube technology is inefficient and power-hungry, it is also incredibly resilient.

For me, these terminals are more than just gameplay mechanics. They act as storytelling devices, preserving fragments of the pre-war world. Reading emails, error logs, and security notices reveals corporate greed, government paranoia, and small, human moments frozen in time, often making the terminals feel like quiet witnesses to a world that no longer exists.

HARDWARE- DISPLAY

1 / 3

For this project, I wanted to break away from the usual rectangular screens, so I went with a unique 4-inch square HDMI display from Waveshare.

It features a 4-inch IPS panel with a hardware resolution of 720x720, paired with 5-point capacitive touch and a toughened glass panel rated up to 6H hardness. When used with a Raspberry Pi, the display supports Raspberry Pi OS and Ubuntu and works out of the box with no configuration or driver editing required.

The display can also function as a standard computer monitor, supporting Windows over HDMI.

It includes an onboard dual touch circuit with optional USB Type-C or I²C touch interfaces, allowing it to be used across a wide range of application scenarios.

In addition, the display provides a 3.5 mm audio jack and speaker interface, as it supports HDMI audio output, making it suitable for compact all-in-one builds without the need for external audio hardware.

https://www.waveshare.com/4inch-hdmi-lcd-c.htm?&aff_id=Arnov

You can check out more about this display from its wiki page.

https://www.waveshare.com/wiki/4inch_HDMI_LCD_(C)

WAVESHARE SERVICE

1 / 2

Special thanks to Waveshare for providing the hardware used in this project. The 4-Inch HDMI Square Display and supporting accessories were supplied as review units for testing and evaluation.

Waveshare is a leading global provider of electronic components, modules, and development tools used across robotics, IoT, automation, education, and many other fields. With a strong focus on quality, reliability, and continuous innovation, Waveshare has earned the trust of engineers, designers, hobbyists, and makers worldwide.

Their extensive product lineup, from displays and HATs to expansion boards and embedded modules, makes them a go-to choice for both professional builds and DIY projects.

HARDWARE- RASPBERRY PI 5

1 / 2

The brain of our terminal is a Raspberry Pi 5 (4 GB RAM variant). I selected the Pi 5 because of its compact form factor and improved performance. It is powered by the Broadcom BCM2712 quad-core Arm Cortex-A76 processor, which makes it a highly usable single-board computer.

To make the system even faster and more practical, I paired the Raspberry Pi 5 with the official Raspberry Pi M.2 HAT, fitted with a 256 GB M.2 Gen 3 NVMe SSD. Ubuntu is flashed directly onto the NVMe drive, and since the operating system runs from the M.2 storage instead of a microSD card, the overall setup feels significantly faster and more responsive.

HARDWARE - SECONDARY DISPLAY

For the secondary display, we are using not a proper display but the TTGO T-Display S3 Long board, an ESP32-based development board that has a unique display. It is powered by an ESP32-S3R8 dual-core LX7 microprocessor and provides strong performance for demanding applications.

It has Bluetooth Mesh, BLE 5, and Wi-Fi 802.11. It can easily handle complex graphics and multitasking thanks to its 16 MB of flash and 8 MB of PSRAM.

Its most notable feature is the 3.4-inch capacitive touch TFT LCD, which uses a QSPI interface and has a 180 × 640 RGB pixel resolution, making it ideal for touch-enabled, long displays.

I use this board to pair the SGP40 sensor via the TTGO board’s I2C pins, connecting to the SGP40 I2C through a CON4 connector present on the back side of the board. The readings are then displayed on the 180 × 640 screen.

RASPBERRY PI & DISPLAY SETUP

1 / 2

The Waveshare 4-inch display contains four mounting standoffs on which we can mount the Raspberry Pi 5. I positioned the Pi’s mounting holes over the standoffs and then used M2 PCB standoffs to mount the Pi in place.

Next, I positioned the M.2 HAT over the PCB standoffs and secured the M.2 HAT to the Raspberry Pi 5 using four M2 bolts.

The FPC cable that came with the M.2 HAT was then connected, with one end plugged into the PCIe connector on the Raspberry Pi 5 and the other end into the PCIe connector on the M.2 HAT.

Finally, I connected the HDMI bridge connector that came with the Waveshare display, pairing the HDMI port of the Raspberry Pi 5 with the HDMI port of the display.

One of the features of the Waveshare display is its power-sharing capability: we only need to provide power through its USB port, which powers both the Raspberry Pi 5 and the display.

DESIGN INSPIRATION

After doing thorough research on the design of several terminals from the Fallout universe, I studied the design language and the key elements that make a terminal stand out, one of the most noticeable being the screen borders that resemble old CRT monitor bezels.

I then created my own version, starting with several rough sketches. This entire ideation process was crucial for me, as I wasn’t copy-pasting an existing terminal model but designing my own version tailored specifically to the hardware I’m using.

My design uses a square display as the main screen, along with a second display to show air-quality readings. After experimenting with multiple design directions, I finally settled on the one I liked the most.

3D MODEL

1 / 22

I started the 3D modeling process in Fusion 360 by importing the Raspberry Pi display setup along with the TTGO T-Display 3D model into my design.

From there, I followed my design idea and began sketching out the enclosure.

I modeled the main body first, making sure to include cutouts for the main square display and the TTGO T-Display board on the front side.

Next, I designed border frames for both the main and secondary displays. The idea was to make the screens look like old CRT-style monitors with thick display borders. These border frames were designed as separate parts so they could be 3D printed individually and then pressure-fitted into place.

From the inside, I added ribs that help keep both the TTGO T-Display and the Raspberry Pi display setup in place. Since there was very little space, I didn’t make any custom screen holders.

Instead, my idea was to use a small amount of hot glue to secure everything—an approach I got inspiration for from James’s channel and his amazing (yet crazy) Xbox handheld build.

The ribs prevent the hardware from shifting, and the hot glue permanently secures the components in place.

I modeled an extra-large knob on the right side of the main body. This knob is pressure-fitted into position.

On the front face, I added a Vault-Tec logo, which is secured in place using four M2 screws. Slightly above the Vault-Tec logo, I placed a small knob-like part that I modeled purely for aesthetics. This part is printed in red to help it stand out visually.

Next is the main lid, which serves multiple purposes. It holds the SGP40 sensor on the back side, includes a cutout for the DC barrel jack, and also acts as the enclosure lid itself. The lid has six mounting holes, allowing it to be secured to the main body using six M2 screws.

The Raspberry Pi has a status indicator LED that turns green from red once the Pi boots. To make this visible, I designed a small opening on the right side of the body aligned with this LED. A diffuser part, printed in transparent PLA, is placed in this opening so the LED glow diffuses through it and becomes visible from the outside.

Above the large knob on the right side, I added a Vault 101 logo. This logo is purely aesthetic and is secured in place using superglue.

On the left side, slightly near the I/O opening, I added a ROBCO logo, which is also secured using superglue. Below the ROBCO logo, I added a speaker grill. This grill holds the speaker in place, and both the speaker and grill assembly are pressure-fitted into the main body. From the outside, the grill sits slightly flush with the body, giving it a clean, integrated look.

3D PRINTED PARTS

1 / 10

I exported all the component mesh files and started the 3D printing process by printing the main enclosure first. I used the Anycubic slicer for this. To add more strength, I increased the default infill from 15% to 25% and changed the infill type to gyroid. I went with a 0.16 mm layer height using normal infill in Snug style and printed the body using grey Hyper PLA. The color didn’t really matter here since the entire body was going to be painted later.

Using the same settings, I 3D printed the lid and both display frames in black Hyper PLA.

These were the main structural parts. The remaining pieces were greeble parts, which I modeled purely to improve the overall aesthetics.

I started with the Fallout Vault-Tec logo for the front side, printing it using the same settings and grey Hyper PLA.

Next, I printed the RobCo logo and the Vault 101 logo using the same settings but with a slightly different approach. Both logos were printed in grey Hyper PLA, and halfway through the print, I paused it, swapped the grey filament with black Hyper PLA, and resumed printing.

This way, the lettering on both logos came out in black, which makes them look much bolder.

After that, I printed the front knob part using red PLA with the same settings as the previous prints.

The side knob was printed in black Hyper PLA, along with the speaker Grill.

MAIN BODY- FILLER PROCESS

1 / 2

Now comes the Filler process in which I used an automotive two-part filler, mixed it according to the recommended ratio, and applied it over the entire body.

The idea was to fill small gaps between parts and smooth out any uneven areas.

I spread the filler generously across the main body to achieve a clean, uniform surface ready for paint.

MAIN BODY - SANDING

1 / 4

For sanding process, I used a few sheets of sandpaper, along with a sandpaper holder and a dust mask, which is a must-have for this step.

I began by sanding each face of the main body one by one. The goal here was to even out the surface by sanding down the filler. This removes excess filler and leaves a clean, smooth surface ready for the next stage.

MAIN BODY - PRIMER & SANDING

1 / 2

After sanding, the next step for me was getting the body ready for paint.

Since no paint job is complete without a proper primer coat, I use a 30 mm wide brush, and coated the entire exterior starting with the top, then moving to the left and right sides, followed by the front, and finally the bottom.
I let the primer dry for 4–5 hours, then came back with 120-grit sandpaper. Using my sanding setup, I sanded the whole body, wiped away the dust with a damp cloth, let it dry, and sanded again.
After that, I inspected the surface for any gaps or uneven areas, applied more primer where needed, let it dry for another 4–5 hours, and repeated the sanding process.
By repeating this cycle three times, I was able to get a smooth, uniform surface that was finally ready for the paint stage.

PS: I made the job harder by using primer from a paint can. I’d recommend using a spray primer instead, as it makes the process much quicker and easier, with a more even finish.

PAINT PROCESS- BASE COAT

1 / 2

Using a beige aerosol spray, I began the painting process by spraying evenly on each face of the main body.
I intentionally applied light coats, as applying too much paint at once can cause drips, which would ruin the finish. After the first coat, I let the body dry for about 3 hours before applying a second coat.
In total, two coats were applied, resulting in a clean, smooth beige finish that gives the terminal a classic, retro look.

WEATHERING PROCESS

1 / 2

Now comes the crucial part that transforms the terminal from a clean, modern-looking computer into a retro, war-torn terminal: the weathering process.
To make the device look aged and battle-worn, I began by using a piece of sandpaper to wear down the edges and borders of the main body, along with randomly sanding a few areas on the left and right sides as well.

PATINA WORK

1 / 5

For the patina, I primarily used two acrylic paint colors: brown to imitate rust and green to imitate mold.
I applied brown paint to the edges and areas that were sanded earlier, then used a sponge to spread it out. The paint settles into the scratches made by the sandpaper, creating a natural rusty effect.
I repeated the same process with green paint, applying it randomly across the surface and spreading it with a sponge. As the paint seeps into the scratches, the green color effectively imitates mold growth.

After this step, the body takes on an old, beaten-down appearance with a convincingly rusty and moldy look.

FINAL PROTECTIVE TOPCOAT

1 / 3

To keep the patina look permanent, I used an acrylic clear coat spray and applied it evenly over the entire main body. I then let it dry for 3–4 hours.
Here as well, light coats are important, since applying too much clear coat at once can cause drips and ruin the finish.

The end result is a heavily weathered, rusty-looking body that is fully sealed with a clear coat, making the finish durable and long-lasting.

SCREEN FRAME ASSEMBLY

1 / 3

Next is the screen frame assembly process.

I first placed the frame for the TTGO T-Display board into position from the front of the main body.
After that, I installed the main square display frame. Both frame parts are pressure-fitted into place.

VAULT-TEC LOGO

1 / 3

Next, the Vault-Tec logo is positioned above its mounting location on the front side of the main body and secured in place using four M2 screws.

REST OF GREEBLES ASSEMBLY

1 / 4

Superglue is applied to the backside of the front knob part and it is positioned slightly above the Vault-Tec logo.
Similarly, I applied superglue to the back of the Vault 101 part and positioned it on the left side of the main body.
I then added superglue to the back of the RobCo Industries logo and positioned it on the right side of the main body.
Finally, the knob is installed on the left side of the main body. This knob was pressure-fitted into place, completing the main body assembly process.

SGP40 TVOC SETUP, CODE & TEST RUN

For the air quality meter setup, I connected the I2C pins of the SGP40 sensor directly to the I2C connector of the TTGO T-Display board. This allowed the ESP32 to communicate with the sensor using the standard SDA and SCL lines.

Once the hardware connections were completed, I uploaded the main sketch to the TTGO T-Display board.

Below is the main code used for this setup.

#include <Arduino.h>
#include <Wire.h>
#include "AXS15231B.h"
#include "pins_config.h"
#include <Adafruit_SGP40.h>
#include "fontFull.h"
/* ================= DISPLAY ================= */
#define SCREEN_W 640
#define SCREEN_H 180
uint16_t frameBuffer[SCREEN_W * SCREEN_H];
/* ================= COLORS ================= */
#define TERMINAL_YELLOW  0x07FF
#define BLACK            0x0000
/* ================= SGP40 ================= */
Adafruit_SGP40 sgp;
uint16_t vocRaw = 0;
uint16_t vocSmooth = 0;
uint16_t vocDisplay = 0;
/* ================= STATE ================= */
bool startupAnim = true;
int animLevel = 10;
int animDir = -1;
unsigned long animStart = 0;
unsigned long lastAnimStep = 0;
/* ================= ROTATED PUSH ================= */
void lcd_PushColors_rotated(uint16_t w, uint16_t h, uint16_t *data)
{
static uint16_t line[SCREEN_H];
for (int col = w - 1; col >= 0; col--) {
lcd_address_set(0, (w - 1) - col, h - 1, (w - 1) - col);
for (int row = 0; row < h; row++) {
line[row] = data[row * w + col];
}
lcd_PushColors(line, h);
}
}
/* ================= FRAMEBUFFER ================= */
void clearFB() { memset(frameBuffer, 0, sizeof(frameBuffer)); }
void fillRectFB(int x, int y, int w, int h, uint16_t c)
{
for (int j = 0; j < h; j++) {
uint16_t *row = &frameBuffer[(y + j) * SCREEN_W + x];
for (int i = 0; i < w; i++) row[i] = c;
}
}
/* ================= FONT ================= */
void drawCharRot90CCW_Fixed(int x, int y, char c, uint16_t col, uint8_t scale)
{
const uint8_t* bmp = fontFull_getBitmap(c);
for (int cx = 0; cx < 5; cx++) {
uint8_t bits = pgm_read_byte(&bmp[cx]);
for (int cy = 0; cy < 7; cy++) {
if (bits & 0x01) {
fillRectFB(x + (6 - cy) * scale, y + cx * scale, scale, scale, col);
}
bits >>= 1;
}
}
}
void drawTextVertical(int x, int y, const char* txt, uint16_t col, uint8_t scale)
{
while (*txt) {
drawCharRot90CCW_Fixed(x, y, *txt, col, scale);
y += (5 * scale) + scale;
txt++;
}
}
/* ================= UI LAYOUT ================= */
#define BTN_PADDING 12
#define BTN_GAP     10
#define BTN_Y       BTN_PADDING
#define BTN_H       (SCREEN_H - BTN_PADDING * 2)
#define BTN_W       ((SCREEN_W - BTN_PADDING * 2 - BTN_GAP * 3) / 4)
/* ================= BARS ================= */
#define BAR_COUNT 10
uint8_t vocToBars(uint16_t voc)
{
if (voc <= 100) return 2;
if (voc <= 200) return 4;
if (voc <= 400) return 6;
if (voc <= 600) return 8;
return 10;
}
void drawBars(uint8_t level)
{
int areaX = BTN_PADDING;
int areaY = BTN_Y;
int areaW = (BTN_W * 3) + (BTN_GAP * 2);
int areaH = BTN_H;
fillRectFB(areaX, areaY, areaW, areaH, BLACK);
int gap = 5;
int barW = (areaW - (BAR_COUNT + 1) * gap) / BAR_COUNT;
int barH = areaH - 24;
for (int i = 0; i < level; i++) {
int x = areaX + gap + i * (barW + gap);
fillRectFB(x, areaY + 12, barW, barH, TERMINAL_YELLOW);
}
}
/* ================= RADS PANEL ================= */
void drawRADS(uint16_t voc)
{
int panelX = BTN_PADDING + (BTN_W + BTN_GAP) * 3;
int panelY = BTN_Y;
int panelW = BTN_W;
int panelH = BTN_H;
fillRectFB(panelX, panelY, panelW, panelH, BLACK);
int bw = 3;
fillRectFB(panelX, panelY, panelW, bw, TERMINAL_YELLOW);
fillRectFB(panelX, panelY + panelH - bw, panelW, bw, TERMINAL_YELLOW);
fillRectFB(panelX, panelY, bw, panelH, TERMINAL_YELLOW);
fillRectFB(panelX + panelW - bw, panelY, bw, panelH, TERMINAL_YELLOW);
int padTop = 43;
int radsX = panelX + panelW - 38;
int numberX = radsX - 80;
int radY = panelY + padTop;
drawTextVertical(radsX, radY, "RADS", TERMINAL_YELLOW, 3);
int lineX = radsX - 20;
int lineY = panelY + bw + 2;
int lineH = panelH - (bw * 2) - 4;
fillRectFB(lineX, lineY, 2, lineH, TERMINAL_YELLOW);
int numberY = radY + (4 * (5 * 3 + 1)) + 6 - 90;
char buf[8];
snprintf(buf, sizeof(buf), "%u", voc);
drawTextVertical(numberX, numberY, buf, TERMINAL_YELLOW, 6);
}
/* ================= SETUP ================= */
void setup()
{
pinMode(TFT_BL, OUTPUT);
digitalWrite(TFT_BL, HIGH);
Wire.begin(15, 10);
axs15231_init();
sgp.begin();
animStart = millis();
}
/* ================= LOOP ================= */
void loop()
{
clearFB();
// -------- SENSOR STABILIZATION --------
vocRaw = sgp.measureVocIndex();
// Exponential smoothing
vocSmooth = (vocSmooth * 7 + vocRaw) / 8;
// Peak-hold with slow decay
if (vocSmooth > vocDisplay) {
vocDisplay = vocSmooth;
} else if (vocDisplay > 0) {
vocDisplay--;   // slow decay
}
drawRADS(vocDisplay);
if (startupAnim) {
if (millis() - lastAnimStep > 350) {
animLevel += animDir;
if (animLevel <= 1 || animLevel >= BAR_COUNT)
animDir = -animDir;
lastAnimStep = millis();
}
drawBars(animLevel);
if (millis() - animStart > 7000)
startupAnim = false;
} else {
drawBars(vocToBars(vocDisplay));
}
lcd_PushColors_rotated(SCREEN_W, SCREEN_H, frameBuffer);
delay(30);
}

In our code, I used customised Display driver AXS15231B, this has been done as the display I am using isn't a normal standard arduino compatable TFT display, our edited display driver allows the TTGo board to work with existing stuff completely.

similarly, I have added the fullFont custom bitmap font file that contains 5x7 bitmap fonts, we are using this as we are not using any graphical library like adafruit gfx so we need to manually draw pixels into the framebuffer.

Here's a small breakdown of the rest of the code.

Display Configuration

#define SCREEN_W 640
#define SCREEN_H 180
uint16_t frameBuffer[SCREEN_W * SCREEN_H];

We first define Resolution of display. I also added frameBuffer which is a full-screen off-screen buffer.

Color Definitions

#define TERMINAL_YELLOW  0x07FF
#define BLACK            0x0000

Colors are in RGB565 format and we have used only two colors, which are black for the background and yellow for the terminal fallout theme.

SGP40 Sensor Variables

Adafruit_SGP40 sgp;
uint16_t vocRaw = 0;
uint16_t vocSmooth = 0;
uint16_t vocDisplay = 0;

I next added SGP40 variables in which vocRaw is the direct sensor reading, vocSmooth filters the value basically reducing noise and vocDisplay is the value shown on screen.

Startup Animation State

bool startupAnim = true;
int animLevel = 10;
int animDir = -1;
unsigned long animStart = 0;
unsigned long lastAnimStep = 0;

Here’s a fun feature I added: on startup, the display shows a bar animation where the bars move from bottom to top before any data is displayed. This animation runs once when the ESP32 receives power from the power source, giving the terminal a proper boot-up feel.

void lcd_PushColors_rotated(uint16_t w, uint16_t h, uint16_t *data)

Display is physically rotated; hence, we needed a function that rotates the framebuffer 90 degrees. basically this sends data column by column instead of row by row.

Framebuffer Utilities

void clearFB() { memset(frameBuffer, 0, sizeof(frameBuffer)); }
This clears the screen to black.
void fillRectFB(int x, int y, int w, int h, uint16_t c)

Using the above function, this manually fills pixels in the framebuffer; this is our primitive drawing function.

Font Rendering

void drawCharRot90CCW_Fixed(...)

This reads bitmap data from the fontFull.h file, rotates characters 90 degrees, support scaling and writes directly to the framebuffer.

void drawTextVertical(...)

This stack rotates characters vertically and it is used for numeric values.

Bar Graph Logic

uint8_t vocToBars(uint16_t voc)
This section converts VOC values into 10 Bar levels.
void drawBars(uint8_t level)

Using this function, we clear the bar area, calculate bar size and spacing, and then draw only the active bars based on VOC values.

RADS Panel Rendering

void drawRADS(uint16_t voc)

This function draws a bordered panel inside, where there is a RADS label and even displays VOC Values below the RADS.

Main Loop

vocRaw = sgp.measureVocIndex();
This reads the raw VOC index.
vocSmooth = (vocSmooth * 7 + vocRaw) / 8;
This reduces noise while remaining responsive.
Peak-hold logic
if (vocSmooth > vocDisplay) {
vocDisplay = vocSmooth;
} else if (vocDisplay > 0) {
vocDisplay--;
}

I have added the AXS15231B.h and.cpp files along with the fontFull.h file, which you need to put in the same folder as the.ino file.

For the demo run, I used an incense stick to increase the VOC levels through smoke release. As the VOC concentration rises, the displayed readings increase, and the number of bars on the screen increases accordingly.

DC STEP DOWN MODULE

1 / 5

To power the Raspberry Pi, display, and ESP32 from a single supply, we used a high-current DC buck converter module.

Specifically, we chose a 6-USB Output DC Step-Down Module capable of converting 8V–40V DC input down to a regulated 5V output at up to 8A.

The module accepts power through a DC barrel jack, allowing the use of a wide range of adapters, including 12V, 24V, or even 36V supplies. This makes the power system flexible and easy to adapt to different setups.

The regulated 5V output is distributed through six onboard USB ports, enabling multiple devices to be powered simultaneously without the need for separate regulators.

POWER SOURCE ASSEMBLY

1 / 5

For power, I wanted to use a 12 V 4A power adapter with a DC barrel jack male connector.

To connect it to the DC step-down module, I soldered a DC barrel jack female connector, wiring its positive and negative terminals to the input ports of the DC step-down module.
For power distribution between the Raspberry Pi–display setup and the TTGO T-Display board, I used two short USB Type-C cables, which power both setups reliably without any soldering.

While I could have soldered these connections directly, using Type-C cables was simply quicker and more convenient.

MAIN DISPLAY ASSEMBLY

1 / 3

The protective covering from the main display was removed, and the whole Raspberry Pi display setup was then slid down into its position.

Using a small amount of hot glue, the Raspberry Pi display setup was secured in place.

SECONDARY DISPLAY ASSEMBLY

1 / 2

Next, the TTGO T- DISPLAY Board was positioned in its mounting position in the correct orientation, hotglue was used to secure it in its place.

SPEAKER ASSEMBLY

1 / 6

For the Speaker Assembly, I used M2 nuts and bolts to secure the speaker grill to the 4-ohm speaker mounting holes.
The entire speaker grill assembly was then slid into its position from the inside of the main body, where it is pressure-fitted in place.
Finally, I connected the speaker’s CON2 connector to the audio connector on the Waveshare display.

LID ASSEMBLY- SENSOR & DC JACK

1 / 4

The lid assembly starts by first installing the SGP40 sensor.
The PG7 connector nut was unscrewed, the sensor wire was passed through the hole in the lid, and the nut was then tightened to secure the SGP40 in place.
Next, the DC barrel jack was inserted into its mounting position, and the retaining nut was tightened to firmly secure it.

LID ASSEMBLY- DC STEP DOWN MODULE

1 / 5

The DC step-down module is placed over its mounting position and then fastened in place using two M2 PCB standoffs and M2 bolts.
After that, the DC barrel connector’s positive and negative wires are re-soldered to the input terminals of the DC step-down module.

With this, the lid assembly process is complete, and we can now begin the final assembly process.

FINAL ASSEMBLY PROCESS

1 / 7

The final assembly process begins by connecting the SGP40 wiring to the TTGO I2C connector.
Next, the USB Type-C port from the Waveshare display is plugged into one of the USB ports on the DC step-down module, along with the TTGO Type-C port, which is also connected to the DC step-down module.
The LED diffuser is then placed into position using a tweezer. This diffuser is pressure-fitted and snaps securely into place.
Once all the connections are done, the lid is placed on the backside of the main body in its position.
Six M2 screws are then used to fasten the lid to the main body.

With this, the entire project is complete, and the terminal build is finished.

END RESULT

1 / 4

The end result of this super sick project is a terminal that looks like it came straight out of the Fallout universe. It contains a Raspberry Pi 5 paired with an M.2 HAT, which makes it a quite capable setup. The entire design is custom; I did thorough research on Fallout terminals and came up with my own design by following Fallout’s terminal design language.

The display is also not a usual one. I used a very unique Waveshare 4-inch square display, which makes the setup feel more retro, similar to old 4:3 TVs from earlier times. I also worked on the body finish, where I painted the enclosure and added patina and aesthetic greeble parts.

On the backside, there is an SGP40 sensor that reads and monitors indoor air quality (TVOC levels). These readings are displayed on the secondary display and labeled as RADS, as a homage to Fallout radiation readings.

I also added 10 bars that increase or decrease depending on the RADS value. As the reading increases, more bars appear, with a maximum of 10 bars and a minimum of 1.

This is a perfect Pi-based computer that also monitors indoor air quality. The only thing missing is a keyboard, which most terminals usually have. My goal was to make a smaller terminal, and adding a keyboard to such a compact design would have looked odd, which is why I didn’t include one.

Maybe in Version 2 of this project, I’ll build a more powerful all-in-one computer larger than this version and include a keyboard along with more sensors and additional Fallout-related features.

For now, this project is complete, and all the files related to it are attached in this article. Feel free to reach out if you need any information or help regarding the project, and let me know what things you think I could have done differently.

I’ve made a few similar Fallout-themed projects as well. If you’re into the Fallout universe, feel free to check them out.

https://www.hackster.io/Arnov_Sharma_makes/pip-watch-version-2-a95c6c

https://www.hackster.io/Arnov_Sharma_makes/pip-watch-project-370245

This is it for now and i'll be back with a new project real soon. peace!

Schematics

Code

#include <Arduino.h>
#include <Wire.h>
#include "AXS15231B.h"
#include "pins_config.h"
#include <Adafruit_SGP40.h>
#include "fontFull.h"

/* ================= DISPLAY ================= */
#define SCREEN_W 640
#define SCREEN_H 180
uint16_t frameBuffer[SCREEN_W * SCREEN_H];

/* ================= COLORS ================= */
#define TERMINAL_YELLOW  0x07FF
#define BLACK            0x0000

/* ================= SGP40 ================= */
Adafruit_SGP40 sgp;
uint16_t vocRaw = 0;
uint16_t vocSmooth = 0;
uint16_t vocDisplay = 0;

/* ================= STATE ================= */
bool startupAnim = true;
int animLevel = 10;
int animDir = -1;
unsigned long animStart = 0;
unsigned long lastAnimStep = 0;

/* ================= ROTATED PUSH ================= */
void lcd_PushColors_rotated(uint16_t w, uint16_t h, uint16_t *data)
{
  static uint16_t line[SCREEN_H];
  for (int col = w - 1; col >= 0; col--) {
    lcd_address_set(0, (w - 1) - col, h - 1, (w - 1) - col);
    for (int row = 0; row < h; row++) {
      line[row] = data[row * w + col];
    }
    lcd_PushColors(line, h);
  }
}

/* ================= FRAMEBUFFER ================= */
void clearFB() { memset(frameBuffer, 0, sizeof(frameBuffer)); }

void fillRectFB(int x, int y, int w, int h, uint16_t c)
{
  for (int j = 0; j < h; j++) {
    uint16_t *row = &frameBuffer[(y + j) * SCREEN_W + x];
    for (int i = 0; i < w; i++) row[i] = c;
  }
}

/* ================= FONT ================= */
void drawCharRot90CCW_Fixed(int x, int y, char c, uint16_t col, uint8_t scale)
{
  const uint8_t* bmp = fontFull_getBitmap(c);
  for (int cx = 0; cx < 5; cx++) {
    uint8_t bits = pgm_read_byte(&bmp[cx]);
    for (int cy = 0; cy < 7; cy++) {
      if (bits & 0x01) {
        fillRectFB(x + (6 - cy) * scale, y + cx * scale, scale, scale, col);
      }
      bits >>= 1;
    }
  }
}

void drawTextVertical(int x, int y, const char* txt, uint16_t col, uint8_t scale)
{
  while (*txt) {
    drawCharRot90CCW_Fixed(x, y, *txt, col, scale);
    y += (5 * scale) + scale;
    txt++;
  }
}

/* ================= UI LAYOUT ================= */
#define BTN_PADDING 12
#define BTN_GAP     10
#define BTN_Y       BTN_PADDING
#define BTN_H       (SCREEN_H - BTN_PADDING * 2)
#define BTN_W       ((SCREEN_W - BTN_PADDING * 2 - BTN_GAP * 3) / 4)

/* ================= BARS ================= */
#define BAR_COUNT 10

uint8_t vocToBars(uint16_t voc)
{
  if (voc <= 100) return 2;
  if (voc <= 200) return 4;
  if (voc <= 400) return 6;
  if (voc <= 600) return 8;
  return 10;
}

void drawBars(uint8_t level)
{
  int areaX = BTN_PADDING;
  int areaY = BTN_Y;
  int areaW = (BTN_W * 3) + (BTN_GAP * 2);
  int areaH = BTN_H;

  fillRectFB(areaX, areaY, areaW, areaH, BLACK);

  int gap = 5;
  int barW = (areaW - (BAR_COUNT + 1) * gap) / BAR_COUNT;
  int barH = areaH - 24;

  for (int i = 0; i < level; i++) {
    int x = areaX + gap + i * (barW + gap);
    fillRectFB(x, areaY + 12, barW, barH, TERMINAL_YELLOW);
  }
}

/* ================= RADS PANEL ================= */
void drawRADS(uint16_t voc)
{
  int panelX = BTN_PADDING + (BTN_W + BTN_GAP) * 3;
  int panelY = BTN_Y;
  int panelW = BTN_W;
  int panelH = BTN_H;

  fillRectFB(panelX, panelY, panelW, panelH, BLACK);

  int bw = 3;
  fillRectFB(panelX, panelY, panelW, bw, TERMINAL_YELLOW);
  fillRectFB(panelX, panelY + panelH - bw, panelW, bw, TERMINAL_YELLOW);
  fillRectFB(panelX, panelY, bw, panelH, TERMINAL_YELLOW);
  fillRectFB(panelX + panelW - bw, panelY, bw, panelH, TERMINAL_YELLOW);

  int padTop = 43;
  int radsX = panelX + panelW - 38;
  int numberX = radsX - 80;

  int radY = panelY + padTop;
  drawTextVertical(radsX, radY, "RADS", TERMINAL_YELLOW, 3);

  int lineX = radsX - 20;
  int lineY = panelY + bw + 2;
  int lineH = panelH - (bw * 2) - 4;
  fillRectFB(lineX, lineY, 2, lineH, TERMINAL_YELLOW);

  int numberY = radY + (4 * (5 * 3 + 1)) + 6 - 90;
  char buf[8];
  snprintf(buf, sizeof(buf), "%u", voc);
  drawTextVertical(numberX, numberY, buf, TERMINAL_YELLOW, 6);
}

/* ================= SETUP ================= */
void setup()
{
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);

  Wire.begin(15, 10);
  axs15231_init();
  sgp.begin();

  animStart = millis();
}

/* ================= LOOP ================= */
void loop()
{
  clearFB();

  // -------- SENSOR STABILIZATION --------
  vocRaw = sgp.measureVocIndex();

  // Exponential smoothing
  vocSmooth = (vocSmooth * 7 + vocRaw) / 8;

  // Peak-hold with slow decay
  if (vocSmooth > vocDisplay) {
    vocDisplay = vocSmooth;
  } else if (vocDisplay > 0) {
    vocDisplay--;   // slow decay
  }

  drawRADS(vocDisplay);

  if (startupAnim) {
    if (millis() - lastAnimStep > 350) {
      animLevel += animDir;
      if (animLevel <= 1 || animLevel >= BAR_COUNT)
        animDir = -animDir;
      lastAnimStep = millis();
    }
    drawBars(animLevel);
    if (millis() - animStart > 7000)
      startupAnim = false;
  } else {
    drawBars(vocToBars(vocDisplay));
  }

  lcd_PushColors_rotated(SCREEN_W, SCREEN_H, frameBuffer);
  delay(30);
}

#include "AXS15231B.h"
#include "SPI.h"
#include "Arduino.h"
#include "driver/spi_master.h"

static volatile bool lcd_spi_dma_write = false;
extern void my_print(const char *buf);
uint32_t transfer_num = 0;
size_t lcd_PushColors_len = 0;

const static lcd_cmd_t axs15231b_qspi_init[] = {
    {0x28, {0x00}, 0x40},
    {0x10, {0x00}, 0x20},
    {0x11, {0x00}, 0x80},
    {0x29, {0x00}, 0x00}, 
};

const static lcd_cmd_t axs15231b_qspi_init_new[] = {
    {0x28, {0x00}, 0x40},
    {0x10, {0x00}, 0x80},
    {0xbb, {0x00,0x00,0x00,0x00,0x00,0x00,0x5a,0xa5}, 0x08},   
    {0xa0, {0x00,0x30,0x00,0x02,0x00,0x00,0x05,0x3f,0x30,0x05,0x3f,0x3f,0x00,0x00,0x00,0x00,0x00}, 0x11},
    {0xa2, {0x30,0x04,0x14,0x50,0x80,0x30,0x85,0x80,0xb4,0x28,0xff,0xff,0xff,0x20,0x50,0x10,0x02,0x06,0x20,0xd0,0xc0,0x01,0x12,0xa0,0x91,0xc0,0x20,0x7f,0xff,0x00,0x06}, 0x1F}, 
    {0xd0, {0x80,0xb4,0x21,0x24,0x08,0x05,0x10,0x01,0xf2,0x02,0xc2,0x02,0x22,0x22,0xaa,0x03,0x10,0x12,0xc0,0x10,0x10,0x40,0x04,0x00,0x30,0x10,0x00,0x03,0x0d,0x12}, 0x1E},
    {0xa3, {0xa0,0x06,0xaa,0x00,0x08,0x02,0x0a,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x00,0x55,0x55}, 0x16},
    {0xc1, {0x33,0x04,0x02,0x02,0x71,0x05,0x24,0x55,0x02,0x00,0x01,0x01,0x53,0xff,0xff,0xff,0x4f,0x52,0x00,0x4f,0x52,0x00,0x45,0x3b,0x0b,0x04,0x0d,0x00,0xff,0x42}, 0x1E},
    {0xc4, {0x00,0x24,0x33,0x80,0x66,0xea,0x64,0x32,0xc8,0x64,0xc8,0x32,0x90,0x90,0x11,0x06,0xdc,0xfa,0x00,0x00,0x80,0xfe,0x10,0x10,0x00,0x0a,0x0a,0x44,0x50}, 0x1D},
    {0xc5, {0x18,0x00,0x00,0x03,0xfe,0xe8,0x3b,0x20,0x30,0x10,0x88,0xde,0x0d,0x08,0x0f,0x0f,0x01,0xe8,0x3b,0x20,0x10,0x10,0x00}, 0x17},
    {0xc6, {0x05,0x0a,0x05,0x0a,0x00,0xe0,0x2e,0x0b,0x12,0x22,0x12,0x22,0x01,0x03,0x00,0x02,0x6a,0x18,0xc8,0x22}, 0x14},
    {0xc7, {0x50,0x36,0x28,0x00,0xa2,0x80,0x8f,0x00,0x80,0xff,0x07,0x11,0x9c,0x6f,0xff,0x24,0x0c,0x0d,0x0e,0x0f,0x01,0x01,0x01,0x01,0x3f,0x07,0x00}, 0x1B},
    {0xc9, {0x33,0x44,0x44,0x01}, 0x04},
    {0xcf, {0x2c,0x1e,0x88,0x58,0x13,0x18,0x56,0x18,0x1e,0x68,0xf7,0x00,0x66,0x0d,0x22,0xc4,0x0c,0x77,0x22,0x44,0xaa,0x55,0x04,0x04,0x12,0xa0,0x08}, 0x1B},
    {0xd5, {0x30,0x30,0x8a,0x00,0x44,0x04,0x4a,0xe5,0x02,0x4a,0xe5,0x02,0x04,0xd9,0x02,0x47,0x03,0x03,0x03,0x03,0x83,0x00,0x00,0x00,0x80,0x52,0x53,0x50,0x50,0x00}, 0x1E},
    {0xd6, {0x10,0x32,0x54,0x76,0x98,0xba,0xdc,0xfe,0x34,0x02,0x01,0x83,0xff,0x00,0x20,0x50,0x00,0x30,0x03,0x03,0x50,0x13,0x00,0x00,0x00,0x04,0x50,0x20,0x01,0x00}, 0x1E},
    {0xd7, {0x03,0x01,0x09,0x0b,0x0d,0x0f,0x1e,0x1f,0x18,0x1d,0x1f,0x19,0x30,0x30,0x04,0x00,0x20,0x20,0x1f}, 0x13},
    {0xd8, {0x02,0x00,0x08,0x0a,0x0c,0x0e,0x1e,0x1f,0x18,0x1d,0x1f,0x19}, 0x0C},
    {0xdf, {0x44,0x33,0x4b,0x69,0x00,0x0a,0x02,0x90}, 0x06},
    {0xe0, {0x1f,0x20,0x10,0x17,0x0d,0x09,0x12,0x2a,0x44,0x25,0x0c,0x15,0x13,0x31,0x36,0x2f,0x02}, 0x11},
    {0xe1, {0x3f,0x20,0x10,0x16,0x0c,0x08,0x12,0x29,0x43,0x25,0x0c,0x15,0x13,0x32,0x36,0x2f,0x27}, 0x11},
    {0xe2, {0x3b,0x07,0x12,0x18,0x0e,0x0d,0x17,0x35,0x44,0x32,0x0c,0x14,0x14,0x36,0x3a,0x2f,0x0d}, 0x11},
    {0xe3, {0x37,0x07,0x12,0x18,0x0e,0x0d,0x17,0x35,0x44,0x32,0x0c,0x14,0x14,0x36,0x32,0x2f,0x0f}, 0x11},
    {0xe4, {0x3b,0x07,0x12,0x18,0x0e,0x0d,0x17,0x39,0x44,0x2e,0x0c,0x14,0x14,0x36,0x3a,0x2f,0x0d}, 0x11},
    {0xe5, {0x37,0x07,0x12,0x18,0x0e,0x0d,0x17,0x39,0x44,0x2e,0x0c,0x14,0x14,0x36,0x3a,0x2f,0x0f}, 0x11},
    {0xbb, {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, 0x06},
    {0x28, {0x00}, 0x40},
    {0x10, {0x00}, 0x80},
    {0x11, {0x00}, 0x80},
    {0x29, {0x00}, 0x00}, 
};

bool get_lcd_spi_dma_write(void)
{
    return lcd_spi_dma_write;
}

static spi_device_handle_t spi;

static void WriteComm(uint8_t data)
{
    TFT_CS_L;
    SPI.beginTransaction(SPISettings(SPI_FREQUENCY, MSBFIRST, TFT_SPI_MODE));
    SPI.write(0x00);
    SPI.write(data);
    SPI.write(0x00);
    SPI.endTransaction();
    TFT_CS_H;
}

static void WriteData(uint8_t data)
{
    TFT_CS_L;
    SPI.beginTransaction(SPISettings(SPI_FREQUENCY, MSBFIRST, TFT_SPI_MODE));
    SPI.write(data);
    SPI.endTransaction();
    TFT_CS_H;
}

static void lcd_send_cmd(uint32_t cmd, uint8_t *dat, uint32_t len)
{
#if LCD_USB_QSPI_DREVER == 1
    TFT_CS_L;
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.flags = (SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR);
    #ifdef LCD_SPI_DMA
        if(cmd == 0xff && len == 0x1f)
        {
            t.cmd = 0x02;
            t.addr = 0xffff;
            len = 0;
        }
        else if(cmd == 0x00)
        {
            t.cmd = 0X00;
            t.addr = 0X0000;
            len = 4;
        }
        else 
        {
            t.cmd = 0x02;
            t.addr = cmd << 8;
        }
    #else
        t.cmd = 0x02;
        t.addr = cmd << 8;
    #endif
    if (len != 0) {
        t.tx_buffer = dat; 
        t.length = 8 * len;
    } else {
        t.tx_buffer = NULL;
        t.length = 0;
    }
    spi_device_polling_transmit(spi, &t);
    TFT_CS_H;
    if(0)
    {
        WriteComm(cmd);
        if (len != 0) {
            for (int i = 0; i < len; i++)
                WriteData(dat[i]);
        }
    }
#else
    WriteComm(cmd);
    if (len != 0) {
        for (int i = 0; i < len; i++)
            WriteData(dat[i]);
    }
#endif
}

static void IRAM_ATTR spi_dma_cd(spi_transaction_t *trans)
{
    if(transfer_num > 0)
    {
        transfer_num--;
    }
        
    if(lcd_PushColors_len <= 0 && transfer_num <= 0)
    {
        if(lcd_spi_dma_write) {
            lcd_spi_dma_write = false;
            lv_disp_t * disp = _lv_refr_get_disp_refreshing();
            if(disp != NULL)
                lv_disp_flush_ready(disp->driver);

            TFT_CS_H;
        }
    }
}


void lcd_send_data8(uint8_t dat) {
	unsigned char i;
	for (i = 0; i < 8; i++) {
		if (dat & 0x80) {
		digitalWrite(TFT_QSPI_D0, 1);
		} else {
		digitalWrite(TFT_QSPI_D0, 0);
		}
		dat <<= 1;
		digitalWrite(TFT_QSPI_SCK, 0);
		digitalWrite(TFT_QSPI_SCK, HIGH);
	}
}

void axs15231_init(void)
{
    pinMode(TFT_QSPI_CS, OUTPUT);
    pinMode(TFT_QSPI_RST, OUTPUT);

    TFT_RES_H;
    delay(130);
    TFT_RES_L;
    delay(130);
    TFT_RES_H;
    delay(300);

#if LCD_USB_QSPI_DREVER == 1
    esp_err_t ret;

    spi_bus_config_t buscfg = {
        .data0_io_num = TFT_QSPI_D0,
        .data1_io_num = TFT_QSPI_D1,
        .sclk_io_num = TFT_QSPI_SCK,
        .data2_io_num = TFT_QSPI_D2,
        .data3_io_num = TFT_QSPI_D3,
        .max_transfer_sz = (SEND_BUF_SIZE * 16) + 8,
        .flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_GPIO_PINS /* |
                 SPICOMMON_BUSFLAG_QUAD */
        ,
    };
    spi_device_interface_config_t devcfg = {
        .command_bits = 8,
        .address_bits = 24,
        .mode = TFT_SPI_MODE,
        .clock_speed_hz = SPI_FREQUENCY,
        .spics_io_num = -1,
        // .spics_io_num = TFT_QSPI_CS,
        .flags = SPI_DEVICE_HALFDUPLEX,
        .queue_size = 17,
        .post_cb = spi_dma_cd,
    };
    ret = spi_bus_initialize(TFT_SPI_HOST, &buscfg, SPI_DMA_CH_AUTO);
    ESP_ERROR_CHECK(ret);
    ret = spi_bus_add_device(TFT_SPI_HOST, &devcfg, &spi);
    ESP_ERROR_CHECK(ret);

#else
    SPI.begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
    SPI.setFrequency(SPI_FREQUENCY);
    pinMode(TFT_DC, OUTPUT);
#endif
    // Initialize the screen multiple times to prevent initialization failure
    int i = 1;
    while (i--) {
#if LCD_USB_QSPI_DREVER == 1
        const lcd_cmd_t *lcd_init = axs15231b_qspi_init;
        for (int i = 0; i < sizeof(axs15231b_qspi_init) / sizeof(lcd_cmd_t); i++)
#else
        const lcd_cmd_t *lcd_init = axs15231_spi_init;
        for (int i = 0; i < sizeof(axs15231_spi_init) / sizeof(lcd_cmd_t); i++)
#endif
        {
            lcd_send_cmd(lcd_init[i].cmd,
                         (uint8_t *)lcd_init[i].data,
                         lcd_init[i].len & 0x3f);

            if (lcd_init[i].len & 0x80)
                delay(200);
            if (lcd_init[i].len & 0x40)
                delay(20);
        }
    }
}

void lcd_setRotation(uint8_t r)
{
    uint8_t gbr = TFT_MAD_RGB;

    switch (r) {
    case 0: // Portrait
        // WriteData(gbr);
        break;
    case 1: // Landscape (Portrait + 90)
        gbr = TFT_MAD_MX | TFT_MAD_MV | gbr;
        break;
    case 2: // Inverter portrait
        gbr = TFT_MAD_MX | TFT_MAD_MY | gbr;
        break;
    case 3: // Inverted landscape
        gbr = TFT_MAD_MV | TFT_MAD_MY | gbr;
        break;
    }
    lcd_send_cmd(TFT_MADCTL, &gbr, 1);
}

void lcd_address_set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
{
    lcd_cmd_t t[3] = {
        {0x2a, {(uint8_t)(x1 >> 8), (uint8_t)x1, uint8_t(x2 >> 8), (uint8_t)(x2)}, 0x04},
        {0x2b, {(uint8_t)(y1 >> 8), (uint8_t)(y1), (uint8_t)(y2 >> 8), (uint8_t)(y2)}, 0x04},
    };

    for (uint32_t i = 0; i < 2; i++) {
        lcd_send_cmd(t[i].cmd, t[i].data, t[i].len);
    }
}

void lcd_fill(uint16_t xsta,
              uint16_t ysta,
              uint16_t xend,
              uint16_t yend,
              uint16_t color)
{

    uint16_t w = xend - xsta;
    uint16_t h = yend - ysta;
    uint16_t *color_p = (uint16_t *)heap_caps_malloc(w * h * 2, MALLOC_CAP_INTERNAL);
    int i = 0;
    for(i = 0; i < w * h ; i+=1)
    {
        color_p[i] = color;
    }

    lcd_PushColors(xsta, ysta, w, h, color_p);
    free(color_p);
}

void lcd_DrawPoint(uint16_t x, uint16_t y, uint16_t color)
{
    lcd_address_set(x, y, x + 1, y + 1);
    lcd_PushColors(&color, 1);
}

void spi_device_queue_trans_fun(spi_device_handle_t handle, spi_transaction_t *trans_desc, TickType_t ticks_to_wait)
{
    ESP_ERROR_CHECK(spi_device_queue_trans(spi, (spi_transaction_t *)trans_desc, portMAX_DELAY));
}

#ifdef LCD_SPI_DMA 
spi_transaction_ext_t t = {0};
void lcd_PushColors(uint16_t x,
                        uint16_t y,
                        uint16_t width,
                        uint16_t high,
                        uint16_t *data)
    {
        static bool first_send = 1;
        static uint16_t *p = (uint16_t *)data;
        static uint32_t transfer_num_old = 0;

        if(data != NULL && (width != 0) && (high != 0))
        {
            lcd_PushColors_len = width * high;
            p = (uint16_t *)data;
            first_send = 1;

            transfer_num = 0;
            lcd_address_set(x, y, x + width - 1, y + high - 1);
            TFT_CS_L;
        }

        for (int x = 0; x < (transfer_num_old - (transfer_num_old-(transfer_num_old-transfer_num))); x++) {
            spi_transaction_t *rtrans;
            esp_err_t ret = spi_device_get_trans_result(spi, &rtrans, portMAX_DELAY);
            if (ret != ESP_OK) {
            // ESP_LOGW(TAG, "1. transfer_num = %d", transfer_num_old);
            }
            assert(ret == ESP_OK);
        }
        transfer_num_old -= (transfer_num_old - (transfer_num_old-(transfer_num_old-transfer_num)));

        do {
            if(transfer_num >= 3 || ESP.getFreeHeap() <= 70000)
            {
                break;
            }
            size_t chunk_size = lcd_PushColors_len;

            memset(&t, 0, sizeof(t));
            if (first_send) {
                t.base.flags =
                    SPI_TRANS_MODE_QIO ;// | SPI_TRANS_MODE_DIOQIO_ADDR 
                t.base.cmd = 0x32 ;// 0x12 
                t.base.addr = 0x002C00;
                first_send = 0;
            } else {
                t.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
                            SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
                t.command_bits = 0;
                t.address_bits = 0;
                t.dummy_bits = 0;
            }
            if (chunk_size > SEND_BUF_SIZE) {
                chunk_size = SEND_BUF_SIZE;
            }
            t.base.tx_buffer = p;
            t.base.length = chunk_size * 16;

            lcd_spi_dma_write = true;

            transfer_num++;
            transfer_num_old++;
            lcd_PushColors_len -= chunk_size;
            esp_err_t ret;

            ESP_ERROR_CHECK(spi_device_queue_trans(spi, (spi_transaction_t *)&t, portMAX_DELAY));
            assert(ret == ESP_OK);

            p += chunk_size;
        } while (lcd_PushColors_len > 0);
    }
#if 0
    void lcd_PushColors(uint16_t x,
                        uint16_t y,
                        uint16_t width,
                        uint16_t high,
                        uint16_t *data)
    {
        bool first_send = 1;
        lcd_PushColors_len = width * high;
        uint16_t *p = (uint16_t *)data;

        spi_transaction_t *rtrans;

        for (int x = 0; x < transfer_num; x++) {
            esp_err_t ret = spi_device_get_trans_result(spi, &rtrans, portMAX_DELAY);
            if (ret != ESP_OK) {
            ESP_LOGW(TAG, "1. transfer_num = %d", transfer_num);
            }
            assert(ret == ESP_OK);
        }
        transfer_num = 0;

        lcd_address_set(x, y, x + width - 1, y + high - 1);
        TFT_CS_L;
        do {
            size_t chunk_size = lcd_PushColors_len;
            spi_transaction_ext_t t = {0};
            memset(&t, 0, sizeof(t));
            if (first_send) {
                t.base.flags =
                    SPI_TRANS_MODE_QIO /* | SPI_TRANS_MODE_DIOQIO_ADDR */;
                t.base.cmd = 0x32 /* 0x12 */;
                t.base.addr = 0x002C00;
                first_send = 0;
            } else {
                t.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
                            SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
                t.command_bits = 0;
                t.address_bits = 0;
                t.dummy_bits = 0;
            }
            if (chunk_size > SEND_BUF_SIZE) {
                chunk_size = SEND_BUF_SIZE;
            }
            t.base.tx_buffer = p;
            t.base.length = chunk_size * 16;

            lcd_spi_dma_write = true;

            transfer_num++;
            lcd_PushColors_len -= chunk_size;

            spi_device_queue_trans_fun(spi, (spi_transaction_t *)&t, portMAX_DELAY);

            p += chunk_size;
        } while (lcd_PushColors_len > 0);
    }
 #endif   
#else
    void lcd_PushColors(uint16_t x,
                        uint16_t y,
                        uint16_t width,
                        uint16_t high,
                        uint16_t *data)
    {
    #if LCD_USB_QSPI_DREVER == 1
        bool first_send = 1;
        size_t len = width * high;
        uint16_t *p = (uint16_t *)data;

        lcd_address_set(x, y, x + width - 1, y + high - 1);
        
        do {

            TFT_CS_L;
            size_t chunk_size = len;
            spi_transaction_ext_t t = {0};
            memset(&t, 0, sizeof(t));
            if (1) {
                t.base.flags =
                    SPI_TRANS_MODE_QIO /* | SPI_TRANS_MODE_DIOQIO_ADDR */;
                t.base.cmd = 0x32 /* 0x12 */;
                if(first_send)
                {
                    t.base.addr = 0x002C00;
                }
                else 
                    t.base.addr = 0x003C00;
                first_send = 0;
            } else {
                t.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
                            SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
                t.command_bits = 0;
                t.address_bits = 0;
                t.dummy_bits = 0;
            }
            if (chunk_size > SEND_BUF_SIZE) {
                chunk_size = SEND_BUF_SIZE;
            }
            t.base.tx_buffer = p;
            t.base.length = chunk_size * 16;
            int aaa = 0;
            aaa = aaa>>1;
            aaa = aaa>>1;
            aaa = aaa>>1;
            if(!first_send)
                TFT_CS_H;
            aaa = aaa>>1;
            aaa = aaa>>1;
            aaa = aaa>>1;
            aaa = aaa>>1;
            aaa = aaa>>1;
            TFT_CS_L;
            aaa = aaa>>1;
            aaa = aaa>>1;
            aaa = aaa>>1;
            spi_device_polling_transmit(spi, (spi_transaction_t *)&t);
            len -= chunk_size;
            p += chunk_size;
        } while (len > 0);
        TFT_CS_H;

    #else
        lcd_address_set(x, y, x + width - 1, y + high - 1);
        TFT_CS_L;
        SPI.beginTransaction(SPISettings(SPI_FREQUENCY, MSBFIRST, TFT_SPI_MODE));
        
        SPI.writeBytes((uint8_t *)data, width * high * 2);
        SPI.endTransaction();
        TFT_CS_H;
    #endif
    }
#endif

void lcd_PushColors(uint16_t *data, uint32_t len)
{
#if LCD_USB_QSPI_DREVER == 1
    bool first_send = 1;
    uint16_t *p = (uint16_t *)data;
    TFT_CS_L;
    do {
        size_t chunk_size = len;
        spi_transaction_ext_t t = {0};
        memset(&t, 0, sizeof(t));
        if (first_send) {
            t.base.flags =
                SPI_TRANS_MODE_QIO /* | SPI_TRANS_MODE_DIOQIO_ADDR */;
            t.base.cmd = 0x32 /* 0x12 */;
            t.base.addr = 0x002C00;
            first_send = 0;
        } else {
            t.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
                           SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
            t.command_bits = 0;
            t.address_bits = 0;
            t.dummy_bits = 0;
        }
        if (chunk_size > SEND_BUF_SIZE) {
            chunk_size = SEND_BUF_SIZE;
        }
        t.base.tx_buffer = p;
        t.base.length = chunk_size * 16;

        spi_device_polling_transmit(spi, (spi_transaction_t *)&t);
        len -= chunk_size;
        p += chunk_size;
    } while (len > 0);
    TFT_CS_H;

#else
    TFT_CS_L;
    SPI.beginTransaction(SPISettings(SPI_FREQUENCY, MSBFIRST, TFT_SPI_MODE));
     
    SPI.writeBytes((uint8_t *)data, len * 2);
    SPI.endTransaction();
    TFT_CS_H;
#endif
}

void lcd_sleep()
{
    lcd_send_cmd(0x10, NULL, 0);
}

#pragma once

#include "stdint.h"
#include "pins_config.h"
#include "lvgl.h"/* https://github.com/lvgl/lvgl.git */

#define LCD_SPI_DMA 
#define AX15231B

#define TFT_MADCTL 0x36
#define TFT_MAD_MY 0x80
#define TFT_MAD_MX 0x40
#define TFT_MAD_MV 0x20
#define TFT_MAD_ML 0x10
#define TFT_MAD_BGR 0x08
#define TFT_MAD_MH 0x04
#define TFT_MAD_RGB 0x00

#define TFT_INVOFF 0x20
#define TFT_INVON 0x21

#define TFT_SCK_H digitalWrite(TFT_SCK, 1);
#define TFT_SCK_L digitalWrite(TFT_SCK, 0);
#define TFT_SDA_H digitalWrite(TFT_MOSI, 1);
#define TFT_SDA_L digitalWrite(TFT_MOSI, 0);

#define TFT_RES_H digitalWrite(TFT_QSPI_RST, 1);
#define TFT_RES_L digitalWrite(TFT_QSPI_RST, 0);
#define TFT_DC_H digitalWrite(TFT_DC, 1);
#define TFT_DC_L digitalWrite(TFT_DC, 0);
#define TFT_CS_H digitalWrite(TFT_QSPI_CS, 1);
#define TFT_CS_L digitalWrite(TFT_QSPI_CS, 0);

typedef struct
{
    uint8_t cmd;
    uint8_t data[36];
    uint8_t len;
} lcd_cmd_t;

void axs15231_init(void);

// Set the display window size
void lcd_address_set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2);
void lcd_setRotation(uint8_t r);
void lcd_DrawPoint(uint16_t x, uint16_t y, uint16_t color);
void lcd_fill(uint16_t xsta,
              uint16_t ysta,
              uint16_t xend,
              uint16_t yend,
              uint16_t color);
void lcd_PushColors(uint16_t x,
                    uint16_t y,
                    uint16_t width,
                    uint16_t high,
                    uint16_t *data);
void lcd_PushColors(uint16_t *data, uint32_t len);
void lcd_sleep();

bool get_lcd_spi_dma_write(void);

#pragma once
#include <Arduino.h>

// 5x7 font: uppercase, lowercase, numbers, and space
// Index: ' ' = 0, 'A' = 1, ..., 'Z' = 26, 'a' = 27, ..., 'z' = 52, '0' = 53, ..., '9' = 62
const uint8_t fontFull[63][5] PROGMEM = {
  {0x00,0x00,0x00,0x00,0x00}, // space

  // Uppercase A-Z
  {0x7C,0x12,0x11,0x12,0x7C}, // A
  {0x7F,0x49,0x49,0x49,0x36}, // B
  {0x3E,0x41,0x41,0x41,0x22}, // C
  {0x7F,0x41,0x41,0x22,0x1C}, // D
  {0x7F,0x49,0x49,0x49,0x41}, // E
  {0x7F,0x09,0x09,0x09,0x01}, // F
  {0x3E,0x41,0x49,0x49,0x7A}, // G
  {0x7F,0x08,0x08,0x08,0x7F}, // H
  {0x00,0x41,0x7F,0x41,0x00}, // I
  {0x20,0x40,0x41,0x3F,0x01}, // J
    {0x7F,0x08,0x14,0x22,0x41}, // K
  {0x7F,0x40,0x40,0x40,0x40}, // L
  {0x7F,0x02,0x0C,0x02,0x7F}, // M
  {0x7F,0x04,0x08,0x10,0x7F}, // N
  {0x3E,0x41,0x41,0x41,0x3E}, // O
  {0x7F,0x09,0x09,0x09,0x06}, // P
  {0x3E,0x41,0x51,0x21,0x5E}, // Q
  {0x7F,0x09,0x19,0x29,0x46}, // R
  {0x26,0x49,0x49,0x49,0x32}, // S
  {0x01,0x01,0x7F,0x01,0x01}, // T
  {0x3F,0x40,0x40,0x40,0x3F}, // U
  {0x1F,0x20,0x40,0x20,0x1F}, // V
  {0x3F,0x40,0x38,0x40,0x3F}, // W
  {0x63,0x14,0x08,0x14,0x63}, // X
  {0x07,0x08,0x70,0x08,0x07}, // Y
  {0x61,0x51,0x49,0x45,0x43}, // Z

  // Lowercase a-z
  {0x20,0x54,0x54,0x54,0x78}, // a
  {0x7F,0x48,0x44,0x44,0x38}, // b
  {0x38,0x44,0x44,0x44,0x20}, // c
  {0x38,0x44,0x44,0x48,0x7F}, // d
  {0x38,0x54,0x54,0x54,0x18}, // e
  {0x08,0x7E,0x09,0x01,0x02}, // f
  {0x0C,0x52,0x52,0x52,0x3E}, // g
  {0x7F,0x08,0x04,0x04,0x78}, // h
  {0x00,0x44,0x7D,0x40,0x00}, // i
  {0x20,0x40,0x44,0x3D,0x00}, // j
  {0x7F,0x10,0x28,0x44,0x00}, // k
  {0x00,0x41,0x7F,0x40,0x00}, // l
  {0x7C,0x04,0x18,0x04,0x78}, // m
  {0x7C,0x08,0x04,0x04,0x78}, // n
  {0x38,0x44,0x44,0x44,0x38}, // o
  {0x7C,0x14,0x14,0x14,0x08}, // p
  {0x08,0x14,0x14,0x18,0x7C}, // q
  {0x7C,0x08,0x04,0x04,0x08}, // r
  {0x48,0x54,0x54,0x54,0x20}, // s
  {0x04,0x3F,0x44,0x40,0x20}, // t
  {0x3C,0x40,0x40,0x20,0x7C}, // u
  {0x1C,0x20,0x40,0x20,0x1C}, // v
  {0x3C,0x40,0x30,0x40,0x3C}, // w
  {0x44,0x28,0x10,0x28,0x44}, // x
  {0x0C,0x50,0x50,0x50,0x3C}, // y
  {0x44,0x64,0x54,0x4C,0x44}, // z

  // Numbers 0-9 (corrected)
  {0x3E,0x51,0x49,0x45,0x3E}, // 0
  {0x00,0x42,0x7F,0x40,0x00}, // 1
  {0x62,0x51,0x49,0x49,0x46}, // 2
  {0x22,0x41,0x49,0x49,0x36}, // 3
  {0x18,0x14,0x12,0x7F},       // 4
  {0x2F,0x49,0x49,0x49,0x31}, // 5
  {0x3E,0x49,0x49,0x49,0x32}, // 6
  {0x01,0x71,0x09,0x05,0x03}, // 7
  {0x36,0x49,0x49,0x49,0x36}, // 8
  {0x26,0x49,0x49,0x49,0x3E}  // 9
};

// Helper functions
inline uint8_t fontFull_getWidth(char c) {
  return 5; // fixed width 5px
}

inline const uint8_t* fontFull_getBitmap(char c) {
  if (c == ' ') return fontFull[0];
  if (c >= 'A' && c <= 'Z') return fontFull[1 + c - 'A'];
  if (c >= 'a' && c <= 'z') return fontFull[27 + c - 'a'];
  if (c >= '0' && c <= '9') return fontFull[53 + c - '0'];
  return fontFull[0]; // fallback space
}

#pragma once

/***********************config*************************/
#define LCD_USB_QSPI_DREVER   1

#define SPI_FREQUENCY           32000000
#define TFT_SPI_MODE          SPI_MODE0
#define TFT_SPI_HOST          SPI2_HOST

#define WIFI_SSID             "xinyuandianzi"
#define WIFI_PASSWORD         "AA15994823428"

#define WIFI_CONNECT_WAIT_MAX (30 * 1000)

#define NTP_SERVER1           "pool.ntp.org"
#define NTP_SERVER2           "time.nist.gov"
#define GMT_OFFSET_SEC        0
#define DAY_LIGHT_OFFSET_SEC  0

/* Automatically update local time */
#define GET_TIMEZONE_API      "https://ipapi.co/timezone/"

/***********************config*************************/

#define TFT_WIDTH             180
#define TFT_HEIGHT            640

#ifdef TFT_WIDTH
#define EXAMPLE_LCD_H_RES     TFT_WIDTH
#else
#define EXAMPLE_LCD_H_RES     180
#endif
#ifdef TFT_HEIGHT
#define EXAMPLE_LCD_V_RES     TFT_HEIGHT
#else
#define EXAMPLE_LCD_V_RES     640
#endif
#define LVGL_LCD_BUF_SIZE     (EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES)

#define SEND_BUF_SIZE         (28800/2) //16bit(RGB565)

#define TFT_QSPI_CS           12
#define TFT_QSPI_SCK          17
#define TFT_QSPI_D0           13
#define TFT_QSPI_D1           18
#define TFT_QSPI_D2           21
#define TFT_QSPI_D3           14
#define TFT_QSPI_RST          16
#define TFT_BL                1


#define PIN_BAT_VOLT          2

#define PIN_BUTTON_1          0
#define PIN_BUTTON_2          21