Hi there,

very new to micropython, but enjoying it so far. I am a bit of a novice so this may be where my issue lay

I have a script that produces the error ... 

assertion "ATB_GET_KIND(block) == AT_HEAD" failed: file "/home/LoBo2_Razno/ESP32/MicroPython/MicroPython_ESP32_psRAM_LoBo/MicroPython_BUILD/components/micropython/py/gc.c", line 596, function: gc_free

abort() was called at PC 0x40121da3 on core 1

I have seen this mentioned elsewhere on the forum, wrt ports, but none of these discussions help with my current issue.

before posting here I ran the code through flake8 and pylint (ignoring some capitalization formatting etc), to make sure I was somewhat pythonic and free of some issues.

This is code for a flow meter that squirts it's measurements into influxdb, it has 2 threads that I start, one to manage a queue, and the other to keep an eye on the network.

It is no where near complete, and remember I am a novice ... but happy to take pointers to making it better.

I see that Boris once worked with the RA8876 display processor, but I can't find any reference to it in the LoBo Display module. Does anyone have a driver for this device?

I have been unable to run the calibration of a touch screen, ILI9341 with XPT2046 touch controller.

Screen initialised:
from machine import SPI,Pin
import display
import tpcalib

tft = display.TFT()
tft.init(tft.ILI9341, width=240, height=320, miso=12,mosi=13,clk=14,cs=15,dc=26, rst_pin=27,tcs=25,hastouch=tft.TOUCH_XPT, bgr=True)

def touch_cal():
    tpc = tpcalib.Calibrate(tft)
    #dosave = True
    tp_type = tft.TOUCH_XPT
    tpc.tpcalib(tp_type)

on calling touch_cal() the screen is displayed, but is unresponsive to touch.
note: tpc.tpcalib(tt_type,dosave) gives 2 errors should be tp_type and only 1 variable required

I have tested the touch functioality using a driver derived from : http://www.ars-informatica.ca/eclectic/x...libration/
.

Any help appreciated

I’m working on an ESP32 camera project (Arduino IDE) that I would like bring over to a K210 based board for performance reasons.

Here’s a quick video demo of what I have at the moment: https://youtu.be/232PdOVPyPg

At the moment I have a web page hosted on the ESP32. Commands and the video stream are over websockets. The cursor overlay uses the IDF gfx library.

How much of this is possible with the current MP port for the K210? I have a Sipeed M1 and the Maixduino.

Hello!

The Grove version of the Maixduino board bundles a 2.4" TFT display (& a camera). I am familiar with these TFT displays being driven through Arduino code. Is there any equivalent MicroPython library module for this purpose?

Thanks.

Hi. On Sipeed Maix Go, I tried to configure SPI with 24bit like so:

Hi,
I'm having trouble displaying pixel text on the screen correctly!


Board: https://heltec.org/project/wireless-stick/

System Image: LoBo MicroPython.

Library:
ssd1306.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces



import time

import framebuf





# register definitions

SET_CONTRAST        = const(0x81)

SET_ENTIRE_ON       = const(0xa4)

SET_NORM_INV        = const(0xa6)

SET_DISP            = const(0xae)

SET_MEM_ADDR        = const(0x20)

SET_COL_ADDR        = const(0x21)

SET_PAGE_ADDR       = const(0x22)

SET_DISP_START_LINE = const(0x40)

SET_SEG_REMAP       = const(0xa0)

SET_MUX_RATIO       = const(0xa8)

SET_COM_OUT_DIR     = const(0xc0)

SET_DISP_OFFSET     = const(0xd3)

SET_COM_PIN_CFG     = const(0xda)

SET_DISP_CLK_DIV    = const(0xd5)

SET_PRECHARGE       = const(0xd9)

SET_VCOM_DESEL      = const(0xdb)

SET_CHARGE_PUMP     = const(0x8d)





class SSD1306:

    def __init__(self, width, height, external_vcc):

        self.width = width

        self.height = height

        self.external_vcc = external_vcc

        self.pages = self.height // 8

        # Note the subclass must initialize self.framebuf to a framebuffer.

        # This is necessary because the underlying data buffer is different

        # between I2C and SPI implementations (I2C needs an extra byte).

        self.poweron()

        self.init_display()



    def init_display(self):

        for cmd in (

            SET_DISP | 0x00, # off

            # address setting

            SET_MEM_ADDR, 0x00, # horizontal

            # resolution and layout

            SET_DISP_START_LINE | 0x00,

            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0

            SET_MUX_RATIO, self.height - 1,

            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0

            SET_DISP_OFFSET, 0x00,

            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,

            # timing and driving scheme

            SET_DISP_CLK_DIV, 0x80,

            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,

            SET_VCOM_DESEL, 0x30, # 0.83*Vcc

            # display

            SET_CONTRAST, 0xff, # maximum

            SET_ENTIRE_ON, # output follows RAM contents

            SET_NORM_INV, # not inverted

            # charge pump

            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,

            SET_DISP | 0x01): # on

            self.write_cmd(cmd)

        self.fill(0)

        self.show()



    def poweroff(self):

        self.write_cmd(SET_DISP | 0x00)



    def contrast(self, contrast):

        self.write_cmd(SET_CONTRAST)

        self.write_cmd(contrast)



    def invert(self, invert):

        self.write_cmd(SET_NORM_INV | (invert & 1))



    def show(self):

        x0 = 0

        x1 = self.width - 1

        if self.width == 64:

            # displays with width of 64 pixels are shifted by 32

            x0 += 32

            x1 += 32

        self.write_cmd(SET_COL_ADDR)

        self.write_cmd(x0)

        self.write_cmd(x1)

        self.write_cmd(SET_PAGE_ADDR)

        self.write_cmd(0)

        self.write_cmd(self.pages - 1)

        self.write_framebuf()



    def fill(self, col):

        self.framebuf.fill(col)



    def pixel(self, x, y, col):

        self.framebuf.pixel(x, y, col)



    def scroll(self, dx, dy):

        self.framebuf.scroll(dx, dy)



    def text(self, string, x, y, col=1):

        self.framebuf.text(string, x, y, col)





class SSD1306_I2C(SSD1306):

    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):

        self.i2c = i2c

        self.addr = addr

        self.temp = bytearray(2)

        # Add an extra byte to the data buffer to hold an I2C data/command byte

        # to use hardware-compatible I2C transactions.  A memoryview of the

        # buffer is used to mask this byte from the framebuffer operations

        # (without a major memory hit as memoryview doesn't copy to a separate

        # buffer).

        self.buffer = bytearray(((height // 8) * width) + 1)

        self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1

        self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)

        super().__init__(width, height, external_vcc)



    def write_cmd(self, cmd):

        self.temp[0] = 0x80 # Co=1, D/C#=0

        self.temp[1] = cmd

        self.i2c.writeto(self.addr, self.temp)



    def write_framebuf(self):

        # Blast out the frame buffer using a single I2C transaction to support

        # hardware I2C interfaces.

        self.i2c.writeto(self.addr, self.buffer)



    def poweron(self):

        pass





class SSD1306_SPI(SSD1306):

    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):

        self.rate = 10 * 1024 * 1024

        dc.init(dc.OUT, value=0)

        res.init(res.OUT, value=0)

        cs.init(cs.OUT, value=1)

        self.spi = spi

        self.dc = dc

        self.res = res

        self.cs = cs

        self.buffer = bytearray((height // 8) * width)

        self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)

        super().__init__(width, height, external_vcc)



    def write_cmd(self, cmd):

        self.spi.init(baudrate=self.rate, polarity=0, phase=0)

        self.cs.high()

        self.dc.low()

        self.cs.low()

        self.spi.write(bytearray([cmd]))

        self.cs.high()



    def write_framebuf(self):

        self.spi.init(baudrate=self.rate, polarity=0, phase=0)

        self.cs.high()

        self.dc.high()

        self.cs.low()

        self.spi.write(self.buffer)

        self.cs.high()



    def poweron(self):

        self.res.high()

        time.sleep_ms(1)

        self.res.low()

        time.sleep_ms(10)

        self.res.high()

import machine

from ssd1306 import SSD1306_I2C



#PG MOD

testPin = machine.Pin(16, machine.Pin.OUT)

testPin.value(1) #VEXT ON



WIDTH = const(128)

HEIGHT = const (64)

sda_pin = machine.Pin(4)

scl_pin = machine.Pin(15)



i2c = machine.I2C(scl=scl_pin, sda=sda_pin, speed=400000)



ssd = SSD1306_I2C(WIDTH, HEIGHT, i2c)



import freesans20



from writer import Writer

wri2 = Writer(ssd, freesans20, verbose=True)



Writer.set_clip(True, True)

Writer.set_textpos(0, 0)

wri2.printstring('MicroPython\nby LoBo\n10/2017')



ssd.show()

ssd.pixel(1,1,1)

ssd.pixel(2,2,1)

ssd.pixel(3,3,1)

ssd.pixel(4,4,1)

ssd.pixel(5,5,1)

ssd.pixel(6,6,1)

ssd.pixel(7,7,1)

ssd.pixel(8,8,1)

ssd.pixel(9,9,1)

ssd.pixel(10,10,1)

ssd.pixel(11,11,1)

ssd.pixel(12,12,1)

ssd.pixel(30,30,1)

ssd.show()

WIDTH = const(64)

HEIGHT = const (32)

I've been trying to talk to Sparkfun's wonderful Battery Babysitter today.

The chip on board is the BQ27441-G1, over I2C.  There is a fairly simple Arduino library I've been using for inspiration, here.


I have the hardware set up correctly, I believe.  I'm able to do this:

Hello,

I am embarking on the MicroPython excursion with newbie steps. May I ask for a link to some Hello World exercises for an absolute beginner in MicroPython who hasn't completed flashing his firmware as yet but wants to get his ducks in a row to start the adventure. Perhaps, I didn't search properly, trust you won't mind and oblige.

Kind regards.

P.S. My nominal browsing/search didn't reveal links. I can do Hello World in Python!

I have two applications, one written in Python and the other in C and am interested in knowing if they can both be run on an esp32, each app running in its own core.  I saw something about pinning the micropython to a task on a particular core.  Is something like this feasible?