Can the GC9A01 Driver be added?

[wingedwarrior64]

@kdschlosser :

Is there any way to add the GC9A01 Driver to your repository? Or is there a better way to do this? I am going to be completely honest, I am brand new to ESP32s and LVGL and I am completely lost. GC-RmG from the LVGL forum said you were the guy to talk to. I started this thread in the LVGL Forum: https://forum.lvgl.io/t/i-am-so-lost-how-in-the-actual-do-you-use-this-thing/17010/2. In case you're wondering just how lost and new I am, that'll give you some background. I still haven't figured out how to create my custom firmware... so there's that... Any help would be greatly appreciated. Thank you.

[kdschlosser]

that driver is already added...

add DISPLAY=gc8a01 to your build command...

To use you would add code similar to what is below to your main.py file that gets uploaded to the device.

import gc9a01

display = gc9a01.GC9801(
    data bus,
    width,
    height,
    ...
)

[kdschlosser]

OK so to create your own firmware I need to know what OS you are using..

[wingedwarrior64]

I might have misused the phrase "create my custom firmware." I am simply trying to get LVGL onto my ESP32. I am using a generic ESP32-D0WD-V3. I was using WSL on Windows, however, I downloaded virtual box and Unbuntu today and I have installed build-essential, cmake, ninja-build and python. That is as far as I have gotten. I am about to download your github file then try and figure the rest out.

[wingedwarrior64]

esptool.py v4.7.0
Serial port COM4
Connecting....
Detecting chip type... Unsupported detection protocol, switching and trying again...
Connecting.....
Detecting chip type... ESP32
Chip is ESP32-D0WD-V3 (revision v3.1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: b0:a7:32:29:1e:f0
Uploading stub...
Running stub...
Stub running...
Manufacturer: 5e
Device: 4016
Detected flash size: 4MB

[kdschlosser]

OK so you are running under window and you have WSL.

I recommend using WSL. It is essentially the same thing as Virtual Box except it is not as isolated from the host OS.

sudo apt-get install build-essential cmake ninja-build python git
cd ~
git clone https://github.com/lvgl-micropython/lvgl_micropython
cd lvgl_micropython
python3 make.py esp32 submodules mpy_cross flash-size=4 DISPLAY=gc9a01 

[kdschlosser]

I opened up an issue on EEZ Studio's repo about adding support.

[wingedwarrior64]

I opened up an issue on EEZ Studio's repo about adding support.

Have you heard anything back?

So far I am not having any luck getting a simple meter example to display on my gc9a01. Here's the code I have so far.
'
from machine import Pin, PWM, ADC
import time

Configure ADC for throttle input

throttle_pin = Pin(34)
adc = ADC(throttle_pin)
adc.atten(ADC.ATTN_11DB)

Configure PWM for ESC control

esc_pin = Pin(33) # Changed to ESC pin 33
esc_pwm = PWM(esc_pin, freq=50, duty=0)

Configure digital input for switched voltage on pin 17

switched_voltage_pin = Pin(17, Pin.IN)

Configure RPM sensor input on pin 16

rpm_sensor_pin = Pin(16, Pin.IN)

Variables to track pulses and time

pulse_count = 0
last_time = time.ticks_ms()

Interrupt handler to count pulses

def handle_rpm_interrupt(pin):
global pulse_count
pulse_count += 1

Attach interrupt to RPM sensor pin (rising edge detection)

rpm_sensor_pin.irq(trigger=Pin.IRQ_RISING, handler=handle_rpm_interrupt)

def map_range(value, in_min, in_max, out_min, out_max):
return int((value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

def calculate_rpm():
global pulse_count, last_time

# Calculate time elapsed since last calculation
current_time = time.ticks_ms()
elapsed_time = time.ticks_diff(current_time, last_time)

# Time in seconds
elapsed_seconds = elapsed_time / 1000

# RPM calculation based on pulses and elapsed time
if elapsed_seconds > 0:
    rpm = ((pulse_count/ 2) / elapsed_seconds) * 60  # Assuming 1 pulse per revolution
else:
    rpm = 0

# Reset pulse count and time
pulse_count = 0
last_time = current_time

return rpm

while True:
# Read switched voltage at pin 17
switched_voltage = switched_voltage_pin.value() * 3.3

# Read throttle input voltage
throttle_voltage = adc.read() / 4095 * 3.3

# Set pulse width based on throttle voltage
if throttle_voltage < 0.87:
    pulse_width = 1000
elif throttle_voltage > 2.3:
    pulse_width = 2000
else:
    pulse_width = map_range(throttle_voltage, 0.87, 2.3, 1000, 2000)

# Set ESC pulse width directly
esc_pwm.freq(50)  # Set frequency to 50Hz
esc_pwm.duty_ns(pulse_width * 1000)  # Set pulse width in nanoseconds

# Calculate RPM
rpm = calculate_rpm()

# Print results
print("Throttle Voltage: {:.2f}V, Pin 17 Voltage: {:.2f}V, Pulse Width: {} microseconds, Frequency: {}Hz, RPM: {:.2f}".format(throttle_voltage, switched_voltage, pulse_width, esc_pwm.freq(), rpm))

time.sleep(0.1)

'

I'm not sure sure what to from here. This is what was returned in the terminal on Thonny.

MPY: soft reboot Traceback (most recent call last): File "<stdin>", line 9, in <module> TypeError: can't create 'SPI' instances

[kdschlosser]

do me a favor.. wrap your code blocks in triple back ticks

```
Code Here
```

which looks like this..

Code Here

[wingedwarrior64]

from machine import Pin, PWM, ADC, SPI
import time
import gc9a01
import lvgl as lv

##### SPI and Display Configuration #####

# Initialize SPI with appropriate bus and pins
spi = SPI(2, baudrate=40000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(23), miso=Pin(19)) 

# Pin assignments for the display (adjust to match your wiring)
cs_pin = Pin(15, Pin.OUT)   # Chip select pin (color: XXX)
dc_pin = Pin(17, Pin.OUT)   # Data/Command pin (color: XXX)
rst_pin = Pin(16, Pin.OUT)  # Reset pin (color: XXX)

# Initialize the GC9A01 display
display = gc9a01.GC9A01(
    spi,                      # SPI bus
    width=240,                 # Display width
    height=240,                # Display height
    cs=cs_pin,                 # Chip select pin
    dc=dc_pin,                 # Data/Command pin
    rst=rst_pin,               # Reset pin
    rotations=0                # Optional: Adjust display rotation if needed
)

# Clear the display and fill with black
display.init()
display.fill(gc9a01.color.BLACK)

##### Gauge Meter Configuration #####
import lvgl as lv

def set_value(indic, v):
    meter.set_indicator_value(indic, v)

# A simple meter
meter = lv.meter(lv.scr_act())
meter.center()
meter.set_size(240, 240)

# Add a scale first
scale = meter.add_scale()
meter.set_scale_ticks(scale, 51, 2, 10, lv.palette_main(lv.PALETTE.GREY))
meter.set_scale_major_ticks(scale, 10, 4, 15, lv.color_black(), 10)

indic = lv.meter_indicator_t()

# Add a blue arc to the start
indic = meter.add_arc(scale, 3, lv.palette_main(lv.PALETTE.BLUE), 0)
meter.set_indicator_start_value(indic, 0)
meter.set_indicator_end_value(indic, 20)

# Make the tick lines blue at the start of the scale
indic = meter.add_scale_lines(scale, lv.palette_main(lv.PALETTE.BLUE), lv.palette_main(lv.PALETTE.BLUE), False, 0)
meter.set_indicator_start_value(indic, 0)
meter.set_indicator_end_value(indic, 20)

# Add a red arc to the end
indic = meter.add_arc(scale, 3, lv.palette_main(lv.PALETTE.RED), 0)
meter.set_indicator_start_value(indic, 80)
meter.set_indicator_end_value(indic, 100)

# Make the tick lines red at the end of the scale
indic = meter.add_scale_lines(scale, lv.palette_main(lv.PALETTE.RED), lv.palette_main(lv.PALETTE.RED), False, 0)
meter.set_indicator_start_value(indic, 80)
meter.set_indicator_end_value(indic, 100)

# Add a needle line indicator
indic = meter.add_needle_line(scale, 4, lv.palette_main(lv.PALETTE.GREY), -10)

# Create an animation to set the value
a = lv.anim_t()
a.init()
a.set_var(indic)
a.set_values(0, 100)
a.set_time(2000)
a.set_repeat_delay(100)
a.set_playback_time(500)
a.set_playback_delay(100)
a.set_repeat_count(lv.ANIM_REPEAT.INFINITE)
a.set_custom_exec_cb(lambda a, val: set_value(indic, val))
lv.anim_t.start(a)

##### RPM and ESC Control Configuration #####

# Configure ADC for throttle input
throttle_pin = Pin(34)
adc = ADC(throttle_pin)
adc.atten(ADC.ATTN_11DB)

# Configure PWM for ESC control
esc_pin = Pin(33)  # Changed to ESC pin 33
esc_pwm = PWM(esc_pin, freq=50, duty=0)

# Configure digital input for switched voltage on pin 17
switched_voltage_pin = Pin(17, Pin.IN)

# RPM sensor setup
rpm_pin = Pin(35, Pin.IN)

def map_range(value, in_min, in_max, out_min, out_max):
    return int((value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

def measure_rpm():
    pulse_count = 0
    start_time = time.ticks_ms()
    
    # Measure pulses for 1 second
    while time.ticks_diff(time.ticks_ms(), start_time) < 1000:
        pulse_count += rpm_pin.value()  # Count rising edges
    
    return pulse_count * 30  # Convert pulses to RPM (assuming two pulses per revolution)

while True:
    # Read switched voltage at pin 17
    switched_voltage = switched_voltage_pin.value() * 3.3

    # Read throttle input voltage
    throttle_voltage = adc.read() / 4095 * 3.3

    # Set pulse width based on throttle voltage
    if throttle_voltage < 0.87:
        pulse_width = 1000
    elif throttle_voltage > 2.3:
        pulse_width = 2000
    else:
        pulse_width = map_range(throttle_voltage, 0.87, 2.3, 1000, 2000)

    # Set ESC pulse width directly
    esc_pwm.freq(50)  # Set frequency to 50Hz
    esc_pwm.duty_ns(pulse_width * 1000)  # Set pulse width in nanoseconds

    # Measure RPM
    rpm = measure_rpm()

    # Update the meter display with RPM value
    meter.set_indicator_value(indic, rpm // 100)

    print("Throttle Voltage: {:.2f}V, Pin 17 Voltage: {:.2f}V, Pulse Width: {} microseconds, RPM: {}".format(throttle_voltage, switched_voltage, pulse_width, rpm))

    time.sleep(0.1)

[kdschlosser]

ok you need to read the readme file it will tell you how to use the drivers and how to build the binding so it will work.