gCore (II) - a dev board for portable GUI gadgets

A high-end ESP32 development board with a 480x320 pixel capacitive touchscreen and sophisticated features.

Similar projects worth following
Designing my own thermal imaging camera led me to design my own development board with a set of features that aren't usually present on other dev board that fit my needs. I've been working with Group Gets to make it available to others in a campaign. This project describes gCore in detail and will be a place where I document various gadgets created with it.

My vision for gCore is as a base for all kinds of portable devices utilizing a display or GUI. gCore provides a rich set of features aimed at allowing developers to focus on the unique functionality of their device while providing a polished solution with high performance graphics and file IO, great battery management and user-friendly features such as soft power control and automatic low-battery shutdown.

gCore uses the ESP32-WROVER-E module which has dual-CPU revision 3 ESP32 silicon, 16 MB Flash memory and 8 MB PSRAM.

High Performance LCD Capacitive Touchscreen Display

TFT 480x320 pixel LCD Display using ILI9488 controller configured to use a 8-bit parallel interface.  The parallel interface is driven by a shift register and other logic connected to the native ESP32 VSPI GPIO pins.  This allows code on the ESP32 to drive the SPI bus at the maximum 80 MHz (faster than the ILI9488 allows in SPI mode).   Bodmer's fantastic TFT_eSPI library has been ported and screams on gCore.  A FT6236 touchscreen controller allows up to two point touch detection.

Full Power Path Li-Ion Charger

gCore is powered by a 3.7V Li-Ion or LiPo battery (typ 500-4400 mA) or USB.  The battery connection uses the standard Adafruit/Sparkfun JST connector.  A Microchip MCP73871 charge controller provides a separate path for battery charging and for board power.  This ensures it can accurately determine charge completion and allow board power to be sourced from USB only when possible or shared between USB and battery power when necessary.  I wanted a full power path charging circuit because I've seen battery life problems with the dev boards that simply hang the board load directly on the battery connection with the both powered by the same charge controller output.  A jumper allows either a 500 mA or 1A maximum charge current selection.

Soft Power Control / RTC

gCore contains a Silicon Labs EFM8SB20F32 8-bit microcontroller that acts as a power manager (PMIC), provides a real-time clock (RTC) with alarm and NVRAM/NVFlash, and board control/monitoring control.  The ESP32 communicates with it over I2C.

  • The board can be powered on by a press on the power button, an alarm from the RTC or when charging is started or completed.  When powered the button has two functions.  It can act as a general purpose button with presses detectable by code running on the ESP32 or it can be held for five seconds to power off the board (like the long press on laptop power buttons).
  • Code running on the ESP32 can initiate a power off.  The EFM8 also switches power off for a critically low battery automatically (a warning status is available to the ESP32 before power is shut off).
  • Dimmable backlight control.  8-bit PWM dimming at 25 kHz.
  • The EFM8 provides 4096 bytes of NVRAM and 1024 bytes of flash accessible by the ESP32 via I2C for storing parameters when the ESP32 is powered off.
  • The EFM8 monitors battery voltage, load current, USB voltage and charge current.  It provides averaged and filtered values via the I2C bus to the ESP32.
  • Charge LED pulses when charging, turns solid when USB power is connected but charge is complete or blinks if there has been a charge error (for example timeout during charging).
  • SD Card insertion detection.  Status bit for ESP32 indicating presence of Micro-SD Card.

4-bit Micro-SD Card

All four bits of the Micro-SD Card connector are connected to the ESP32 allowing high performance 4-bit SD-mode access.  I've seen up to a 5.5X performance increase for large writes over the typical SPI-based SD Card interface.  The GPIO signals are also available on SMT pads if the SD Card is not being used.

USB Interface

A Silicon Labs CP2102N USB UART is connected to the ESP32 serial port and includes the traditional auto-programming (DTR/RTS) circuitry to put the ESP32 into boot mode.

Expansion Port

Unused ESP32 GPIO plus the GPIO used for the I2C interface are brought out to a connector along with both switched and un-switched 3.3V regulated outputs, a switched version of the battery rail, and other signals such as USB power and the power button signals for external circuits.   The I2C interface is also available on a Qwiic compatible connector for easy connection to peripheral devices from Sparkfun, Adafruit and others.

Software Support...

Read more »

  • Micropython and LVGL

    Dan Julioa day ago 0 comments

    LVGL supports a python binding and they provide a pair of repositories supporting it.  One contains the bindings and the other with the bindings as part of micropython.  There are even drivers for the ILI9488 LCD controller and FT6236 touchscreen controller used by gCore and since Micropython runs just fine on the ESP32 getting the lv_micropython build running on gCore is easy.  However there's room for an optimization that speeds drawing on gCore even more than the higher 80 MHz SPI clock.

    The ILI9488 chip supports multiple interfaces: 8- or 9-bit SPI, 8-, 16- or 24-bit parallel or DSI/MIPI parallel.  Most micro-based systems use the 4-wire SPI interface.  gCore uses the 8-bit parallel interface.  The chip also supports either 16-bit (RGB565) or 18-bit (RGB666) pixels, but only on the parallel interfaces.  When using the SPI interface directly the chip is limited to 18-bit pixels which must be loaded with 3 bytes (8-bits each for R, G and B).  This is why you'll see a lot of drivers with an extra step of converting data from 16-bits to 24-bits or from 32-bits down to 24-bits (as is done by the default driver in the lv_micropython repository).  This is a significant performance hit.  The "ili9488" class in the driver only supports LVGL in 32-bit (RGBA8888) mode and generates an error if LVGL is configured for 16-bit pixels.  But since gCore uses the parallel interface we can avoid this.  For this reason I modified the driver to include a new class "ili9488g" that implements the following optimizations (leaving the original ILI9488 class alone).

    1. Changed the default SPI peripheral to VSPI and default pins to match
    2. Set a default 80 MHz SPI bus frequency
    3. Added support for 16-bit pixels

    The new driver will work with LVGL compiled for either 16- or 32-bit pixels.  There is a noticeable speed-up when running with 16-bit pixels and not a lot of image degradation since the ILI9488 is really only capable of 18-bit pixels.

    I also got one of the demos running.

    One of the nice things about LVGL on Micropython is that it's really easy to use.  The REPL makes it great for experimentation too.  Just a few lines of code to get a GUI.  For example the following code initializes LVGL and both the touchscreen and LCD drivers, and then creates and displays a button.

    from ili9XXX import ili9488g
    from ft6x36 import ft6x36
    touch=ft6x36(0, 21, 22, 10000)

    The main github repository has been updated with instructions and the new driver.

  • Manufacturing test and programming fixture

    Dan Julio11/24/2022 at 03:09 0 comments

    The functional test and programming fixture is done and ready to send to the contract manufacturer.  It's a fairly simple piece of hardware with a bunch of software that, as usual, took me longer than I originally planned...  It has the following functionality

    • Functional hardware test
    • Program EFM8 firmware
    • Program the ESP32 with the calculator demo program (also used to verify the LCD and touchscreen functionality)

    The hardware uses a PJRC Teensy 3.2 as a local controller with software running on a PC and connects to the gCore using a set of pogo-pins.  A 3D printed mechanism holds the gCore down.  The Teensy reads various voltages, outputs digital signals that control a simulated battery, power button and USB power supply, interfaces to the gCore I2C bus and implements a programmer for the EFM8.  The ESP32 is programmed by the PC via USB.

    Originally I intended the switched USB connection to gCore to run through a pair of USB-C connectors on the test fixture PCB.  However I got some signals reversed so the connectors didn't work.  I ended up just splitting a USB cable open, cutting the +5 line and running that through the pair of P-channel MOSFETs on the test fixture used to turn Vusb on and off.  And holding the cable down with lots of glue.

    On the other hand the circuit I designed to simulate a LiPo battery worked really well.  The test fixture has to handle both a drain and charge of a simulated battery.  I looked into a dual quadrant power supply design but the complexity and cost put me off.  Then I realized all I really needed to test was that the charger IC put out current.  That could be implemented by simulating a battery at one voltage through a Schottky diode and then observing if the voltage went close to 4.2V when the charger was active when Vusb was energized.  The diode prevents back flow to the 4V regulator.

    In the circuit above, +5V is supplied by teensy and U2 is a 4V regulator enabled by the Teensy using BP_EN. The voltage is routed through D1 to V+ which is connected to the battery input.  When Vusb is supplied the charger IC on gCore will attempt to charge the battery to 4.2V.  A small load is provided via Q1 so the charger sees some current flow.  For a functional board V+ will jump from about 3.7-3.8 V to 4.1-4.2V when the charger is running and is sensed via A_BP_SNS.

    Software running on the Windows PC (and Mac, for me) was written in xojo.  The program encapsulates the pre-compiled esptool binary I found in the ESP32 Arduino package and binary files for both the EFM8 and ESP32.  Although it has a set of manual controls, during normal operation the operator only has to press Run and acknowledge one dialog box for each board.  Excluding the time to insert and remove a gCore the entire test and programming process takes around 20 seconds.

    I still have to write a document that correlates error messages with parts of the gCore for debugging of failed boards.

  • gCore intro video

    Dan Julio10/31/2022 at 20:03 0 comments

    Here's a video describing gCore.

  • Group Gets Campaign

    Dan Julio10/28/2022 at 20:17 0 comments

    I've been working with the fine folks at Group Gets to bring gCore to market.  Their initial campaign can be found here.

    gCore is a bit more expensive than some development boards due to the feature set requiring lots of ICs, and the fact it's being built in the USA but I think the value it brings makes up for the additional cost.  I know it will not be for everybody but I hope to empower those people who see the additional performance and features as worth a delta cost that's less than a night out on the town, forgotten in a few days time.

    As with all my projects, please feel free to send me questions here or via my email. 

View all 4 project logs

Enjoy this project?



Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates