Maximale Array-Größe

Software Fragen und Probleme Fragen zu MakeCode/PXT
1

Wie groß ist die maximale unterstütze Größe für eindimensionale arrays vom Typ „number“ mit der aktuellen Makecode version?

Bei größeren arrays stürzt der calliope immer wieder ab. Das Programm lässt sich zwar compilieren und übertragen. Jedoch nachdem Start kommt es gleich zum Absturz. Es wird auch keine Errorcode ausgeben. Mit viel ausprobieren bin ich aktuell auf max 480 Elementen vom Typ number gekommen. Es ändert sich auch nichts, wenn ich ein uint8-Format nutze ( Die Datenelemente sind nur max. 1 Byte groß). Jedoch schwankt das immer etwas. Gibt es hier irgendwo eine Doku oder Definition für die max. array-Größe ?
Mit der aktuellen beta-Version von Makecode ist es noch schlimmer, da stürzt der Calliope schon bei arrays mit 30 Datenelemente ab .

Schöne Grüße
xaver

2

Eine gute Frage, auf die hier leider auch keine Antwort zu finden ist.
Ich habe gerade mehrere Stunden damit verbracht, bis ich dem Problem auf die Spur gekommen bin, dass der Calliope, im Gegensatz zum Simulator beim ca. 30. „push“ crasht.

3

Hallo Andreas,

die Schwierigkeit ist, dass die Anzahl (vor allem) abhängig von der genutzten MakeCode-Version ist und dort ebenfalls variiert. Da hilft nur ausprobieren. Ich vermute, wenn du an den Einstellungen (manuell) optimierst, kannst du auch noch deutlich mehr rausholen. Leider sind neuere MakeCode-Versionen nicht besonders sparsam, weder in der Filegröße, noch in der RAM Ausnutzung. Allerdings sind alle erstellten Version auch weiterhin verfügbar z.B. unter makecode.calliope.cc/v3.
Grüße
Jörn

4

Hallo Jörn,
danke für die schnelle Antwort.
Leider kommt unter der URL für V2 nur „Seite nicht gefunden“.
An welchen Einstellungen kann ich denn bei MakeCode noch optimieren?
Falls ich das wirklich noch mal umsetzen muss wird’s wohl gutes altes C.
Hier ging es nur um einen kleinen Test für ein Fortbildungsprojekt, aber dann ist Calliope mit MakeCode wohl schon an seiner Grenze.
2020 ging’s scheinbar noch.

5

Sorry, ich habe es korrigiert. Ein kleines „v“ ist nötig!

makecode.calliope.cc/v1
makecode.calliope.cc/v3
makecode.calliope.cc/v4
makecode.calliope.cc/beta

6

Super, mit v3 läuft es. Danke!

1 „Gefällt mir“
7

Weil ich jetzt selbst betroffen bin, habe ich die aktuellen Array-Grenzen ausgetestet:

(BT an) bedeutet Bluetooth Grundeinstellung (Schalter links=aus)
(BT aus) bedeutet Bluetooth manuell bei Bedarf laden (Schalter grün) = mehr freier Speicher
(+) bedeutet funktioniert
(-) bedeutet stürzt ab (LED Matrix blitzt auf)

  1. Die Grenze liegt bei 32 Array-Elementen (+).
  2. Bei 33 Elementen stürzt Calliope ab (-), wenn (BT an).
  • Gilt für 33 number Elemente im Array.
  • Gilt für 33 string Elemente. Die Länge der Strings ist egal, passiert auch bei leeren Strings.
  • Gilt für Calliope 1.3 und 2.1.
  1. Arrays mit 33 Elementen (+) funktionieren aber, wenn (BT aus).
  • Gilt für Calliope 1.3 und 2.1.

nur Calliope 1.3

  1. Es sind mehrere Arrays mit je 32 Elementen möglich.
  • Mit (BT an) funktionieren 4 Arrays je 32 Elemente (+), beim 5. stürzt es ab (-).
  • Mit (BT aus) funktionieren 10 Arrays je 32 Elemente (+). Mehr habe ich nicht getestet.

nur Calliope 2.1 (Erweiterung mini2 geladen)

  1. Es sind mehrere Arrays mit je 32 Elementen möglich.
  • 10 Arrays je 32 Elemente (+) funktionieren unabhängig von Bluetooth. Mehr habe ich nicht getestet.
  • 1 Array mit 33 Elementen funktioniert trotzdem nur, wenn (BT aus).

1.3 (BT an) 1x33 (-)
1.3 (BT an) 4x32 (+) 5x32 (-)
1.3 (BT aus) 1x33 (+)
1.3 (BT aus) 10x32 (+)
2.1 (BT an) 1x33 (-)
2.1 (BT an) 10x32 (+)
2.1 (BT aus) 1x33 (+)
2.1 (BT aus) 10x32 (+)

Logisch ist, dass die Anzahl der Arrays mit je 32 Elementen zunimmt, je mehr Speicher frei ist. Entweder durch (BT aus) oder durch Calliope 2.x oder beides. Der Absturz passiert nur bei 1.3 (BT an) beim 5. Array mit 32 Elementen.

Unlogisch ist, dass ein einziges Array mit 33 Elementen immer abstürzt, wenn (BT an). Das kann nicht daran liegen dass der Speicher voll wäre. Wenn die Arrays im Datenspeicher liegen, der bei Calliope 2.x verdoppelt wurde, ist das umso unverständlicher.

Das Test Programm ist hier:
Knopf A lädt in 10 verschiedene Variablen je 1 Array mit 32 Elementen (number).
Knopf B lädt 1 Array mit 33 Elementen (number).
Knopf A+B lädt 1 Array mit 33 Elementen (string).

Ich wünsche mir, dass die Grenze von 32 Elementen im Array jedenfalls bei Calliope 2.1 aufgehoben wird, weil das nicht mit fehlendem Speicherplatz zu begründen ist.
(Im Simulator funktioniert es immer.)

Lutz

2 „Gefällt mir“