How to use a 1.3 inch IPS screen in a drone?
To integrate a 1.3 inch IPS screen into a drone, you wire it directly to the flight controller or a separate microcontroller like an ESP32 or STM32, using the SPI interface for real-time data display. This isn’t just a cool add-on; it’s a practical tool for telemetry, camera feed, or even a custom OSD (on-screen display). The 1.3 inch 240x240 ips display is a solid choice because of its high pixel density (about 261 PPI), wide viewing angles (typically 160 degrees), and low power draw—around 20-40 mA at 3.3V, which is critical for battery-powered drones. You’ll need to decide on the data source: a direct connection to a Pixhawk or Betaflight flight controller for telemetry, or a secondary MCU for more complex tasks like video overlays.
Let’s break down the hardware side first. The display uses a 4-wire SPI protocol (SCK, MOSI, DC, CS) plus a reset pin, running at up to 20 MHz. On a typical drone, the flight controller’s UART or I2C ports are often occupied, but SPI is usually free on most boards. For example, on a Pixhawk 4, you can use the SPI1 port (pins 11-14) for the screen, but you’ll need to map the pins in the firmware. Data speed matters: at 20 MHz SPI, you can refresh the 240x240 frame (57,600 pixels) at over 100 Hz, which is overkill for telemetry but useful for smooth video. Power consumption is a key factor: the display draws 0.08W at 3.3V, compared to a typical FPV camera’s 0.5W. This means you can run it for hours on a 3S 2200mAh LiPo without significant drain. However, you must include a 3.3V regulator (like the AMS1117-3.3) if your flight controller’s 5V rail is noisy—common on drones with ESCs that cause voltage spikes up to 5.5V.
Now, the software side. For a drone, the most common approach is to use the MSP (MultiWii Serial Protocol) or MAVLink to pull telemetry data from the flight controller. With Betaflight, you can enable the display on a spare UART (e.g., UART3) using the “displayport” feature. For example, on a F4 flight controller, you’d set “displayport = MSP” and “displayport_serial = 3” in the CLI, then wire the display’s SPI to the MCU’s SPI pins. The refresh rate for telemetry data (altitude, speed, battery voltage) is typically 10-50 Hz, which the display handles easily. If you’re using a Pixhawk with ArduPilot, you can output MAVLink data via a serial port to a secondary MCU (like an ESP32), which then drives the display. The ESP32 can handle both WiFi (for telemetry logging) and SPI simultaneously, using its dual-core processor. A typical setup: ESP32 reads MAVLink at 115200 baud, parses the data, and updates the display at 20 FPS. The 240x240 resolution is enough to show 6-8 lines of text (using a 24-pixel font) or a simple gauge for battery voltage.
For video feed, things get trickier. The 1.3 inch IPS screen has a 240x240 resolution, but it’s not designed for analog video (like NTSC/PAL). You’d need a digital video stream, such as from a camera module like the OV2640 (2MP) connected to an ESP32-CAM. The ESP32 can capture JPEG frames, downsample them to 240x240, and send them via SPI to the display. This requires a fast SPI bus (20 MHz) and a buffer of at least 115 KB (240x240x2 bytes for RGB565). The frame rate will be limited to about 10-15 FPS due to JPEG decoding and SPI transfer time. For comparison, a dedicated FPV system runs at 30 FPS, but for a secondary display (e.g., for a co-pilot or ground station), 10 FPS is acceptable. Power consumption here jumps: the ESP32-CAM draws 150-200 mA, plus the display’s 20-40 mA, totaling 0.7-0.8W—still manageable for a drone with a 10A flight battery.
Mounting the display is also a practical consideration. The screen measures 29.5mm x 29.5mm (including the PCB), with a thickness of 3.5mm. It weighs about 5 grams, which is negligible for most drones (a 5-inch quad weighs 250-300g). You can mount it on the top plate using double-sided tape or a 3D-printed bracket, but keep it away from the GPS module (if you have one) to avoid magnetic interference. The display’s operating temperature range is -20°C to +70°C, which covers most flying conditions, but direct sunlight can cause glare due to the IPS’s glossy surface. A matte screen protector or a hood can help. For vibration damping, use silicone pads between the display and the frame—drone vibrations (50-200 Hz from motors) can cause pixel flickering if the connection is loose.
Here’s a quick comparison of display options for drones:
| Parameter | 1.3 inch IPS (240x240) | 0.96 inch OLED (128x64) | 2.4 inch TFT (320x240) |
|---|---|---|---|
| Resolution | 240x240 | 128x64 | 320x240 |
| Pixel Density | 261 PPI | 150 PPI | 166 PPI |
| Power (3.3V) | 20-40 mA | 15-25 mA | 50-80 mA |
| Refresh Rate | 100 Hz (SPI) | 60 Hz (I2C) | 60 Hz (SPI) |
| Weight | 5g | 3g | 12g |
| Viewing Angle | 160 degrees | 160 degrees | 120 degrees |
| Cost | $8-12 | $5-8 | $15-20 |
The 1.3 inch IPS strikes a balance between readability and power efficiency. For telemetry, the 240x240 resolution lets you show 8-10 data fields (e.g., voltage, current, altitude, speed, GPS satellites, RSSI, flight mode, distance) without scrolling. For example, using a 16-pixel font, you can fit 15 characters per line and 15 lines, which is more than enough. On a 0.96 inch OLED, you’d only get 8 characters per line and 8 lines, which is cramped. The IPS also has better color reproduction (65K colors vs. OLED’s monochrome), which helps with contrast in sunlight. However, the OLED has a faster response time (0.1ms vs. 5ms for IPS), but for static telemetry, this doesn’t matter.
For a practical build, I’ll walk through a specific example using a Matek F405-WING flight controller (common in fixed-wing drones but also used in quads). The F405 has a dedicated SPI bus (SPI1) on pins PA5 (SCK), PA7 (MOSI), PA4 (CS), and PA6 (MISO—though not used for the display). You’ll need to solder wires to the display’s 8-pin header (0.5mm pitch, so use a fine tip iron). The pinout: 1-GND, 2-VCC (3.3V), 3-SCK, 4-MOSI, 5-DC, 6-RESET, 7-CS, 8-BL (backlight). Connect BL to 3.3V through a 100-ohm resistor to limit current to 20 mA. In ArduPilot firmware, enable the “DISPLAY” feature and set “DISPLAY_TYPE = 1” (for SPI). Then, in the “DISPLAY_SPI_CS” parameter, set the CS pin number (e.g., 4 for PA4). The screen will show flight data like battery voltage (e.g., 12.6V), altitude (e.g., 50m), and GPS coordinates. The refresh rate is set by the “DISPLAY_RATE” parameter, defaulting to 5 Hz, which is fine for telemetry.
If you’re using a Betaflight setup, the process is similar but uses the “displayport” system. On a STM32F405 board (like the Holybro Kakute F7), you can map the display to a free SPI bus. For example, on the F7, SPI2 is on PB13 (SCK), PB15 (MOSI), and PB12 (CS). In the CLI, set “resource SPI_SCK 2 B13”, “resource SPI_MOSI 2 B15”, and “resource SPI_CS 2 B12”. Then, enable the display with “feature display” and “displayport = MSP”. The screen will show Betaflight’s OSD elements, like artificial horizon, throttle position, and battery warning. The OSD is rendered at 30 FPS, which the display can handle, but the SPI bus speed must be at least 10 MHz to avoid flickering. A common issue is that the display’s SPI clock line can pick up noise from the drone’s power lines (especially from ESCs), causing data corruption. To fix this, add a 10-ohm resistor in series with the SCK line and a 100pF capacitor to ground—this filters out high-frequency noise up to 50 MHz.
Another angle is using the display as a secondary FPV monitor for a ground station. In this case, you’d pair it with a Raspberry Pi Zero 2W (which draws 0.4W) and a WiFi dongle. The Pi receives the drone’s telemetry via UDP (from a MAVLink-to-WiFi bridge like the Holybro Telemetry Radio), then renders the data on the display using Python and the PIL library. The 240x240 resolution is enough for a simple dashboard: a battery gauge (0-100%) as a bar, a compass rose, and a speed indicator. The Pi’s SPI speed is limited to 32 MHz, but the display’s controller (ST7789) can handle it. A typical Python script uses the “spidev” library and writes 57,600 bytes per frame (240x240x1 for 8-bit color). At 20 FPS, that’s 1.15 MB/s, which is well within the SPI’s bandwidth. The Pi Zero 2W’s CPU load is about 30% for this task, leaving room for video recording or logging.
Durability is a concern for drones. The display’s glass is 0.5mm thick and can crack under hard landings. To protect it, use a 3D-printed bezel with a 1mm thick acrylic sheet on top. The bezel should have a cutout for the display (29.5mm x 29.5mm) and screw holes for mounting to the drone’s frame. The total weight of the bezel and screen is under 10g. For waterproofing, apply a conformal coating (like MG Chemicals 422B) to the display’s PCB, but avoid the glass area. This prevents short circuits from moisture or condensation during high-humidity flights. The display’s operating humidity range is 5-95% non-condensing, so coating is essential for rainy conditions.
For a more advanced setup, you can use the display for camera gimbal control. Connect a servo-driven gimbal (like the Tarot T-2D) to the flight controller, and display the gimbal’s pitch and roll angles on the screen. The data comes from the gimbal’s IMU (e.g., MPU6050) via I2C, and the flight controller forwards it to the display via SPI. The angles are updated at 100 Hz, but the display only needs to refresh at 10 Hz to show smooth movement. The 240x240 resolution lets you draw a 3D-style gimbal indicator (a circle with a crosshair) that’s readable from 30cm away. This is useful for aerial photography drones where you need to see the camera’s orientation without looking at the FPV feed.
Battery monitoring is another practical use. The display can show a voltage graph over time, using the flight controller’s ADC. For example, on a 4S LiPo (16.8V full), the ADC reads 0-3.3V through a voltage divider (4:1 ratio). The flight controller sends this data via MAVLink, and the display plots a 240-pixel-wide graph (e.g., 10 seconds of data at 24 samples per second). The graph uses the display’s 16-bit color depth to show a gradient from green (high voltage) to red (low voltage). This is more detailed than a simple percentage bar, and it helps you spot voltage sag during high-throttle maneuvers. The power draw for this feature is identical to telemetry mode, since the display is just refreshing the same area.
Finally, consider the firmware compatibility. Not all flight controllers have built-in support for SPI displays. For example, the popular Pixhawk 1 uses a 32-bit STM32F427, but its SPI pins are mapped to the external I2C port, which is not standard. You’d need to reflash the firmware with custom pin mappings, which is doable but requires a JTAG programmer. In contrast, the Matek H743-WING has a dedicated “Display” port with SPI pins, making it plug-and-play. If you’re using a custom MCU like an ESP32, you have full control. The ESP32’s SPI can be set to 40 MHz, but the display’s ST7789 controller maxes out at 20 MHz, so you’ll see no benefit beyond that. For most drones, a 10 MHz SPI clock is sufficient for 30 FPS video, and it reduces electromagnetic interference (EMI) compared to higher speeds. The 1.3 inch 240x240 ips display is a versatile component that fits into these workflows with minimal hassle.