Only space for 128 points in Sparkline?

[axelmagnus]

Hello!

I cant seem to find any info on how many points can be stored in a sparkline.
When I try to add my 129th element to a sparkline i get the follow error:

Traceback (most recent call last): File "code.py", line 232, in <module> File "adafruit_display_shapes/sparkline.py", line 98, in add_value MemoryError: memory allocation failed, allocating 1024 bytes

I would at least want the size to be as many as my displaywidth, 320 on a PyPortal. Does Titano have more?

Can this be increased to say 1024 points? (If this indeed is the error)

[kmatch98]

@axelmagnus. The number of points you can plot will depend upon how much RAM memory you have available free keeping in mind that the memory taken up by whatever else your code is doing. You can check your memory usage at different points through your program by:

import gc
print(gc.mem_free()))

See https://circuitpython.readthedocs.io/en/2.x/docs/library/gc.html

Since you just want one pixel per datapoint you may be able to conserve memory if you write your own display element for your specific graph, maybe it would be best to manipulate a bitmap. Once you delve into it, let me know if you need any help doing that.

[axelmagnus]

Thanks, thats a great tip for other memory issues. Note to other noobs: theres a parenthesis too many if you copy.

However, this is the read out. (number of sparkline, memory left)

123 50112 124 49024 125 46704 126 44384 127 43056 Traceback (most recent call last): File "code.py", line 186, in <module> File "adafruit_display_shapes/sparkline.py", line 98, in add_value MemoryError: memory allocation failed, allocating 1024 bytes

Im not running out of memory at all, and its probably not a coincident that it flunks out at 127, no?

Reg. bitmap idea: im just so happy i finally found out that is was sparkline i should have used all those years trying to make my own graph with a FIFO queue. and i think 128 is a limitation anyways.

BUT if you have any ideas to make the line itself more attractive, which is a positive with that idea though. let us know 👍

[axelmagnus]

Also:

Another run gave different numbers:

49424 125 61696 126 65232 127 65040 Traceback (most recent call last): File "code.py", line 187, in <module> File "adafruit_display_shapes/sparkline.py", line 98, in add_value MemoryError: memory allocation failed, allocating 1024 bytes

[kmatch98]

On a pyPortal, I tested the display_shapes_sparkline_simpletest.py , just changing the max_items=2000 and it looped through the main loop and added 253 points before crashing with the MemoryError: memory allocation failed, allocating 752 bytes.

I don't think this is a fundamental limitation of the code. I think your the number of points/lines is limited by how much RAM was available in your code.

Here's my serial output of the error:

251 

252 

253 

Traceback (most recent call last):
  File "code.py", line 135, in <module>
  File "/lib/adafruit_display_shapes/sparkline.py", line 99, in add_value
  File "/lib/adafruit_display_shapes/sparkline.py", line 158, in update
  File "/lib/adafruit_display_shapes/sparkline.py", line 121, in _plotline
  File "/lib/adafruit_display_shapes/line.py", line 59, in __init__
  File "/lib/adafruit_display_shapes/polygon.py", line 75, in __init__
MemoryError: memory allocation failed, allocating 752 bytes

Code done running. Waiting for reload.
Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.

Press any key to enter the REPL. Use CTRL-D to reload.

Here's the code that I ran:

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

# class of sparklines in CircuitPython
# created by Kevin Matocha - Copyright 2020 (C)

# See the bottom for a code example using the `sparkline` Class.

# # File: display_shapes_sparkline.py
# A sparkline is a scrolling line graph, where any values added to sparkline using
# `add_value` are plotted.
#
# The `sparkline` class creates an element suitable for adding to the display using
# `display.show(mySparkline)`
# or adding to a `displayio.Group` to be displayed.
#
# When creating the sparkline, identify the number of `max_items` that will be
# included in the graph.
# When additional elements are added to the sparkline and the number of items has
# exceeded max_items, any excess values are removed from the left of the graph,
# and new values are added to the right.


# The following is an example that shows the

# setup display
# instance sparklines
# add to the display
# Loop the following steps:
# 	add new values to sparkline `add_value`
# 	update the sparklines `update`

import time
import random
import board
import displayio


from adafruit_display_shapes.sparkline import Sparkline

if "DISPLAY" not in dir(board):
    # Setup the LCD display with driver
    # You may need to change this to match the display driver for the chipset
    # used on your display
    from adafruit_ili9341 import ILI9341

    displayio.release_displays()

    # setup the SPI bus
    spi = board.SPI()
    tft_cs = board.D9  # arbitrary, pin not used
    tft_dc = board.D10
    tft_backlight = board.D12
    tft_reset = board.D11

    while not spi.try_lock():
        spi.configure(baudrate=32000000)

    spi.unlock()

    display_bus = displayio.FourWire(
        spi,
        command=tft_dc,
        chip_select=tft_cs,
        reset=tft_reset,
        baudrate=32000000,
        polarity=1,
        phase=1,
    )

    print("spi.frequency: {}".format(spi.frequency))

    # Number of pixels in the display
    DISPLAY_WIDTH = 320
    DISPLAY_HEIGHT = 240

    # create the display
    display = ILI9341(
        display_bus,
        width=DISPLAY_WIDTH,
        height=DISPLAY_HEIGHT,
        rotation=180,  # The rotation can be adjusted to match your configuration.
        auto_refresh=True,
        native_frames_per_second=90,
    )

    # reset the display to show nothing.
    display.show(None)
else:
    # built-in display
    display = board.DISPLAY

##########################################
# Create background bitmaps and sparklines
##########################################

# Baseline size of the sparkline chart, in pixels.
chart_width = display.width
chart_height = display.height

# sparkline1 uses a vertical y range between 0 to 10 and will contain a
# maximum of 40 items
sparkline1 = Sparkline(
    width=chart_width, height=chart_height, max_items=2000, y_min=0, y_max=10, x=0, y=0
)

# Create a group to hold the sparkline and append the sparkline into the
# group (my_group)
#
# Note: In cases where display elements will overlap, then the order the elements
# are added to the group will set which is on top.  Latter elements are displayed
# on top of former elemtns.
my_group = displayio.Group(max_size=1)

# add the sparkline into my_group
my_group.append(sparkline1)


# Add my_group (containing the sparkline) to the display
display.show(my_group)

loop_count=0

# Start the main loop
while True:
    print(loop_count, "\n")
    loop_count += 1

    # turn off the auto_refresh of the display while modifying the sparkline
    display.auto_refresh = False

    # add_value: add a new value to a sparkline
    # Note: The y-range for mySparkline1 is set to 0 to 10, so all these random
    # values (between 0 and 10) will fit within the visible range of this sparkline
    sparkline1.add_value(random.uniform(0, 10))

    # turn the display auto_refresh back on
    display.auto_refresh = True

    # The display seems to be less jittery if a small sleep time is provided
    # You can adjust this to see if it has any effect
    #time.sleep(0.01)

[kmatch98]

This is an issue more about how much RAM is available on the board, not a specific limitation of the library. One possible solution to allow for more data points is to use the vectorio library rather than display_shapes (which uses bitmaps).

But that would go in a different library, so closing this for now as a board limit not a library limit.

[matemaciek]

Since we specify maximum number of data points, this sounds like a nice place for optimizations regarding memory fragmentation - from quickly going through the code I don't see any, I'll try and maybe I can add some. E.g. allocating all the memory needed for data when constructing sparkline, this way user can know earlier that ther's not enough memory for storing all requested data.