I am not sure why there is an allocation of
536,934,808 bytes. 536MB of ram. That’s kind of a lot. LOL
It’s saying the error is occurring in a file named st7796.py but you have not provided any file by that name. So there is something that you are missing.
st7796.py
import time
import machine
import struct
import uctypes
from micropython import const
import lvgl as lv
ST77XX_CASET = const(0x2A)
ST77XX_RASET = const(0x2B)
ST77XX_RAMWR = const(0x2C)
ST77XX_MADCTL = const(0x36)
ST77XX_MADCTL_MY = const(0x80) # page address order (0: top to bottom; 1: bottom to top)
ST77XX_MADCTL_MX = const(0x40) # column address order (0: left to right; 1: right to left)
ST77XX_MADCTL_MV = const(0x20) # page/column order (0: normal mode 1; reverse mode)
ST77XX_MADCTL_ML = const(0x10) # line address order (0: refresh to to bottom; 1: refresh bottom to top)
ST77XX_MADCTL_BGR = const(0x08) # colors are BGR (not RGB)
_MADCTL_ROTS = (
const(ST77XX_MADCTL_MX), # 0 = portrait
const(ST77XX_MADCTL_MV), # 1 = landscape
const(ST77XX_MADCTL_MY), # 2 = inverted portrait
const(ST77XX_MADCTL_MX | ST77XX_MADCTL_MY | ST77XX_MADCTL_MV), # 3 = inverted landscape
)
ST77XX_COLOR_MODE_65K = const(0x50)
ST77XX_COLOR_MODE_262K = const(0x60)
ST77XX_COLOR_MODE_12BIT = const(0x03)
ST77XX_COLOR_MODE_16BIT = const(0x05)
ST77XX_COLOR_MODE_18BIT = const(0x06)
ST77XX_COLOR_MODE_16M = const(0x07)
DISPLAY_TYPE_ST7789 = const(4)
DISPLAY_TYPE_ILI9488 = const(2)
ST77XX_PORTRAIT = const(0)
ST77XX_LANDSCAPE = const(1)
ST77XX_INV_PORTRAIT = const(2)
ST77XX_INV_LANDSCAPE = const(3)
class St7796_hw(object):
def __init__(self, *, cs, dc, spi, res, suppRes, bl=None, model=None, suppModel=[], rst=None, rot=ST77XX_LANDSCAPE, bgr=False, rp2_dma=None):
'''
This is an abstract low-level driver the ST77xx controllers, not to be instantiated directly.
Derived classes implement chip-specific bits. THe following parameters are recognized:
* *cs*: chip select pin (= slave select, SS)
* *dc*: data/command pin
* *bl*: backlight PWM pin (optional)
* *model*: display model, to account for variations in products
* *rst*: optional reset pin
* *res*: resolution tuple; (width,height) with zero rotation
* *rot*: display orientation (0: portrait, 1: landscape, 2: inverted portrait, 3: inverted landscape); the constants ST77XX_PORTRAIT, ST77XX_LANDSCAPE, ST77XX_INV_POTRAIT, ST77XX_INV_LANDSCAPE may be used.
* *bgr*: color order if BGR (not RGB)
* *rp2_dma*: optional DMA object for the rp2 port
Subclass constructors (implementing concrete chip) set in addition the following, not to be used directly:
* *suppModel*: models supported by the hardware driver
* *suppRes*: resolutions supported by the hardware driver, as list of (width,height) tuples
'''
self.buf1 = bytearray(1)
self.buf2 = bytearray(2)
self.buf4 = bytearray(4)
self.cs,self.dc,self.rst=[(machine.Pin(p,machine.Pin.OUT) if isinstance(p,int) else p) for p in (cs,dc,rst)]
self.bl=bl
if isinstance(self.bl,int): self.bl=machine.PWM(machine.Pin(self.bl,machine.Pin.OUT))
elif isinstance(self.bl,machine.Pin): self.bl=machine.PWM(self.bl)
assert isinstance(self.bl,(machine.PWM,type(None)))
self.set_backlight(10) # set some backlight
self.rot=rot
self.bgr=bgr
self.width,self.height=(0,0) # this is set later in hard_reset->config->apply_rotation
if res not in suppRes: raise ValueError('Unsupported resolution %s; the driver supports: %s.'%(str(res),', '.join(str(r) for r in suppRes)))
if suppModel and model not in suppModel: raise ValueError('Unsupported model %s; the driver supports: %s.'%(str(model),', '.join(str(r) for r in suppModel)))
self.res=res
self.model=model
self.rp2_dma=rp2_dma
self.spi=spi
self.hard_reset()
def off(self): self.set_backlight(0)
def hard_reset(self):
if self.rst:
for v in (1,0,1):
self.rst.value(v)
time.sleep(.2)
time.sleep(.2)
self.config()
def config(self):
self.config_hw() # defined in child classes
self.apply_rotation(self.rot)
def set_backlight(self,percent):
if self.bl is None: return
self.bl.duty_u16(percent*655)
def set_window(self, x, y, w, h):
#c0,r0=ST77XX_COL_ROW_MODEL_START_ROTMAP[self.res[0],self.res[1],self.model][self.rot%4]
c0 = 0
r0 = 0
struct.pack_into('>hh', self.buf4, 0, c0+x, c0+x+w-1)
self.write_register(ST77XX_CASET, self.buf4)
struct.pack_into('>hh', self.buf4, 0, r0+y, r0+y+h-1)
self.write_register(ST77XX_RASET, self.buf4)
def apply_rotation(self, rot):
self.rot = rot
if (self.rot % 2) == 0:
self.width, self.height = self.res
else:
self.height, self.width = self.res
self.write_register(0x36,bytes([ST77XX_MADCTL_BGR | _MADCTL_ROTS[self.rot % 4]]),)
def blit(self, x, y, w, h, buf, is_blocking=True):
self.set_window(x, y, w, h)
if self.rp2_dma: self._rp2_write_register_dma(ST77XX_RAMWR, buf, is_blocking)
else: self.write_register(ST77XX_RAMWR, buf)
def clear(self, color):
bs=128 # write pixels in chunks; makes the fill much faster
struct.pack_into('>h',self.buf2,0,color)
buf=bs*bytes(self.buf2)
npx=self.width*self.height
self.set_window(0, 0, self.width, self.height)
self.write_register(ST77XX_RAMWR, None)
self.cs.value(0)
self.dc.value(1)
for _ in range(npx//bs): self.spi.write(buf)
for _ in range(npx%bs): self.spi.write(self.buf2)
self.cs.value(1)
def write_register(self, reg, buf=None):
struct.pack_into('B', self.buf1, 0, reg)
self.cs.value(0)
self.dc.value(0)
self.spi.write(self.buf1)
if buf is not None:
self.dc.value(1)
self.spi.write(buf)
self.cs.value(1)
def _rp2_write_register_dma(self, reg, buf, is_blocking=True):
'If *is_blocking* is False, used should call wait_dma explicitly.'
SPI1_BASE = 0x40040000 # FIXME: will be different for another SPI bus?
SSPDR = 0x008
self.rp2_dma.config(
src_addr = uctypes.addressof(buf),
dst_addr = SPI1_BASE + SSPDR,
count = len(buf),
src_inc = True,
dst_inc = False,
trig_dreq= self.rp2_dma.DREQ_SPI1_TX
)
struct.pack_into('B',self.buf1,0,reg)
self.cs.value(0)
self.dc.value(0)
self.spi.write(self.buf1)
self.dc.value(1)
self.rp2_dma.enable()
if is_blocking: self.rp2_wait_dma()
def rp2_wait_dma(self):
'''
Wait for rp2-port DMA transfer to finish; no-op unless self.rp2_dma is defined.
Can be used as callback before accessing shared SPI bus e.g. with the xpt2046 driver.
'''
if self.rp2_dma is None: return
while self.rp2_dma.is_busy(): pass
self.rp2_dma.disable()
# wait to send last byte. It should take < 1uS @ 10MHz
time.sleep_us(1)
self.cs.value(1)
def config_hw(self):
self._run_seq(
[
(0x01,None, 120),
(0x11, None, 120),
(0xF0,b"\xc3"),
(0xF0,b"\x96"),
#(0x36,bytes([self.madctl(COLOR_MODE_RGB, ILI9XXX_LANDSCAPE, ORIENTATION_TABLE)])),
#(0X36,b"\x0"),
(0x3A,bytes([self.display_config()])),
(0xB4,b"\x01"),
(0xB6,b"\x80\x02\x3B"),
(0xE8,b"\x40\x8A\x00\x00\x29\x19\xA5\x33"),
(0xC1,b"\x06"),
(0xC2,b"\xA7"),
(0xC5,b"\x18", 120),
(0xE0,b"\xF0\x09\x0B\x06\x04\x15\x2F\x54\x42\x3C\x17\x14\x18\x1B"),
(0xE1,b"\xE0\x09\x0B\x06\x04\x03\x2B\x43\x42\x3B\x16\x14\x17\x1B", 120),
(0xF0,b"\x3C"),
(0xF0,b"\x69",120),
(0x29,b""),
]
)
def display_config(self):
if lv.color_t.__SIZE__ == 4:
display_type = DISPLAY_TYPE_ILI9488
pixel_format = 0x06 # 262K-Colors
elif lv.color_t.__SIZE__ == 2:
pixel_format = 0x05 # 65K-Colors 55??
display_type = DISPLAY_TYPE_ST7789
else:
raise RuntimeError('ST7796 micropython driver requires defining LV_COLOR_DEPTH=32 or LV_COLOR_DEPTH=16')
return pixel_format
def madctl(self, colormode, rotation, rotations):
# if rotation is 0 or positive use the value as is.
if rotation >= 0:
return rotation | colormode
# otherwise use abs(rotation)-1 as index to retreive value from rotations set
index = abs(rotation) - 1
if index > len(rotations):
RuntimeError('Invalid display rot value specified during init.')
return rotations[index] | colormode
def _run_seq(self,seq):
'''
Run sequence of (initialization) commands; those are given as list of tuples, which are either
`(command,data)` or `(command,data,delay_ms)`
'''
for i,cmd in enumerate(seq):
if len(cmd)==2: (reg,data),delay=cmd,0
elif len(cmd)==3: reg,data,delay=cmd
else: raise ValueError('Command #%d has %d items (must be 2 or 3)'%(i,len(cmd)))
self.write_register(reg,data)
if delay>0: time.sleep_ms(delay)
class St77xx_lvgl(object):
'''LVGL wrapper for St77xx, not to be instantiated directly.
* creates and registers LVGL display driver;
* allocates buffers (double-buffered by default);
* sets the driver callback to the disp_drv_flush_cb method.
'''
def disp_drv_flush_cb(self,disp_drv,area,color):
# print(f"({area.x1},{area.y1}..{area.x2},{area.y2})")
self.rp2_wait_dma() # wait if not yet done and DMA is being used
# blit in background
self.blit(area.x1,area.y1,w:=(area.x2-area.x1+1),h:=(area.y2-area.y1+1),color.__dereference__(2*w*h),is_blocking=False)
self.disp_drv.flush_ready()
def __init__(self,doublebuffer=True,factor=8):
#import lvgl as lv
#import lv_utils
if lv.COLOR_DEPTH!=16: raise RuntimeError(f'LVGL *must* be compiled with LV_COLOR_DEPTH=16 (currently LV_COLOR_DEPTH={lv.COLOR_DEPTH}.')
bufSize=(self.width*self.height*lv.color_t.__SIZE__)//factor
if not lv.is_initialized(): lv.init()
#if not lv_utils.event_loop.is_running(): self.event_loop=lv_utils.event_loop()
# attach all to self to avoid objects' refcount dropping to zero when the scope is exited
self.disp_drv = lv.disp_create(self.width, self.height) **line 343**
self.disp_drv.set_flush_cb(self.disp_drv_flush_cb)
self.disp_drv.set_draw_buffers(bytearray(bufSize), None if doublebuffer is False else bytearray(bufSize), bufSize, lv.DISP_RENDER_MODE.PARTIAL)
self.disp_drv.set_color_format(lv.COLOR_FORMAT.NATIVE if self.bgr else lv.COLOR_FORMAT.NATIVE_REVERSED)
class St7796(St7796_hw, St77xx_lvgl):
def __init__(self, doublebuffer=True, factor=8, **kw):
St7796_hw.__init__(self, **kw)
St77xx_lvgl.__init__(self, doublebuffer, factor)
main.py
import lvgl as lv
import st7796
import time
from machine import SPI, Pin
spi = SPI(1, baudrate=27000000, sck=Pin(10), mosi=Pin(11), miso=Pin(8))
drv = st7796.St7796(spi=spi, dc=23, cs=29, rst=28,rot=3,res=(320,480),suppRes=[(320,480),])
#Screen background style
style_scr_back = lv.style_t()
style_scr_back.set_bg_opa(lv.OPA.COVER)
style_scr_back.set_border_width(0)
style_scr_back.set_bg_color(lv.color_hex(0x003a57))
style_scr_back.set_bg_grad_color(lv.color_hex(0x000000))
style_scr_back.set_bg_grad_dir(lv.GRAD_DIR.HOR)
style_scr_back.set_bg_main_stop(128)
# Create an object with the new style
scr = lv.scr_act()
scr.add_style(style_scr_back, 0)
error
Traceback (most recent call last):
File "<stdin>", line 11, in <module>
File "st7796.py", line 351, in __init__
File "st7796.py", line 343, in __init__
MemoryError: memory allocation failed, allocating 20972008 bytes
I might be wrong but I think such error happens when the rp2_dma is not correctly initialized.
i added factor=50 in main.py, now I am getting this error.
Traceback (most recent call last):
File "<stdin>", line 11, in <module>
File "st7796.py", line 351, in __init__
File "st7796.py", line 343, in __init__
MemoryError: memory allocation failed, allocating 712140650 bytes
its not making any sense to me.I am using Thonny as my IDE
There’s the problem!!!.
Stop using Thonny IDE it causes issues because of how to connects to MicroPython.
Use a terminal program to connect to the MCU
i was referring doc and it lists thonny as a IDE for micropython. 
what about rshell be good? Or can you suggest any terminal programs.
irelevant how IDE this number is stupid. Maybe better is starting clean class with simple 3 func required for display lvgl.
I am telling you that Thonny DOES cause problems. IDK what it is about how to makes the connection but it does cause issues.
It’s worth a shot to try it without using Thonny to see what happens. It’s not a big deal to do. You can use Thonny to upload the files but do not run the program on the MCU with Thonny connected to it… I would exit the IDE and use any serial based terminal emulator to make the connection
The code the OP is running is NOT using any DMA. It has not been set up. It’s not a DMA problem it’s something else.
If DMA was being used you would see code like this in there somewhere.
from machine import Pin
from rp2 import PIO, StateMachine, asm_pio
from time import sleep
import array
import uctypes
from uctypes import BF_POS, BF_LEN, UINT32, BFUINT32, struct
GPIO_BASE = 0x40014000
GPIO_CHAN_WIDTH = 0x08
GPIO_PIN_COUNT = 30
PAD_BASE = 0x4001c000
PAD_PIN_WIDTH = 0x04
ADC_BASE = 0x4004c000
PIO0_BASE = 0x50200000
PIO1_BASE = 0x50300000
DMA_BASE = 0x50000000
DMA_CHAN_WIDTH = 0x40
DMA_CHAN_COUNT = 12
DMA_SIZE_BYTE = 0x0
DMA_SIZE_HALFWORD = 0x1
DMA_SIZE_WORD = 0x2
# DMA: RP2040 datasheet 2.5.7
DMA_CTRL_TRIG_FIELDS = {
"AHB_ERROR": 31<<BF_POS | 1<<BF_LEN | BFUINT32,
"READ_ERROR": 30<<BF_POS | 1<<BF_LEN | BFUINT32,
"WRITE_ERROR": 29<<BF_POS | 1<<BF_LEN | BFUINT32,
"BUSY": 24<<BF_POS | 1<<BF_LEN | BFUINT32,
"SNIFF_EN": 23<<BF_POS | 1<<BF_LEN | BFUINT32,
"BSWAP": 22<<BF_POS | 1<<BF_LEN | BFUINT32,
"IRQ_QUIET": 21<<BF_POS | 1<<BF_LEN | BFUINT32,
"TREQ_SEL": 15<<BF_POS | 6<<BF_LEN | BFUINT32,
"CHAIN_TO": 11<<BF_POS | 4<<BF_LEN | BFUINT32,
"RING_SEL": 10<<BF_POS | 1<<BF_LEN | BFUINT32,
"RING_SIZE": 6<<BF_POS | 4<<BF_LEN | BFUINT32,
"INCR_WRITE": 5<<BF_POS | 1<<BF_LEN | BFUINT32,
"INCR_READ": 4<<BF_POS | 1<<BF_LEN | BFUINT32,
"DATA_SIZE": 2<<BF_POS | 2<<BF_LEN | BFUINT32,
"HIGH_PRIORITY":1<<BF_POS | 1<<BF_LEN | BFUINT32,
"EN": 0<<BF_POS | 1<<BF_LEN | BFUINT32
}
# Channel-specific DMA registers
DMA_CHAN_REGS = {
"READ_ADDR_REG": 0x00|UINT32,
"WRITE_ADDR_REG": 0x04|UINT32,
"TRANS_COUNT_REG": 0x08|UINT32,
"CTRL_TRIG_REG": 0x0c|UINT32,
"CTRL_TRIG": (0x0c,DMA_CTRL_TRIG_FIELDS)
}
# General DMA registers
DMA_REGS = {
"INTR": 0x400|UINT32,
"INTE0": 0x404|UINT32,
"INTF0": 0x408|UINT32,
"INTS0": 0x40c|UINT32,
"INTE1": 0x414|UINT32,
"INTF1": 0x418|UINT32,
"INTS1": 0x41c|UINT32,
"TIMER0": 0x420|UINT32,
"TIMER1": 0x424|UINT32,
"TIMER2": 0x428|UINT32,
"TIMER3": 0x42c|UINT32,
"MULTI_CHAN_TRIGGER": 0x430|UINT32,
"SNIFF_CTRL": 0x434|UINT32,
"SNIFF_DATA": 0x438|UINT32,
"FIFO_LEVELS": 0x440|UINT32,
"CHAN_ABORT": 0x444|UINT32
}
DREQ_PIO0_TX0, DREQ_PIO0_RX0, DREQ_PIO1_TX0 = 0, 4, 8
DREQ_PIO1_RX0, DREQ_SPI0_TX, DREQ_SPI0_RX = 12, 16, 17
DREQ_SPI1_TX, DREQ_SPI1_RX, DREQ_UART0_TX = 18, 19, 20
DREQ_UART0_RX, DREQ_UART1_TX, DREQ_UART1_RX = 21, 22, 23
DREQ_I2C0_TX, DREQ_I2C0_RX, DREQ_I2C1_TX = 32, 33, 34
DREQ_I2C1_RX, DREQ_ADC = 35, 36
TREQ_TIMER_0 = 0x3b
DMA_CHANS = [struct(DMA_BASE + n*DMA_CHAN_WIDTH, DMA_CHAN_REGS) for n in range(0,DMA_CHAN_COUNT)]
DMA_DEVICE = struct(DMA_BASE, DMA_REGS)
PIO0_TX0 = PIO0_BASE + 0x010
PIO0_TX1 = PIO0_BASE + 0x014
PIO0_TX2 = PIO0_BASE + 0x018
PIO0_TX3 = PIO0_BASE + 0x01c
PIO1_TX0 = PIO1_BASE + 0x010
PIO0_TX1 = PIO1_BASE + 0x014
PIO0_TX2 = PIO1_BASE + 0x018
PIO0_TX3 = PIO1_BASE + 0x01c
GPIO_FUNC_SPI, GPIO_FUNC_UART, GPIO_FUNC_I2C = 1, 2, 3
GPIO_FUNC_PWM, GPIO_FUNC_SIO, GPIO_FUNC_PIO0 = 4, 5, 6
GPIO_FUNC_NULL = 0x1f
DMA_CH0_AL3_TRANS_COUNT = DMA_BASE + 0x38
#format 16 bits X followed by 16bits Y. speed = x/y * sysclock
DMA_TIMER_REG = {
"DMA_TIMER_0" : 0x420 | UINT32
}
PIO0_CTRL = PIO0_BASE
PIO0_STOP = 0 | 0b111
DMA_TIMERS = struct(DMA_BASE, DMA_TIMER_REG)
def set_timer_reg(number, x, y):
if number == 0:
DMA_TIMERS.DMA_TIMER_0 = (x<<16) | y
def set_timer_reg_direct(number, value):
DMA_TIMERS.DMA_TIMER_0 = value
def get_timer_reg(number):
return DMA_TIMER_0
class PIO_DMA_Transfer():
def __init__(self, dma_channel, sm_num, block_size, transfer_count, bswap=False):
self.dma_chan = DMA_CHANS[dma_channel]
self.channel_number = dma_channel
if (sm_num == 0):
self.dma_chan.WRITE_ADDR_REG = PIO0_TX0
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO0_TX0
elif (sm_num == 1):
self.dma_chan.WRITE_ADDR_REG = PIO0_TX1
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO0_TX1
elif (sm_num == 2):
self.dma_chan.WRITE_ADDR_REG = PIO0_TX2
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO0_TX2
elif (sm_num == 3):
self.dma_chan.WRITE_ADDR_REG = PIO0_TX3
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO0_TX3
elif (sm_num == 4):
self.dma_chan.WRITE_ADDR_REG = PIO1_TX0
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO1_TX0
elif (sm_num == 5):
self.dma_chan.WRITE_ADDR_REG = PIO1_TX1
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO1_TX1
elif (sm_num == 6):
self.dma_chan.WRITE_ADDR_REG = PIO1_TX2
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO1_TX2
elif (sm_num == 7):
self.dma_chan.WRITE_ADDR_REG = PIO1_TX3
self.dma_chan.CTRL_TRIG.TREQ_SEL = DREQ_PIO1_TX3
if (block_size == 8):
self.dma_chan.CTRL_TRIG.DATA_SIZE = DMA_SIZE_BYTE
if (block_size == 16):
self.dma_chan.CTRL_TRIG.DATA_SIZE = DMA_SIZE_HALFWORD
if (block_size == 32):
self.dma_chan.CTRL_TRIG.DATA_SIZE = DMA_SIZE_WORD
self.dma_chan.TRANS_COUNT_REG = transfer_count
#Do I just always want these?
self.dma_chan.CTRL_TRIG.INCR_WRITE = 0
self.dma_chan.CTRL_TRIG.INCR_READ = 1
if bswap:
self.dma_chan.CTRL_TRIG.BSWAP = 1
else:
self.dma_chan.CTRL_TRIG.BSWAP = 0
def start_transfer(self, buffer):
self.dma_chan.READ_ADDR_REG = uctypes.addressof(buffer)
self.dma_chan.CTRL_TRIG.EN = 1
def transfer_count(self):
return self.dma_chan.TRANS_COUNT_REG
def set_transfer_count(self, count):
self.dma_chan.TRANS_COUNT_REG = count
def use_timer(self, timer):
self.dma_chan.CTRL_TRIG.TREQ_SEL = TREQ_TIMER_0
def busy(self):
if self.dma_chan.CTRL_TRIG.DATA_SIZE == 1:
return True
else:
return False
def abort_transfer(self):
pass
def chain_to(self, channel):
self.dma_chan.CTRL_TRIG.CHAIN_TO = channel
def get_number(self):
return self.channel_number
def create_dma_to_stop_pio0(dma_channel):
dma_chan = DMA_CHANS[dma_channel]
channel_number = dma_channel
dma_chan.WRITE_ADDR_REG = PIO0_CTRL
dma_chan.CTRL_TRIG.TREQ_SEL = 0x3f
dma_chan.CTRL_TRIG.DATA_SIZE = DMA_SIZE_WORD
dma_chan.TRANS_COUNT_REG = 1
buffer = array.array("L", [PIO0_STOP])
dma_chan.READ_ADDR_REG = uctypes.addressof(buffer)
dma_chan.CTRL_TRIG.EN = 1
#looping transfers
#note -- see datasheet 2.5.7
#location of registers is -- AL3 transcount / read address trigger.
#Writing to these (from one DMA channel) will re-trigger a second DMA channel
#need to set write ring.
#could also set read ring?
#out_buff = array.array('L', ((x if (x<1000) else (2000-x)) for x in range(NSAMPLES)))
class DMA_Control_Block:
def __init__(self, this_chan, that_chan, read_address, transfer_count, loops):
self.dma_chan = DMA_CHANS[this_chan]
#note -- need to set this up to get the right location
#but for now just always control channel 0
self.dma_chan.WRITE_ADDR_REG = DMA_CH0_AL3_TRANS_COUNT
self.dma_chan.CTRL_TRIG.DATA_SIZE = DMA_SIZE_WORD
self.dma_chan.TRANS_COUNT_REG = 2 # two transfers. One is the count, one is the read_address.
#Then pauses until the other channel chains back to this.
self.buffer = array.array('L', (x for x in range(2*loops)))
for x in range(loops):
self.buffer[2*x] = transfer_count
self.buffer[2*x+1] = read_address
self.start_address = uctypes.addressof(self.buffer)
#set up read ring
that_chan.chain_to(this_chan)
self.dma_chan.CTRL_TRIG.INCR_WRITE = 1
self.dma_chan.CTRL_TRIG.INCR_READ = 1
self.dma_chan.CTRL_TRIG.RING_SEL = 1
self.dma_chan.CTRL_TRIG.RING_SIZE = 3 # 1u<<3 bytes / 8 bytes
self.dma_chan.CTRL_TRIG.TREQ_SEL = 0x3f # unpaced transfer
def start_chain(self):
self.dma_chan.READ_ADDR_REG = self.start_address
self.dma_chan.CTRL_TRIG.EN = 1
def transfer_count(self):
return self.dma_chan.TRANS_COUNT_REG
def get_read_address(self):
return self.dma_chan.READ_ADDR_REG
def busy(self):
if self.dma_chan.CTRL_TRIG.DATA_SIZE == 1:
return True
else:
return False
The issue is the interrupt when transfer is complete. There is no way to assign this to a callback from inside of MicroPython so it wouldn’t work. You need to be able to trigger an interrupt and set a callback to let LVGL know the buffer has been emptied.