π
<-

News 2025
May (1)
April (1)

News 2024

News 2023

News 2022
July (1)
June (1)
May (1)
April (3)

Retour du site Zero (calculatrice) avec nouveau design !

New postby critor » 08 May 2025, 20:16

22120Fan de la TI-83 Premium CE (ou hors de France de la TI-84 Plus CE), il est aujourd'hui à nouveau question de la Zero ZGC4, le clone non officiel qui se préparerait enfin à sortir pour la rentrée 2025 après quatre ans de prototypage !

La dernière fois nous t'annoncions une mise à jour majeure avec l'ajout d'une bibliothèque graphique en Python et pas n'importe laquelle, lvgl !

Par rapport à la concurrence des calculatrices programmables en Python, avec lvgl la Zero ZGC4 cumule l'avantage de la bibliothèque graphique la plus évoluée à ce jour (gestion d'objets graphiques et de leurs événements associés) ainsi que celui exclusif d'une bibliothèque graphique standard ! 👍
Nous avons aujourd'hui du nouveau avec une nouvelle étape majeure de franchie vers la sortie de la Zero ZGC4, avec la mise à jour du site officiel ZeroCalculators.com.

Les pages placeholder génériques laissent enfin la place à un tout nouveau design 3D dédié ! 😍

À bientôt peut-être enfin pour la sortie…

Lien : https://www.zerocalculators.com/

Mise à jour Zero 2.23 avec bibliothèque graphique Python !

New postby critor » 20 Apr 2025, 09:54

22120Fan de la TI-83 Premium CE (ou hors de France de la TI-84 Plus CE), aujourd'hui nous te reparlons de la Zero ZGC4, le clone non officiel qui serait censé sortir pour la rentrée 2025.

Nous avons reçu une nouvelle mise à jour 2.23 pour la ZGC4, également compatible avec le prototype précédent ZGC3.

Plus précisément, nous passons donc de la version 2.22.0 du 11 décembre 2024 à la version 2.23.0 du 25 mars 2025.
Dans la dernière version, nous regrettions que la programmation Python qui devenait enfin fonctionnelle, n'offrait pas encore de bibliothèque graphique.

22130Et bien portons toute notre attention sur la programmation Python, car cela a visiblement bougé une nouvelle fois avec cette dernière mise à jour 2.23.

En effet l'interpréteur Micropython utilisé a été lui aussi mis à jour, passant de la version 1.22.0 sortie le 27 décembre 2023 à la version 1.23.0 sortie le 31 mai 2024.

2213121769Nous n'avons pas besoin de chercher bien loin, un simple appel help("modules") nous indique que le Python de la Zero dispose désormais d'une bibliothèque standard supplémentaire par rapport à la version précédente, lvgl, qui est justement une bibliothèque graphique !

Rappelons que niveau graphismes en Python, les calculatrices concurrents répartissent habituellement les fonctionnalités sur 3 bibliothèques :
  • une bibliothèque de tracé par pixels (habituellement propriétaire, c'est-à-dire spécifique à chaque marque ou pire modèle sans compatibilité du code entre les marques ou modèles)
  • une bibliothèque de tracé dans un repère (matplotlib, standard)
  • une bibliothèque de tracé à la tortue (turtle, standard)

Avec lvgl, la Zero nous offre déjà le gros avantage d'une bibliothèque de tracé par pixels standard !

À partir de l'objet écran lvgl.scr_act(), les méthodes .get_width() et .get_height() nous permettent de déterminer que nous contrôlons une zone graphique de 320×218 pixels, la barre de titre permanente occupant donc 22 pixels de hauteur.

Exemple 1 :
22122
Code: Select all
import lvgl as lv

scr = lv.scr_act()

# Height of persistent header on screen
header_height = lv.get_header_height()

print("Screen width: ", scr.get_width())
print("Screen height: ", scr.get_height())
print("Header height: ", header_height)

def draw_cb(obj, mask, mode):
    if mode == lv.DESIGN.DRAW_MAIN:
        objArea = lv.area_t()
        obj.get_coords(objArea)

        # Fill bg
        bgColor = lv.color_make(0xFF, 0xFF, 0xFF)
        lv.draw_fill(objArea, mask, bgColor, lv.OPA._100)

        styleLine = lv.style_t()
        styleLine.copy(lv.style_plain)
        styleLine.line.color = lv.color_make(0xFF, 0x00, 0x00)
        styleLine.line.width = 3
        styleLine.line.rounded = 1

        # Draw hor line (in coordinates of display (320x240))
        horLinePoint1 = { "x": objArea.x1, "y": objArea.y1 + int(objArea.get_height() / 2) }
        horLinePoint2 = { "x": objArea.x2, "y": objArea.y1 + int(objArea.get_height() / 2) }
        lv.draw_line(horLinePoint1, horLinePoint2, mask, styleLine, lv.OPA._100)

        # Draw ver line (in coordinates of display (320x240))
        verLinePoint1 = { "x": objArea.x1 + int(objArea.get_width() / 2), "y": objArea.y1 }
        verLinePoint2 = { "x": objArea.x1 + int(objArea.get_width() / 2), "y": objArea.y2 }
        lv.draw_line(verLinePoint1, verLinePoint2, mask, styleLine, lv.OPA._100)

        # Draw four pixels
        pxColor = lv.color_make(0x00, 0x00, 0x00)
        lv.draw_px(objArea.x1 + 50, objArea.y1 + 50, mask, pxColor, lv.OPA._100)
        lv.draw_px(objArea.x1 + 50, objArea.y2 - 50, mask, pxColor, lv.OPA._100)
        lv.draw_px(objArea.x2 - 50, objArea.y1 + 50, mask, pxColor, lv.OPA._100)
        lv.draw_px(objArea.x2 - 50, objArea.y2 - 50, mask, pxColor, lv.OPA._100)

        # Draw rectangle
        styleRect = lv.style_t()
        styleRect.copy(lv.style_plain)
        styleRect.body.main_color = lv.color_make(0x00, 0xFF, 0x00)
        styleRect.body.grad_color = lv.color_make(0x00, 0xFF, 0x00)
        styleRect.body.radius = 5

        rectArea = lv.area_t()
        rectArea.set(objArea.x1 + 60, objArea.y1 + 60, objArea.x1 + 100, objArea.y1 + 100)
        lv.draw_rect(rectArea, mask, styleRect, lv.OPA._100)

        # Draw label
        labelStyle = lv.style_t()
        labelStyle.copy(lv.style_plain)
        labelStyle.text.color = lv.color_make(0x00, 0xFF, 0xFF)

        labelOffset = {"x": 0, "y": 0}

        labelArea = lv.area_t()
        labelArea.set(objArea.x1 + 180, objArea.y1 + 60, objArea.x2, objArea.y1 + 80)
        lv.draw_label(labelArea, mask, labelStyle, lv.OPA._100, "Label", 0, labelOffset, None, None, lv.BIDI_DIR.LTR)

        # Draw triangle
        styleRect.body.main_color = lv.color_make(0xFF, 0x00, 0x00)
        trigPoints = [ {"x":200, "y":150},
                        {"x":240, "y":150},
                        {"x":240, "y":200}]
        lv.draw_triangle(trigPoints, mask, styleRect, lv.OPA._100)

        # Draw polygon
        styleRect.body.main_color = lv.color_make(0x00, 0x00, 0xFF)
        polyPoints = [ {"x":100, "y":150},
                        {"x":140, "y":150},
                        {"x":140, "y":200},
                        {"x":100, "y":220}]
        lv.draw_polygon(polyPoints, len(polyPoints), mask, styleRect, lv.OPA._100)

        return True
    else:
        return False

scr.set_design_cb(draw_cb)

print("Main draw finished")

lv.show()


Exemple 2:
22138
Code: Select all
import lvgl as lv

# Create an array for the points of the line
line_points = [ {"x":5, "y":5},
                {"x":70, "y":70},
                {"x":120, "y":10},
                {"x":180, "y":60},
                {"x":240, "y":10}]

# Create new style (thick dark blue)
style_line = lv.style_t()
style_line.copy(lv.style_plain)
style_line.line.color = lv.color_make(0x00, 0x3b, 0x75)
style_line.line.width = 3
style_line.line.rounded = 1

# Copy the previous line and apply the new style
line1 = lv.line(lv.scr_act(), None)
line1.set_points(line_points, len(line_points))      # Set the points
line1.set_style(lv.line.STYLE.MAIN, style_line)
line1.align(None, lv.ALIGN.CENTER, 0, 0)

lv.show()
lvgl se révèle être une bibliothèque de tracé par pixels hautement poussée, encore mieux que le double buffering des Casio et TI-Nspire CX II, nous manipulons hors écran autant de calques que nous voulons, comme sur HP Prime !

Exemple :
22121
Code: Select all
import lvgl as lv

CANVAS_WIDTH  = 200
CANVAS_HEIGHT = 150

style = lv.style_t()
style.copy(lv.style_plain)
style.body.main_color = lv.color_make(0xFF,0,0)
style.body.grad_color = lv.color_make(0x80,0,0)
style.body.radius = 4
style.body.border.width = 2
style.body.border.color = lv.color_make(0xFF,0xFF,0xFF)
style.body.shadow.color = lv.color_make(0xFF,0xFF,0xFF)
style.body.shadow.width = 4
style.line.width = 2
style.line.color = lv.color_make(0,0,0)
style.text.color = lv.color_make(0,0,0xFF)

# CF.TRUE_COLOR requires 4 bytes per pixel
cbuf = bytearray(CANVAS_WIDTH * CANVAS_HEIGHT * 4)

canvas = lv.canvas(lv.scr_act(), None)
canvas.set_buffer(cbuf, CANVAS_WIDTH, CANVAS_HEIGHT, lv.img.CF.TRUE_COLOR)
canvas.align(None, lv.ALIGN.CENTER, 0, 0)
canvas.fill_bg(lv.color_make(0xC0, 0xC0, 0xC0))

canvas.draw_rect(70, 60, 100, 70, style)

canvas.draw_text(40, 20, 100, style, "Some text on text canvas", lv.label.ALIGN.LEFT)

# Test the rotation. It requires an other buffer where the original image is stored.
# So copy the current image to buffer and rotate it to the canvas
img = lv.img_dsc_t()
img.data = cbuf[:]
img.header.cf = lv.img.CF.TRUE_COLOR
img.header.w = CANVAS_WIDTH
img.header.h = CANVAS_HEIGHT

canvas.fill_bg(lv.color_make(0xC0, 0xC0, 0xC0))
canvas.rotate(img, 30, 0, 0, CANVAS_WIDTH // 2, CANVAS_HEIGHT // 2)

lv.show()
Mais ce n'est pas tout… Nul besoin de changer de bibliothèque ici, deux en un, lvgl permet également les tracés dans un repère comme matplotlib !

Exemple :
22124
Code: Select all
import lvgl as lv

# Create a chart
chart = lv.chart(lv.scr_act(), None)
chart.set_size(200, 150)
chart.align(None, lv.ALIGN.CENTER, 0, 0)
chart.set_type(lv.chart.TYPE.POINT | lv.chart.TYPE.LINE)   # Show lines and points too
chart.set_series_opa(lv.OPA._70)                           # Opacity of the data series
chart.set_series_width(4)                                  # Line width and point radious

chart.set_range(0, 100)

# Add two data series
ser1 = chart.add_series(lv.color_make(0xFF, 0x00, 0x00))
ser2 = chart.add_series(lv.color_make(0x00, 0x80, 0x00))

# Set points on 'dl1'
chart.set_points(ser1, [10, 10, 10, 10, 10, 10, 10, 30, 70, 90])

# Set points on 'dl2'
chart.set_points(ser2, [90, 70, 65, 65, 65, 65, 65, 65, 65, 65])

lv.show()
print("LVGL drawing finished")
Mais lvgl c'est encore bien plus que cela, car il s'agit en fait d'une bibliothèque graphique orientée objet. Tu peux en quelques lignes créer nombre d'objets graphiques différents ! 👍

Exemple : boutons poussoir
22136
Code: Select all
import lvgl as lv

def event_handler(obj, event):
    if event == lv.EVENT.CLICKED:
        print("Button clicked")
   
btn1 = lv.btn(lv.scr_act(), None)
btn1.align(None, lv.ALIGN.CENTER, 0, -40)
btn1.set_event_cb(event_handler)
label = lv.label(btn1, None)
label.set_text("Button")

btn2 = lv.btn(lv.scr_act(), None)
# callback can be lambda:
btn2.set_event_cb(lambda obj, event: print("Toggled") if event == lv.EVENT.VALUE_CHANGED else None)
btn2.align(None, lv.ALIGN.CENTER, 0, 40)
btn2.set_toggle(True)
btn2.toggle()
btn2.set_fit2(lv.FIT.NONE, lv.FIT.TIGHT)

label = lv.label(btn2, None)
label.set_text("Toggled")

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for buttons
group = lv.group_create()
group.add_obj(btn1)
group.add_obj(btn2)
keyboard.set_group(group)

lv.show()
print("LVGL drawing finished")


Exemple : boîtes à cocher
2213522134
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("State: %s" % ("Checked" if obj.is_checked() else "Unchecked"))

cb = lv.cb(lv.scr_act(), None)
cb.set_text("I agree to terms")
cb.align(None, lv.ALIGN.CENTER, 0, 0)
cb.set_event_cb(event_handler)

group.add_obj(cb)

lv.show()
print("LVGL drawing finished")


Exemple : interrupteurs à bascule
2214022139
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("State: %s" % ("On" if obj.get_state() else "Off"))

# Create styles for the switch
bg_style = lv.style_t()
indic_style = lv.style_t()
knob_on_style = lv.style_t()
knob_off_style = lv.style_t()

bg_style.copy(lv.style_pretty)
bg_style.body.radius = 800
bg_style.body.padding.top = 6
bg_style.body.padding.bottom = 6

indic_style.copy(lv.style_pretty_color)
indic_style.body.radius = 800
indic_style.body.main_color = lv.color_hex(0x9fc8ef)
indic_style.body.grad_color = lv.color_hex(0x9fc8ef)
indic_style.body.padding.left = 0
indic_style.body.padding.right = 0
indic_style.body.padding.top = 0
indic_style.body.padding.bottom = 0

knob_off_style.copy(lv.style_pretty)
knob_off_style.body.radius = 800
knob_off_style.body.shadow.width = 4
knob_off_style.body.shadow.type = lv.SHADOW.BOTTOM

knob_on_style.copy(lv.style_pretty_color)
knob_on_style.body.radius = 800
knob_on_style.body.shadow.width = 4
knob_on_style.body.shadow.type = lv.SHADOW.BOTTOM

# Create a switch and apply the styles
sw1 = lv.sw(lv.scr_act(), None)
sw1.set_style(lv.sw.STYLE.BG, bg_style)
sw1.set_style(lv.sw.STYLE.INDIC, indic_style)
sw1.set_style(lv.sw.STYLE.KNOB_ON, knob_on_style)
sw1.set_style(lv.sw.STYLE.KNOB_OFF, knob_off_style)
sw1.align(None, lv.ALIGN.CENTER, 0, -50)
sw1.set_event_cb(event_handler)

# Copy the first switch and turn it ON
sw2 = lv.sw(lv.scr_act(), None)
sw2.set_style(lv.sw.STYLE.BG, bg_style)
sw2.set_style(lv.sw.STYLE.INDIC, indic_style)
sw2.set_style(lv.sw.STYLE.KNOB_ON, knob_on_style)
sw2.set_style(lv.sw.STYLE.KNOB_OFF, knob_off_style)
sw2.on(lv.ANIM.ON)
sw2.align(None, lv.ALIGN.CENTER, 0, 50)
sw2.set_event_cb(lambda o,e: None)

group.add_obj(sw1)
group.add_obj(sw2)

lv.show()


Exemple : barre de progression horizontale
22133
Code: Select all
import lvgl as lv

bar1 = lv.bar(lv.scr_act(), None)
bar1.set_size(200, 30)
bar1.align(None, lv.ALIGN.CENTER, 0, 0)
bar1.set_anim_time(2500)
bar1.set_value(100, lv.ANIM.ON)

lv.show()
print("LVGL drawing finished")


Exemple : barre de progression ou d'attente chargement circulaire
22132
Code: Select all
import lvgl as lv

# Create style for the Arcs
style = lv.style_t()
style.copy(lv.style_plain)
style.line.color = lv.color_make(0x00, 0xFF, 0xFF) # Arc color
style.line.width = 8                      # Arc width

# Create an Arc
arc = lv.arc(lv.scr_act(), None)
arc.set_style(lv.arc.STYLE.MAIN, style)   # Use the new style
arc.set_angles(90, 60)
arc.set_size(150, 150)
arc.align(None, lv.ALIGN.CENTER, 0, 0)

lv.show()
print("LVGL drawing finished")


Exemple : champ de saisie numérique
22128
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("Value: %d" % obj.get_value())
    elif event == lv.EVENT.CLICKED:
        # For simple test: Click the spinbox to increment its value
        obj.increment()

spinbox = lv.spinbox(lv.scr_act(), None)
spinbox.set_digit_format(5, 3)
spinbox.step_prev()
spinbox.set_width(100)
spinbox.align(None, lv.ALIGN.CENTER, 0, 0)
spinbox.set_event_cb(event_handler)

group.add_obj(spinbox)

lv.show()


Exemple : jauge 1
22141
Code: Select all
import lvgl as lv

# Create a style
style = lv.style_t()
style.copy(lv.style_pretty_color)
style.body.main_color = lv.color_hex3(0x666)     # Line color at the beginning
style.body.grad_color =  lv.color_hex3(0x666)    # Line color at the end
style.body.padding.left = 10                     # Scale line length
style.body.padding.inner = 8                     # Scale label padding
style.body.border.color = lv.color_hex3(0x333)   # Needle middle circle color
style.line.width = 3
style.text.color = lv.color_hex3(0xFFFFFF)
style.line.color = lv.color_hex3(0xF00)          # Line color after the critical value

# Describe the color for the needles
needle_colors = [
    lv.color_make(0x00, 0x00, 0xFF),
    lv.color_make(0xFF, 0xA5, 0x00),
    lv.color_make(0x80, 0x00, 0x80)
]

# Create a gauge
gauge1 = lv.gauge(lv.scr_act(), None)
gauge1.set_style(lv.gauge.STYLE.MAIN, style)
gauge1.set_needle_count(len(needle_colors), needle_colors)
gauge1.set_size(150, 150)
gauge1.align(None, lv.ALIGN.CENTER, 0, 20)

# Set the values
gauge1.set_value(0, 10)
gauge1.set_value(1, 20)
gauge1.set_value(2, 30)

lv.show()
print("LVGL drawing finished")


Exemple : jauge 2
22142
Code: Select all
import lvgl as lv

# Create a style for the line meter
style_lmeter = lv.style_t()
style_lmeter.copy(lv.style_pretty_color)
style_lmeter.line.width = 2
style_lmeter.line.color = lv.color_hex(0xc0c0c0)              # Silver
style_lmeter.body.main_color = lv.color_hex(0x91bfed)         # Light blue
style_lmeter.body.grad_color = lv.color_hex(0x04386c)         # Dark blue
style_lmeter.body.padding.left = 16                           # Line length

# Create a line meter
lmeter = lv.lmeter(lv.scr_act(), None)
lmeter.set_range(0, 100)                    # Set the range
lmeter.set_value(80)                        # Set the current value
lmeter.set_scale(240, 31)                   # Set the angle and number of lines
lmeter.set_style(lv.lmeter.STYLE.MAIN, style_lmeter)          # Apply the new style
lmeter.set_size(150, 150)

lv.show()


Exemple : curseur
22143
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

# Create a label below the slider
slider_label = lv.label(lv.scr_act(), None)
slider_label.set_text("0")
slider_label.set_auto_realign(True)

def slider_event_cb(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        slider_label.set_text("%u" % obj.get_value())

# Create a slider in the center of the display
slider = lv.slider(lv.scr_act(), None)
slider.set_width(200)
slider.align(None, lv.ALIGN.CENTER, 0, 0)
slider.set_event_cb(slider_event_cb)
slider.set_range(0, 100)

slider_label.align(slider, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)

# Create an informative label
info = lv.label(lv.scr_act(), None)
info.set_text("""Welcome to the slider+label demo!
Move the slider and see that the label
updates to match it.""")
info.align(None, lv.ALIGN.IN_TOP_LEFT, 10, 10)

group.add_obj(slider)

lv.show()


Exemple : liste de choix
22127
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        option = " "*10
        obj.get_selected_str(option, len(option))
        print("Selected month: %s" % option.strip())

roller1 = lv.roller(lv.scr_act(), None)
roller1.set_options("\n".join([
                    "January",
                    "February",
                    "March",
                    "April",
                    "May",
                    "June",
                    "July",
                    "August",
                    "September",
                    "October",
                    "November",
                    "December"]), lv.roller.MODE.INIFINITE)

roller1.set_visible_row_count(4)
roller1.align(None, lv.ALIGN.CENTER, 0, 0)
roller1.set_event_cb(event_handler)

group.add_obj(roller1)

lv.show()
Et bien évidemment, lvgl permet d'organiser nombre de ces objets graphiques de façon complexe et d'en gérer les différents événements ! 👍

Exemple : boîte de dialogue de confirmation ou annulation
22137
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("Button: %s" % lv.mbox.get_active_btn_text(obj))

mbox1 = lv.mbox(lv.scr_act(), None)
mbox1.set_text("A message box with two buttons.")
mbox1.add_btns(["Apply", "Close", ""])
mbox1.set_width(200)
mbox1.set_event_cb(event_handler)
mbox1.align(None, lv.ALIGN.CENTER, 0, 0)  # Align to the corner

group.add_obj(mbox1)

lv.show()


Exemple : Grille de boutons poussoir
22125
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        txt = obj.get_active_btn_text()
        print("%s was pressed" % txt)

btnm1 = lv.btnm(lv.scr_act(), None)
btnm1.set_map( ["1", "2", "3", "4", "5", "\n",
            "6", "7", "8", "9", "0", "\n",
            "Action1", "Action2", ""])
btnm1.set_btn_width(10, 2)        # Make "Action1" twice as wide as "Action2"
btnm1.align(None, lv.ALIGN.CENTER, 0, 0)
btnm1.set_event_cb(event_handler)

group.add_obj(btnm1)

lv.show()
print("LVGL drawing finished")


Exemple : Vues par onglets
22126
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

# Create a Tab view object
tabview = lv.tabview(lv.scr_act(), None)

# Add 3 tabs (the tabs are page (lv_page) and can be scrolled
tab1 = tabview.add_tab("Tab 1")
tab2 = tabview.add_tab("Tab 2")
tab3 = tabview.add_tab("Tab 3")

# Add content to the tabs
label = lv.label(tab1, None)
label.set_text("""This the first tab

If the content
of a tab
become too long
the it
automatically
become
scrollable.""")

label = lv.label(tab2, None)
label.set_text("Second tab")

label = lv.label(tab3, None)
label.set_text("Third tab")

group.add_obj(tabview)

lv.show()


Exemple : zone à défiler
22144
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

valid_pos = [{"x":0, "y": 0}, {"x": 0, "y": 1}, {"x": 1,"y": 1}]

# resolution of the screen
HOR_RES = lv.scr_act().get_width()
VER_RES = lv.scr_act().get_height()

tileview = lv.tileview(lv.scr_act(), None)
tileview.set_valid_positions(valid_pos, len(valid_pos))
tileview.set_edge_flash(True)

# Tile1: just a label
tile1 = lv.obj(tileview, None)
tile1.set_size(HOR_RES, VER_RES)
tile1.set_style(lv.style_pretty)
tileview.add_element(tile1)

label = lv.label(tile1, None)
label.set_text("Tile 1")
label.align(None, lv.ALIGN.CENTER, 0, 0)

# Tile2: a list
lst = lv.list(tileview, None)
lst.set_size(HOR_RES, VER_RES)
lst.set_pos(0, VER_RES)
lst.set_scroll_propagation(True)
lst.set_sb_mode(lv.SB_MODE.OFF)
tileview.add_element(lst)

list_btn = lst.add_btn(None, "One")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Two")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Three")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Four")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Five")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Six")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Seven")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Eight")
tileview.add_element(list_btn)

# Tile3: a button
tile3 = lv.obj(tileview, None)
tile3.set_size(HOR_RES, VER_RES)
tile3.set_pos(HOR_RES, VER_RES)
tileview.add_element(tile3)

btn = lv.btn(tile3, None)
btn.align(None, lv.ALIGN.CENTER, 0, 0)

label = lv.label(btn, None)
label.set_text("Button")

group.add_obj(tileview)

lv.show()
Clairement niveau graphismes Python, dire que la Zero rattrape aujourd'hui les TI-83/84 serait un euphémisme. Bien au-delà, elle les dépasse et les laisse loin derrière ainsi que l'ensemble de la concurrence ! 🥳

Test différentiel Zero ZGC4 et mise à jour 2.22

New postby critor » 23 Jan 2025, 10:30


2174715793Dans une actualité d'avril 2022 nous t'annoncions la sortie pour la rentrée 2022 d'une nouvelle calculatrice graphique en Amérique du Nord, la Zero par l'entreprise du même nom.

Le projet était d'offrir une calculatrice s'utilisant exactement comme une TI-84 Plus CE (équivalent hors de France à la TI-83 Premium CE), tout en utilisant un matériel plus récent et en étant plus abordable.

Le logiciel, développé par Integra Sources (Kazakhstan), reproduisait très minutieusement les interfaces et menus de la TI-84 Plus CE. Si nous sommes habitués à voir des clones plus ou moins réussis de calculatrices scientifiques et graphiques Casio, la Zero était donc à ranger au rang des très rares clones Texas Instruments.

Parmi les améliorations matérielles et logicielles par rapport à une TI-84 Plus CE, nous pouvions citer :
  • niveau recharge et connectivité, le remplacement du port USB mini-AB désuet par un port USB-C
  • à la place du processeur 8 bits eZ80, un processeur 32 bits Cortex-M4 (ARM)
  • un bien meilleur usage de la définition de l'écran, la zone graphique (fenêtre dédiée aux tracés de graphes et également utilisable par les programmes via les instructions de dessin du langage Basic) passant de 265×165 pixels à 320×195 pixels, comme nous venons de l'illustrer avec notre convertisseur d'image img2calc
2174821749
2159121599
Toutefois jusqu'à aujourd'hui, la calculatrice Zero n'est jamais sortie.

Le site officiel dédié ZeroCalculators.com avait même été vidé intégralement de son contenu mi-avril 2022.

La communauté soupçonnait très fortement une intervention de la part de Texas Instruments.
Toutefois le projet a continué depuis.

Nous avons eu droit d'une part à plusieurs révisions matérielles majeures que nous t'avons testées :
  • juin 2022 : ZGC1
  • septembre 2022 : ZGC2 (nouvel écran + extension mémoire RAM)
  • septembre 2023 : ZGC3 (nouveau microcontrôleur + réorganisation clavier + déplacement diode examen)
  • et de plus, nous t'avions annoncé en décembre 2023 l'arrivée future d'une ZGC4











Modèle
TI-84 Plus CE
TI-84 Plus CE Python
Zero
ZGC1
Zero
ZGC2
Zero
ZGC3
Sortie
2015
2022
(dès 2019 en France)
2022
2023
2024
Microcontrôleur
ET2017
JB-007
(+ ATSAMD21E18)
Processeur
Zilog eZ80
Zilog eZ80
(+ coprocesseur Cortex-M0+)
Cortex-M4
Cortex-M4
Cortex-M4
Bus
8 bits
8 bits
(+ coprocesseur 32 bits)
32 bits
32 bits
32 bits
Architecture
ARMv6
(coprocesseur)
ARMv7
ARMv7
ARMv7
Fréquence
48 MHz
48 MHz
100 MHz
100 MHz
200 MHz
RAM intégrée
256 Kio
256 Kio
320 Kio
320 Kio
256 Kio
RAM externe
32 Kio
(coprocesseur)
512 Kio
8 Mio
Flash intégrée
256 Kio
256 Kio
1 Mio
1 Mio
3 Mio
Flash externe
4 Mio
4 Mio
(+ 256 Kio coprocesseur)
4 Mio
4 Mio
8 Mio
Connectivité
USB mini-A/B
USB mini-A/B
USB-C
USB-C
USB-C


Parallèlement à cela, nous avons également eu en test plusieurs versions du logiciel, dont voici une liste non-exhaustive :
Et bien tout semble s'accélérer :
  • bien que n'indiquant pas encore de date de sortie, le site officiel vient d'être réactivé
  • nous venons enfin de recevoir un échantillon prototype de la nouvelle révision Zero ZGC4 :bj:
  • et en prime nous venons également de recevoir une mise à jour 2.22.0
21423Comme déjà décrit, 15 échantillons de test Zero ZGC4 ont été produits pour cette occasion. Ils sont numérotés à la main via un autocollant présent sur la coque, et nous avons reçu les numéros 7 (moi-même) et 13 (Adriweb).

On nous dit que cette fois-ci c'est la bonne, que tous les obstacles ont été levés.

Sauf nouvel incident, la Zero ZGC4 devrait donc enfin sortir pour la rentrée 2025.

En attendant, découvrons donc les changements apportés à la fois par la révision matérielle ZGC4 ainsi que par la mise à jour 2.22.0.










A) Tour de la machine et clavierGo to top

2177721775Premier regard sur la ZGC4 autour de l'écran, zone caractéristique de toute calculatrice graphique, et nous notons deux choses.

D'une part, contrairement aux ZGC3 et révisions plus anciennes, le logo de la marque Zero en haut d'écran passe en couleur et se voit désormais accompagné de la mention de la révision ZGC4.

Nous regrettons toutefois le film de protection de l'écran ZGC4 qui n'a pas du tout la même qualité que celui de la ZGC3 qui n'a pas bougé depuis l'année dernière et fait très pro en comparaison. Ici sur ZGC4 le film est mal fixé et se décolle de tous les côtés, problème constaté dès la réception.

2176421765Passons à la pesée. Bien que conservant les mêmes dimensions que la Zero ZGC3, la ZGC4 perd un petit peu de poids.

Nous passons :
  • avec la coque de 219 grammes à 210 grammes
  • sans la coque de 180 grammes à 176 grammes
2142417591Nous notons un format différent de l'autocollant sur la face arrière, même si il continue à fournir les mêmes informations.

La lisibilité de l'adresse du site officiel est améliorée avec des majuscules, zerocalculators.com devenant ZeroCalculators.com.

La ZGC4 serait plus gourmande en énergie que la ZGC3. Si elle continue à être indiquée comme alimentée par une batterie rechargeable de 5 Volts de tension, l'intensité pour sa part bondit de 0,5 Ampère à 1,5 Ampère, un triplement qui devrait diviser l'autonomie par trois, si c'est vrai et si il s'agit toujours de la même batterie.

Mais ce qui retient le plus notre attention, c'est le clavier.
1758614660Sans doute suite à l'intervention de Texas Instruments, le clavier de la Zero avait déjà été modifié avec la ZGC3.

Il s'était éloigné de celui de la TI-84 Plus CE avec :
  • des touches passant d'une forme rectangulaire à une forme circulaire bombée
  • leur texture abandonnant le plastique pour de la gomme
  • les 4 rangées supérieures de touches (partie proche de l'écran et donc caractéristique dans l'esprit des utilisateurs de l'identité de chaque calculatrice) étaient complètement réorganisées avec :
    • pavé directionnel qui passait au centre, mettant donc gauchers et droitiers à égalité (ce qui ne nous ne nous avait pas trop gênés, nul besoin de bouleverser ses habitudes digitales avec un pavé directionnel au centre, et puis nous étions habitués à d'autres modèles adoptant une organisation similaire comme les NumWorks)
    • touches
      X,Y,θ,n
      ,
      mode
      ,
      del
      et
      clear
      adoptant des emplacements inédits les mettant en valeur
    • et inversement pour leur faire de la place, touche
      stat
      quittant la partie supérieure du clavier
  • plastique de la façade clavier qui abandonne sa finition sablée pour un polissage miroir certes très beau, mais avec malheureusement deux inconvénients majeurs :
    • se transformait en véritable collecteur d'empreintes digitales si l'on ne prenait pas de gants
    • rendait hélas les inscriptions rouge foncé des fonctions alphabétiques plus pénibles à lire sous un éclairage domestique
2142521778La ZGC4 bénéficie visiblement à nouveau d'un changement de clavier :
  • les touches conservent leur forme cylindrique mais cette dernière n'est plus bombée mais creusée
  • leur texture abandonne la gomme pour revenir au plastique
  • on repart de l'organisation clavier TI-84 Plus CE mais avec une réorganisation majeure différente : les rangées de touche au niveau du pavé directionnel (2e et 3e rangées en partant du haut) sont inversées horizontalement ; c'est-à-dire entre autres que le pavé directionnel passe à gauche et les modificateurs de touches
    2nd
    et
    alpha
    à droite
Là où le clavier ZGC3 ne nous avait pas perturbés, ce nouveau clavier ZGC4 est très embêtant.

Ce n'est ici plus un détail anodin, toute manipulation faisant intervenir des touches des 2e ou 3e rangées (notamment les touches fléchées ou modificateurs, c'est-à-dire très souvent) doit être pensée différemment.

C'est particulièrement dérangeant pour les manipulations faisant intervenir des touches de différentes rangées, avec :
  • les touches de la 1ère rangée, de la 4e rangée ainsi que des rangées inférieures s'utilisant normalemnent
  • et toute touche des 2e et 3e rangées pouvant intervenir au beau milieu d'une manipulation devant être pensée différemment
Toutes les rangées du clavier auraient été inversées horizontalement que ça aurait été plus simple...

Mais cela ne devrait toutefois déranger que des utilisateurs qui comme nous étaient déjà déjà habitués à une TI-84 Plus CE (ou TI-83 Premium CE). De nouveaux élèves s'équipant en calculatrice graphique pour la première fois avec une Zero ZGC4 ne devraient pas avoir ce problème.

21431Rajoutons qu'il semble à ce jour y avoir un problème avec ces nouvelles touches ; certaines restent très facilement coincées en position enfoncée. Ceci a été remonté très rapidement, et Zero a confirmé qu'ils sont en effet au courant et qu'ils sont déjà sur un correctif mécanique sur les bords des boutons.

Et en passant si tu n'as pas encore remarqué, nous avons reçu une ZGC4 dont le clavier présente un défaut d'assemblage, la touche séparateur décimal
.
ayant été montée à l'envers :
2177421776






B) MatérielGo to top

La carte électronique de la calculatrice avait varié de référence dans le temps :
  • ZGC1 et ZGC2 : GraphingCalculator 1.11
  • ZGC3 : GraphingCalculator 2.1
Pour connaître la suite, démontons à son tour la Zero ZGC4 :
214332143221434


Nous y découvrons une nouvelle carte de référence ZGC v2.3, que nous pouvons alors comparer avec la version GraphingCalculator 2.1 précédente :

Nous notons la disparition apparente de pas mal de pistes autour de la mémoire RAM (probablement déplacées sur l'autre face ou bien sur une couche interne) mais rien de bien exceptionnel.

Pour les puces majeures, nous restons très exactement avec :
  • en U1 le microcontrôleur GD32F470ZKT6 de chez GigaDevice, offrant :
    • un processeur 32 bits Cortex-M4 cadencé à 200 MHz
    • 256 Kio de mémoire RAM
    • 3 Mio de mémoire Flash
  • en U4 la mémoire Flash de 8 Mio 25Q64JVSIQ de chez Winbond
  • en U3 la mémoire RAM de 8 Mio IS42S16400J-6TLI de chez ISSI
Il va donc nous falloir creuser, mais nous avons fort heureusement quelques pistes.

En effet pour rappel, comme nous te l'annoncions en décembre 2023, la révision matérielle ZGC4 est censée apporter :
  • recharge rapide de la batterie (de 0 à 100% en 1 heure, au lieu de 4,5 heures actuellement)
  • possibilité de configurer le délai d'inutilisation avant la mise en veille de l'écran (baisse de la luminosité)
  • allumage instantané (là où actuellement il y a parfois besoin de maintenir la touche
    on
    )
  • mode économie d'énergie






C) Versions d'usine et mise à jourGo to top

214292175117616À l'écran à propos accessible comme sur TI-84 Plus CE via
2nd
+
1
, la Zero ZGC3 fraichement sortie d'usine indiquait qu'elle faisait tourner un système d'exploitation en version 2.18.3 ainsi qu'un loader (équivalent du Boot chez Texas Instruments) également en version 2.18.3.

La Zero ZGC4 comme on peut s'y attendre est préchargée en usine de versions plus récentes : 2.21.1 ici aussi à la fois pour le système et le loader.

Nous notons également une identification plus précise de la calculatrice, :
  • la ZGC3 indiquait simplement ZERO-001
  • alors que la ZGC4 complète la chose en ZERO-001 HW v1, indiquant donc un matériel en version 1
Mais si la version système 2.21.1 précise donc une information supplémentaire dans l'intitulé, alors il nous faut mettre les deux calculatrices Zero ZGC3 et ZGC4 sur la même version.
2175221751Mettons donc à jour les Zero ZGC3 et ZGC4 vers la même dernière version 2.22.0 que nous venons tout juste de recevoir.

Et nous pouvons confirmer une différence et donc au moins une vérification effectuée par le code sur le matériel :
  • la ZGC3 indique maintenant ZERO-001 HW v0 (matériel en version 0)
  • la ZGC3 indique ZERO-001 HW v1 (matériel en version 1)
En passant, notons que les loaders ne sont pour leur part pas mis à jour et restent dans les deux cas sur leur version programmée en usine.






D) Gestion de l'alimentation et économie d'énergieGo to top

La TI-84 Plus CE disposait de 4 niveaux d'alimentation :
  • maximale lorsque la calculatrice est allumée et en cours d'utilisation, laissant cette dernière consultable et prête à réagir immédiatement à toute pression de touche
  • à partir du moment où la calculatrice n'est plus occupée (évaluation terminée de la dernière saisie, peu importe qu'il s'agisse d'un calcul ou d'un programme) et tant qu'aucune nouvelle touche n'est pressée, la calculatrice compte jusqu'à 1min 30s, avant de baisser la luminosité de l'écran au minimum pour réduire sa consommation d'énergie
  • si tu n'interviens toujours pas, 1min 30s plus tard, soit après 3 minutes d'inutilisation, la calculatrice s'éteint exactement comme si tu avais tapé
    2nd
    on
    , coupant donc l'alimentation de l'écran et de divers autres composants, et réduisant sa consommation au minimum vital permettant de conserver l'état de sa mémoire RAM et de reprendre immédiatement là où tu en étais d'une simple pression sur
    on
  • si tu n'interviens toujours pas, un certain temps après cette extinction (plusieurs heures ou jours ; nous n'avons pas mesuré), la calculatrice passe en deep sleep mode (veille profonde) :
    • sauvegarde du contenu mémoire RAM et mémoire Flash
    • arrêt du système d'exploitation
    • coupure de l'alimentation de la RAM et des autres composants n'étant maintenant plus utilisés
    Ceci permet de réduire la consommation à sa plus simple expression et de conserver ainsi la charge de la batterie pendant de longs mois.
    Au prochain rallumage il te faudra donc patienter quelques secondes, le temps que le système d'exploitation démarre et restaure le contenu RAM à partir de la mémoire Flash.
    Précisons justement que c'est dans cet état que sont les calculatrices neuves en rayon des magasins.

Jusqu'ici les calculatrices Zero de façon similaire :
  • baissaient la luminosité de l'écran après 2 minutes d'inutilisation
  • s'éteignaient après 4 minutes d'inutilisation
Dans les deux cas, il était regrettable de ne pas pouvoir modifier les délais en question...

21753Et bien c'est désormais possible avec la version 2.22 ! 👍

L'écran de configuration accessible via la touche
mode
dispose enfin de lignes relatives à ces délais.

La réduction de la luminosité de l'écran se produit toujours par défaut après 2 minutes d'inutilisation ; mais tu peux aussi configurer ce délai sur 30 secondes, 1 minute, 5 minutes, 10 minutes ou même la désactiver complètement par le réglage Inf pour un délai infini (impliquant donc bien jamais, et dans un contexte scolaire c'est pédagogiquement remarquable de présenter la chose ainsi).

L'extinction de la calculatrice se produit désormais après 5 minutes par défaut, délai que tu peux également régler sur 30 secondes, 1 minute, 2 minutes, 10 minutes ou ici encore Inf pour désactiver l'extinction automatique de la calculatrice.






E) MémoiresGo to top

217541845017764Vérifions maintenant les capacités mémoire utilisables. Pour cela juste après un reset de la calculatrice, accédons au gestionnaire de mémoire avec
2nd
+
2
comme sur TI-84 Plus CE.

Comme mémoire RAM, rappelons que nous avons :
  • 256 Kio intégrés au microcontrôleur
  • 8 Mio soit 8192 Kio sur puce externe
Et bien le gestionnaire de mémoire nous indique toujours une mémoire utilisateur dite encore de travail de 8032 Kio utilisables.
Même si ce n'est pas clairement indiqué à l'écran, nous savons que cet espace est indiqué non pas en Ko (1 Ko = 1000 octets) mais en Kio (1 Kio = 1024 octets), car cet espace était auparavant indiqué en octets avec 8225336 octets.
C'est donc l'espace disponible l'enregistrement à des fins d'utilisation (exécution, modification) des différents types de variables gérés par le système d'exploitation.
C'est ici plus de 53 fois les pauvres 152 Ko de la TI-84 Plus CE ! Tu vas pouvoir en faire des choses avec tout ça…

Comme mémoire Flash maintenant, rappelons que nous avons :
  • 3 Mio soit 3072 Kio intégrés au microcontrôleur
  • 8 Mio soit 8192 Kio sur puce externe
Le gestionnaire de mémoire nous indique toujours une mémoire d'archive dite encore de stockage de 7656 Kio (très probablement la même unité que précédemment même si ici encore l'affichage est ambigu).
C'est ici l'espace disponible pour l'enregistrement à des fins de stockage durable (consultation, sauvegarde) de l'ensemble des variables et fichiers.
C'est plus du double des 3086 Kio de la TI-84 Plus CE, qu'il faut même réduire à 1898 Kio vu les applications préinstallées en usine.

2175621755Petite remarque, le reset sur la Zero crée automatiquement 6 variables de type liste L1 à L6. En les supprimant, il est possible de passer la mémoire de travail de 8032 Kio à 8033 Kio.

Bref niveau capacités mémoire utilisables, il ne semble pas y avoir de changement par rapport à la version précédente.






F) Moteur de calcul et performancesGo to top

Un même moteur de calcul est utilisé pour l'ensemble des fonctionnalités de la calculatrice, à l'exception du Python qui a son propre moteur dédié. C'est de ce moteur transversal dont il va être question ici.

Une façon que nous avons pour identifier un moteur de calcul est le test de la signature trigonométrique. Il s'agit de calculer en mode degrés
$mathjax$Arcsin\left(Arccos\left(Arctan\left(tan\left(cos\left(sin\left(x\right)\right)\right)\right)\right)\right)$mathjax$
.

Le résultat théorique est de 9. Toutefois les calculatrices numériques ne travaillant pas sur la totalité de l'ensemble des nombres réels, et pas davantage sur la totalité de l'ensemble des nombres décimaux, mais sur un tout petit sous-ensemble de nombres dits en virgule flottante, répondent presque toutes une valeur approchante, que nous appelons signature trigonométrique. La valeur en question diffère d'un moteur de calcul à un autre et permet entre autres de déterminer les modèles utilisant le même moteur de calcul.

Les décimales non affichées du résultat peuvent être déterminées par dichotomie.

Et bien nous avons ici une surprise, entre notre test ZGC3 avec la version 2.18.3 et cette version 2.22.0, le résultat a changé, ce qui implique donc des changements majeurs apportés au moteur de calcul voir son remplacement au complet.

En effet :
  • sur la version 2.18.3, la signature trigonométrique était de 8.99999999983257 :
    2176021761
  • sur la version 2.22.0, la signature trigonométrique est désormais de 8.99999999983256924045820355382044
    2175821759
Il ne nous faut pas longtemps pour découvrir le changement majeur derrière cela.

Comme tout ordinateur, en interne les calculatrices Zero travaillent en binaire.

Mais pour des calculatrices graphiques, leur moteur de calcul avait un fonctionnement assez original voir même naïf. En effet pour répondre à tes saisies, les différents nombres y intervenant étaient codés en binaire pour traitement direct par le processeur.

21762C'est facile à mettre en évidence ; par exemple le calcul 0,2+0,1 ne donnait pas exactement 0,3 mais une valeur approchée. En effet 0,1 n'admet pas de décomposition en puissance de 2 et le codage binaire dès le début du traitement de la saisie le remplaçait par une valeur approchée.

En cela le fonctionnement des calculatrices Zero s'opposait à celui toutes les autres calculatrices graphiques actuelles, qui pour leur part utilisent un codage BCD (Décimal Codé Binaire), une représentation codant en binaire non pas les valeurs des nombres, mais leur écriture décimale (avec 4 bits par chiffre).
21763Nous remarquons donc qu'une fois mises à jour les calculatrices Zero trouvent bien que 0,2+0,1=0,3.

Le nouveau moteur de calcul fonctionne donc en BCD.
Mais un changement de moteur de calcul influe également sur les performances de l'ensemble des fonctionnalités de la calculatrice, en dehors du Python comme déjà dit.

Dans notre test ZGC3 en version 2.18.3, nous t'avions présentées les performances de la calculatrice comme exceptionnelles, venant chatouiller celles du haut de gamme HP Prime ou encore de la NumWorks N0120.

Les opérations que tu saisis n'étant plus directement évalués par le cœur de calcul du processeur mais voyant leurs opérandes transposées en nombres BCD pour être ensuite traités par des algorithmes spécifiques à chaque opération, une chute des performances est à craindre.

Voyons donc jusqu'à quel point...
Commençons par un test de performances via un calcul. Il s'agit de mesurer le temps de calcul d'une grosse somme développée par pier4r sur HP Museum, en mode degrés :
$mathjax$\sum\limits_{x=1}^{1000}{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

Pour les modèles trop rapides difficiles à chronométrer, nous multiplions la borne supérieure de la somme, et divisons d’autant le temps chronométré.

Le calcul prend donc :
  • sur TI-84 Plus CE Python : 13,2s
  • sur ZGC3 version 2.18.3 : 0,256s
  • sur ZGC3 version 2.22.0 : 1,558s
  • sur ZGC4 version 2.22.0 : 1,310s
Avec la mise à jour en version 2.22.0, la Zero ZGC3 devient donc 7 fois plus lente pour ce calcul. Elle reste malgré tout dans les 8,5 fois plus rapide qu'une TI-84 Plus CE sur ce même test.

Etrangement, bien que testée dans les mêmes conditions (batterie chargée et câble USB débranché), la Zero ZGC4 fait un peu mieux que la ZGC3.

Comparons avec une sélection de modèles actuels. Avec la ZGC4 en version 2.22.0, la calculatrice Zero chute de la 3e à la 7e place sur ce test :
  1. 0,130s : HP Prime G2
  2. 0,252s : NumWorks N0120
  3. 0,256s : Zero ZGC3 2.18.3
  4. 0,49s : Zero ZGC1/ZGC2
  5. 0,997s : TI-Nspire CX II
  6. 1,100s : NumWorks N0110/N0115
  7. 1,310s : Zero ZGC4 2.22.0
  8. 1,558s : Zero ZGC3 2.22.0
  9. 6,330s : Casio fx-CG500/CP400
  10. 8,550s : Casio fx-CG50 / Graph 90+E
  11. 13,200s : TI-84 Plus CE Python / TI-83 Premium CE Python
  12. 14,100s : Casio fx-9750/9860GIII / Graph 35+E II
La ZGC4 en version 2.22.0 fait désormais moins bien qu'une TI-Nspire CX II malgré un système autrement plus allégé. Elle fait même moins bien que les premiers modèles ZGC1/ZGC2 malgré leur processeur beaucoup moins puissant. Elle fait également pire qu'une NumWorks N0110/N0115 dont le matériel comparable à celui des ZGC1/ZGC2 remonte à la rentrée 2019. En 2025 soit 6 ans après et avec un processeur plus puissant, c'est extrêmement décevant.
Passons sur un test un peu différent, faisant intervenir l’écran graphique. Il s’agit de mesurer le temps nécessaire pour représenter graphiquement la fonction d’expression suivante, en mode radians :
$mathjax$f(x)=0+\sqrt[3]{Arcsin\left(Arccos\left(cos\left(sin\left(Arcsin\left(Arccos\left(Arctan\left(tan\left(cos\left(sin\left(x\right)\right)\right)\right)\right)\right)\right)\right)\right)\right)}$mathjax$

Pour les modèles trop rapides difficiles à chronométrer, nous leur faisons tracer plusieurs fonctions en faisant varier la constante +0 apparaissant dans l'expression, et divisons d’autant le temps chronométré.

Le tracé prend donc :
  • sur TI-84 Plus CE Python : 14,180s pour une fenêtre graphique de 265 pixels de large, soit 53,509ms par colonne
  • sur ZGC3 version 2.18.3 : 1,480s mais pour une fenêtre graphique de 320 pixels de large, soit 4,625ms par colonne
  • sur ZGC3 version 2.22.0 : 2,588s mais pour une fenêtre graphique de 320 pixels de large, soit 8,088ms par colonne
  • sur ZGC4 version 2.22.0 : 2,173s, soit 6,791ms par colonne
Avec la mise à jour en version 2.22.0, la Zero ZGC3 devient donc 1,75 fois plus lente pour les graphes. Elle reste malgré tout dans les 5,5 fois plus rapide qu'une TI-84 Plus CE.

On retrouve cette étrange surperformance de la ZGC4 par rapport à la ZGC3, qui plus est avec le même rapport. Cela commence à beaucoup pour un simple hasard…

Classons ici aussi cela parmi la même sélection de modèles de référence actuels :
  1. 0,219 ms/col : HP Prime G2
  2. 2,634 ms/col : Zero ZGC1/ZGC2
  3. 4,363 ms/col : NumWorks N0120
  4. 4,625 ms/col : Zero ZGC3 2.18.3
  5. 6,791 ms/col : Zero ZGC4 2.22.0
  6. 7,311 ms/col : Casio fx-CG50 / Graph 90+E
  7. 8,088 ms/col : Zero ZGC3 2.22.0
  8. 12,736 ms/col : TI-Nspire CX II
  9. 17,938 ms/col : NumWorks N0110/N0115
  10. 36,252 ms/col : Casio fx-9750/9860GIII / Graph 35+E II
  11. 44,272 ms/col : Casio fx-CG500/CP400
  12. 53,409 ms/col : TI-84 Plus CE Python / TI-83 Premium CE Python
Sur ce test nous échappons à la catastrophe avec des performances de la Zero ZGC4 en apparence similaires à une NumWorks N0120, mais c'est à relativiser :
  • d'une part la Zero ZGC3 dégringole bien au classement en version 2.22.0, et c'est la surperformance pour le moment inexpliquée de la ZGC4 qui compense
  • d'autre part les résultats des NumWorks à ce test se sont nettement dégradés avec les dernières versions, car elles font nombre de choses que les autres modèles ne font pas, notamment en interne une étude des fonctions afin de déterminer automatiquement la meilleure fenêtre pour les représenter

On peut également tester les performances dans le langage interprété ZeroBasic qui utilise le même moteur de calcul.

Voici la transcription d'un algorithme de seuil sur une suite numérique, de niveau Première :
Code: Select all
Prompt(D)
0→N
2→U
D²→D
while (D-1)²≥D do
  1+1/((1-U)*(N+1))→U
  N+1→N
end
{N,U}

Exécuté avec une saisie de 0,008, le programme prend :
  • sur TI-84 Plus CE Python : 94,3s
  • sur ZGC3 version 2.18.3 : 3,29s
  • sur ZGC3 version 2.22.0 : 25,5s
  • sur ZGC4 version 2.22.0 : 21,3s
Avec la mise à jour en version 2.22.0, la Zero ZGC3 devient ici dans les 7 fois plus lente. Elle reste malgré tout dans les 3,7 fois plus rapide qu'une TI-84 Plus CE sur ce même test.

Ici encore même surperformance de la ZGC4 par rapport à la ZGC3, toujours de l'ordre de 20%. Le processeur étant identique comme vu plus haut, c'est à se demander si le nouveau loader ne configurerait pas le processeur sur une fréquence plus élevée…

Voici ici encore le classement :
  1. 0,69s : HP Prime G2
  2. 3,29 s : Zero ZGC3 2.18.3
  3. 7,6 s : Zero ZGC1/ZGC2
  4. 21,3 s : Zero ZGC4 2.22.0
  5. 25,5 s : Zero ZGC3 2.22.0
  6. 50,8s : Casio fx-CG50 / Graph 90+E
  7. 1min 21s : Casio fx-9750/9860GIII / Graph 35+E II
  8. 1min 23,3s : TI-Nspire CX II
  9. 1min 34,3s : TI-84 Plus CE Python / TI-83 Premium CE Python
  10. 10min 8s : Casio fx-CG500/CP400

Bilan, un effondrement catastrophique des performances de la ZGC3 d'un facteur de 7 après mise à jour en version 2.22.

Une surperformance de l'ordre de 20% jusqu'ici inexpliquée de la ZGC4 réduit le facteur à 6.

Malgré cela, des performances extrêmement décevantes, juste comparables à celles d'une NumWorks N0110/N0115, mais il faut rajouter :
  • que le matériel NumWorks N0110/N0115 remonte à la rentrée 2019 et est sensiblement inférieur en terme de capacités
  • qu'en prime les moteurs NumWorks sont autrement plus ambitieux (moteur de calcul plus complet capable de fournir des résultats exacts pour toute saisie algébrique, fenêtrage automatique avec détection intelligente des éléments remarquables à inclure dans la fenêtre pour les graphes)
Dans ce contexte, la sous performance de la Zero en version 2.22 n'est pas justifiable.






G) Python : capacités et performancesGo to top

17756Lors de notre test de la Zero ZGC3, nous découvrions l'ajout du langage de programmation Python.

Toutefois la fonctionnalité était dans un état extrêmement préliminaire et à peine utilisable :
  • aucun éditeur de script n'était présent sur la calculatrice
  • le clavier n'était que fort partiellement géré, ne permettant que la saisie de caractères alphanumériques et symboles usuels, tout autre caractère même indiqué au clavier étant remplacé à la saisie par w
  • aucun menu, il manquait donc entre autres de quoi lister les variables et fonctions définies, ou encore fonctions des bibliothèques intégrées
  • et aucune possibilité de charger des scripts dans la calculatrice, les fichiers .py rajoutés depuis un ordinateur n'étant visiblement pas importables à partir de la console Python
21771Et bien il y a du changement avec la mise à jour 2.22.

Déjà grande nouvelle que nous ne taisons pas plus longtemps, les scripts Python sont enfin gérés. Il t'est possible de charger des scripts sur la calculatrice depuis un ordinateur, et ensuite de les lancer depuis la console avec la commande import qui va bien.

De plus, le choix de la programmation Python proposé sur la touche
prgm
comme illustré ci-dessus, n'ouvre plus directement la console mais un menu par onglets, proposant à son tour :
  • par défaut sur l'onglet EXEC la liste des scripts chargés dans la calculatrice, que tu peux donc lancer directement sans avoir à saisir de commande import !
  • l'accès à la console
  • ou enfin la possibilité de supprimer des scripts
Il manquerait donc encore a priori au moins un éditeur de script.
2178221770La console nous indique que nous avons affaire à un interpréteur Micropython en version 1.23.0 et cette information est également consultable par les scripts dans la bibliothèque sys. Cette dernière précise de plus qu'il s'agit d'une implémentation de Python 3.4.0, et usys.platform permet même à tes scripts de tester si ils tournent ou pas sur une calculatrice Zero, la valeur étant dans ce cas "Zero Graphing Calculator".

Pour rappel :
  • Micropython est une implémentation partielle de Python 3 ciblant les appareils légers et terme de puissance (dont les calculatrices sur piles/batterie)
  • les TI-84 Plus CE utilisent à la place un dérivé de CircuitPython qui est lui-même une version allégée de Micropython
Micropython est donc un excellent choix, effectué d'ailleurs par le reste de la concurrence, et nous notons de plus que l'effort a été fait de le mettre à jour, puisque depuis le test précédent nous passons de la version 1.20.0 à la version 1.23.0 du 31 mai 2024.

En conséquence il s'agit à ce jour de la version Micropython la plus récente actuellement disponible sur calculatrices :
  1. Micropython 1.23.0 (Zero 2.22 + PythonExtra pour Casio)
  2. Micropython 1.20.0 (Zero 2.19)
  3. Micropython 1.17.0 (NumWorks)
  4. Micropython 1.12.0 (KhiCAS/Micropy pour Casio, TI-Nspire et NumWorks)
  5. Micropython 1.11.0 (TI-Nspire CX II)
  6. Micropython 1.9.4 (Casio Graph 90/35+E II + Graph Math+ + fx-CG50/100 + fx-9750/9860GIII + HP Prime)
Le clavier est cette fois-ci mieux géré. Le caractère tiret bas par exemple (_) peut être saisi via la touche
(-)
.

Mais il n'est reste pas moins que nombre de caractères utiles ne sont pas disponibles au clavier, comme par exemple les opérateurs de comparaison. Et toujours aucun menu accessible depuis la console Python, donc on ne peut aller chercher ça ni dans le menu dédié
2nd
math
, ni au catalogue
2nd
0
. Tu n'as que 2 alternatives pour utiliser des caractères non proposés au clavier :
  • saisir le script sur ton ordinateur avant de la même sur la calculatrice
  • 21773construire la ligne que tu souhaites évaluer sous forme de chaîne de caractères, avec les codes ASCII des caractères inaccessibles, puis l'évaluer
    Par exemple, imaginons que tu veuilles tester si pi>22/7, tu devrais alors saisir quelque chose comme ça sur ta calculatrice :
    eval("pi" + chr(62) + "22/7")
21769Comme nous n'avons pas de menu catalogue, passons par help('modules') pour découvrir la collection de bibliothèques à notre disposition.

Comparons avec ce qui est disponible sur TI-84 Plus CE Python :


TI-84 Plus CE Python
Zero 2.19
Zero 2.22
(u)array
cmath
(u)collections
(u)errno
gc
(u)io
math
micropython
os
(u)random
(u)struct
(u)sys
(u)time
turtle













(ajoutable)


























bibliothèques
standard
7-8
8
10

La version Zero précédente offrait déjà davantage de bibliothèques Python standard que la TI-84 Plus CE Python, avec cmath pour les fonctions relatives aux nombres complexes, micropython et ustruct.

La mise à jour 2.22 va encore plus loin, proposant à la fois davantage de bibliothèques standard que sur TI-84 Plus CE Python et sur les versions Zero précédentes. Sont rajoutées errno, io et os.

Nous déplorons toutefois des manques flagrants comme time et random.

Nous regrettons également l'absence de bibliothèque de tracé (matplotlib, turtle), ce qui limite grandement l'intérêt de la programmation Python sur cette machine.
2177217763Interrogeons maintenant la capacité de la mémoire de tas (heap) avec gc.mem_alloc()+gc.mem_free().

Nous déterminons une formidable capacité de 4,016 Mo en version 2.22.
C'est certes en légère baisse par rapport aux 4,048 Mo de la version précédente, mais ça n'en reste pas moins 228 fois plus que sur TI-84 Plus CE et parmi les meilleurs capacités sur calculatrices à ce jour !
  1. 252,1 Mo (HP Prime G2)
  2. 4,048 Mo (Zero 2.19)
  3. 4,016 Mo (Zero 2.22)
  4. 2,068 Mo (TI-Nspire CX II)
  5. 1,033 Mo (Casio fx-CG50/100 + Graph 90+E + Graph Math+)
  6. 100,432 Ko (Casio fx-9750/9860GIII + Graph 35+E II)
  7. 64,888 Ko (NumWorks)
  8. 17,601 Ko (TI-84 Plus CE Python)
Enfin pour terminer, passons aux performances Python, test que nous n'avions pas pu effectuer la dernière fois à cause de l'impossibilité de charger des scripts.

Commençons par un calcul en virgule flottante. Voici la transcription en Python d'un algorithme de seuil sur une suite numérique, niveau Première :
Code: Select all
def seuil(d):
  n = 0
  u = 2.
  d = d ** 2
  while (u-1)**2 >= d:
    u = 1 + 1/((1 - u)*(n + 1))
    n = n + 1
  return [n, u]

La Graph Math+ met 3,57s à évaluer l'appel seuil(0.008).
197791978019781

  1. 0,087s : HP Prime G2
  2. 0,201s : NumWorks N0120
  3. 0,297s : TI-Nspire CX II
  4. 0,341s : Zero ZGC4
  5. 0,411s : Zero ZGC3
  6. 0,714s : NumWorks N0115
  7. 3,270s : Graph 90+E, fx-CG50
  8. 3,570s : Graph Math+, fx-CG100
  9. 3,990s : TI-84+CE Python, TI-84 Plus CE-T Python Edition, TI-83 Premium CE Edition Python
  10. 4,010s : TI-82 Advanced Edition Python
  11. 9,21s : Graph 35+E II, fx-9750/9860GIII
Nous appellerons ici seuil(0.008).

Ici pas d'effondrement par rapport au test précédent, le changement de moteur de calcul évoqué plus haut ne concernant pas les fonctionnalités Python.

Sur des flottants en Python, la calculatrice Zero est donc dans les 10 fois plus rapide qu'une TI-84 Plus CE Python.
Nous notons à nouveau l'étrange surperformance d'environ 20% de la ZGC4 par rapport à la ZGC3, malgré des conditions de tests identiques.
Et terminons maintenant avec un test de performances mais dans le contexte de nombres entiers.

Voici donc un test de primalité retranscrit en Python :
Code: Select all
def nodivisorin(n, l):
  for k in l:
    if n // k * k == n:
      return False
  return True

def isprimep(n):
  l, k = [3], 7
  if n == 2 or n == 5: return True
  if int(n) != n or n // 2 * 2 == n or n // 5 * 5 == 5:
    return False
  if n < k: return n in l
  while k * k < n:
    if nodivisorin(k,l): l.append(k)
    k += 2 + 2*((k + 2) // 5 * 5 == k + 2)
  r = nodivisorin(n, l)
  return r

Voici ce que donne l'appel isprimep(10000019) :
  1. 0,171s : HP Prime G2
  2. 0,406s : NumWorks N0115
  3. 0,451s : TI-Nspire CX II-T
  4. 0,514s : Zero ZGC4
  5. 0,609s : Zero ZGC3
  6. 0,745s : NumWorks N0120
  7. 1,530s : Graph Math+, fx-CG100
  8. 1,580s : Graph 90+E, fx-CG50
  9. 4,39s : Graph 35+E II, fx-9750/9860GIII
  10. 8,910s : TI-84+CE Python, TI-84 Plus CE-T Python Edition, TI-83 Premium CE Edition Python
  11. 9,220s : TI-82 Advanced Edition Python
Nous sommes ici sur ZGC4 dans les 17 fois plus rapide qu'une TI-84 Plus CE Python, et toujours dans les 1,2 fois plus rapide que la ZGC3.
Cette constance autour d'un rapport de 1,2 peu importe les tests que nous effectuons, crédibilise fortement la configuration du processeur à une fréquence plus élevée.






H) Mode examenGo to top

La TI-84 Plus CE dispose de 2 modes examen : un pour les Pays-Bas et un pour l'international, tous deux activables en maintenant une combinaison de touches différente pendant un allumage de la calculatrice.

La calculatrice Zero n'inclut qu'un seul mode examen, que l'on considère donc comme international. Et il présentait de gros avantages par rapport au mode examen international de la TI-84 Plus CE :
  • possibilité de résoudre les systèmes d'équations et trouver les racines de polynômes, là où l'application préchargée nécessaire sur TI-84 Plus CE, PlySmlt2, est inutilisable
  • possibilité de désactiver facilement le mode examen par simple connexion à un hôte USB actif (ordinateur, tablette, smartphone), là où la TI-84 Plus CE exigeait en plus de lancer le logiciel de connectivité TI-Connect CE et de transférer une donnée

Le mode examen avait toutefois un gros défaut sur ZGC3, la diode examen cessait de clignoter calculatrice éteinte ce qui ne convenait pas pour la France. La diode examen doit en effet clignoter de façon permanente à partir du moment où le mode examen est activé, y compris calculatrice éteinte.
Nous ignorons si cela relève du matériel ou du logiciel, peut-être des deux, mais quoi qu'il en soit la mise à jour 2.22 n'améliore strictement rien concernant le clignotement de la diode en mode examen. Cette dernière continue à cesser de clignoter avec l'extinction de la calculatrice, aussi bien sur ZGC3 que ZGC4.

Pire encore comme si cela ne suffisait pas, nous déplorons de plus une lourde régression avec la mise à jour 2.22. La simple connexion à un hôte USB actif ne suffit plus à désactiver le mode examen. Il faut en prime lancer le logiciel de connectivité ZeroConnect sur l'hôte en question, logiciel qui rappelons-le n'est disponible que pour systèmes d'exploitation Windows et Mac.

Nous ne comprenons pas ce changement et donc l'exclusion des appareils nomades type smartphone pour désactiver facilement et rapidement le mode examen entre deux épreuves, les smartphones étant de toutes façons non problématiques puisque non autorisés en cours d'épreuves et donc par définition inutilisables.

Les utilisateurs seront désormais beaucoup plus embêtés, ne pouvant plus désactiver le mode examen entre des épreuves avec le matériel qu'ils ont sous la main, et devant donc aller chercher un ordinateur. Mais pas n'importe quel ordinateur… Un ordinateur Windows ou Mac uniquement, jusqu'ici pas trop de problèmes mais ils arrivent. Si c'est un ordinateur du centre d'épreuves, si il y a des chances d'y trouver TI-Connect CE justement pour désactiver le mode examen, il y aura beaucoup moins de chances d'y trouver ZeroConnect. Et rappelons que l'utilisateur n'aura probablement pas les droits suffisants pour y installer ce logiciel par lui-même.

Non franchement, nous ne comprenons pas la motivation à coder ce changement, qui embête tous les utilisateurs, les forçant en pratique à rentrer chez eux pour désactiver le mode examen depuis leur ordinateur alors que ce n'est pas toujours envisageable en journée entre les épreuves, et ce alors qu'aucune réglementation de mode examen n'interdit à ce jour à notre connaissance la désactivation par simple connexion filaire à un hôte USB actif.






ConclusionGo to top

Après bientôt 3 années, l'interminable attente toucherait enfin à son terme. La calculatrice graphique Zero ZGC4 devrait sortir d'ici la rentrée 2025 si l'on en croit ce que l'on nous dit.

Là où il était (tristement) banal de cloner des calculatrices scientifiques ou graphiques Casio, la chose est exceptionnelle dans le contexte de Texas Instruments où les clones et imitations sont extrêmement rares, et ainsi d'autant plus dignes d'intérêt.

En terme de capacités et fonctionnalités, la ZGC4 est comparable à la TI-84 Plus CE-T Python Edition disponible chez nos voisins européens. Au moins dans un premier temps toutefois, nous nous attendons à ce qu'elle cible le marché nord-américain et donc s'oppose plutôt à la TI-84 Plus CE Python, la seule différence autre que le nom étant juste l'absence d'une diode examen sur cette dernière. La TI-84 Plus CE Python étant trouvable dans les 120-150$ (port éventuel exclu), la ZGC4 devrait logiquement être proposée à un prix inférieur, légèrement on suppose.
Avec la ZGC4 en version 2.22 nous notons des avancées majeures, comme la programmation Python qui devient enfin utilisable, avec :
  • la gestion des touches non alphanumériques du clavier
  • et la possibilité de transférer des scripts depuis un ordinateur
Nous étions très enthousiasmés par la ZGC3, mais nous avons le regret de l'être sensiblement moins par cette ZGC4, surtout vu le rythme extrêmement lent du développement si la sortie est véritablement imminente pour la rentrée 2025.

Comment en effet imaginer que les défauts toujours pas corrigés depuis 3 ans ou même nouvellement introduits avec cette ZGC4 le soient soudainement dans les quelques mois ou même semaines qui restent ?

La qualité hautement inférieure du film de protection de l'écran ZGC4 fait tache sur chacune de nos photos. À côté de ça, le film équivalent sur la ZGC3 n'a pas bougé depuis l'année dernière et fait très pro.
Cela dit, cet échantillon est venu sans packaging cette fois-ci, donc peut-être que ce film grossier a été rapidement ajouté et que cette calculatrice prototype n'est pas passée par le processus de préparation habituel pour de la production de masse.

Parlons clavier, et nous excusons le problème de la touche
.
montée à l'envers. Apparemment sur les 15 échantillons ZGC4 nous sommes les seuls à avoir reçu une calculatrice avec ce défaut ; nous supposons que cela ne se reproduira pas dans le contexte d'une production de masse davantage automatisée.
Mais par contre, le clavier ZGC4, reprenant donc le clavier TI-84 Plus CE mais en inversant horizontalement 3 lignes essentielles, est extrêmement déroutant pour des utilisateurs habitués à Texas Instruments. Il est certes possiblement moins dérangeant pour des élèves s'équipant pour la première fois d'une calculatrice graphique et donc non encore habitués au clavier TI, mais est-ce la cible de ce produit ?
Rajoutons à cela le nouveau format des touches qui se coincent en position enfoncée, même si l'usure à force d'utilisation pourrait atténuer le problème (si c'est juste ça, il faudrait que cela soit fait en usine en aval de la chaîne de montage, avec pression de chaque touche un certain nombre de fois). Toujours est-il qu'ils ont dit être au courant de ce problème-là et vont s'en occuper.

Même si la ZGC4 est comme nous avons vu toujours nettement plus performante que les TI-84 Plus CE (dans les 11-17 fois plus rapide en Python et dans les 4-10 fois plus rapide pour les autres manipulations), hors Python les performances se sont littéralement effondrées vis-à-vis de la ZGC3. Si lors de notre test précédent la ZGC3 arrivait à chatouiller le haut de gamme TI-Nspire CX II ou NumWorks N0120, désormais hors Python c'est sur ZGC4 moins bien qu'une NumWorks N0110/N0115 dont le matériel nettement inférieur remonte à la rentrée 2019 ! Vu son matériel ainsi que le caractère relativement modeste de ses moteurs de calcul et de graphe, la ZGC4 devrait être capable de beaucoup mieux ; il doit y avoir des éléments fort mal optimisés…

Nous regrettons la non conformité du mode examen pour la France (la diode cesse de clignoter calculatrice éteinte). En l'état si tu importes une calculatrice Zero, tu n'auras pas le droit de l'utiliser aux examens. Rajoutons de plus des choix fort mal avisés qui ont été faits sans prévenir, rendant la désactivation légitime du mode examen désormais extrêmement contraignante voir impossible dans nombre de situations.

Il est bien dommage en Python, contrairement à tout le reste de l'interface, de ne pas avoir accès au catalogue permettant de lister l'ensemble des fonctions et saisir l'ensemble des caractères gérés même non présents au clavier. Sans cela le codage sur calculatrice est digitalement pénible, et certains caractères ne peuvent être obtenus que de façon détournée (insérés dans un fichier transféré depuis un ordinateur, ou alors construction avec les codes ascii associés de la saisie souhaitée sous la forme d'une chaîne de caractères qui sera ensuite à évaluer). Nous regrettons également l'absence de bibliothèques graphiques à ce jour.

Globalement tout ceci nous donne l'impression, peut-être fausse, que la ZGC4 n'a pas bénéficié du même soin que la ZGC3. Nous devrions être de plus en plus proche d'un produit finalisé, et nous avons bien au contraire l'impression sur bien des points d'un recul ou au mieux d'une stagnation (à cause d'un développement possiblement trop lent ou trop haché dans le temps et donc décousu).
Espérons toutefois que l'entreprise Zero va pouvoir redoubler d'efforts dans les semaines ou mois qui restent, c'est indispensable, voir même proposer une mise à jour majeure gratuite finalisant le logiciel très rapidement après le lancement pour la rentrée 2025.

On voit en tout cas qu'ils ajoutent des beta-testeurs ces dernieres semaines/mois, ce qui a permis de faire remonter un certain nombre de bugs logiciels que nous n'avions pas forcément vu avant. Nous verrons bien si une v1.23 sort bientôt !

Nous ne manquerons pas de te tenir au courant des évolutions d'ici la rentrée 2025, si il y en a.


Découvre les testeurs des 15 Zero ZGC4

New postby critor » 08 Jan 2025, 11:14

2142421423Prévue pour une sortie d'ici la rentrée 2025, la Zero est un projet de calculatrice graphique reproduisant l'interface et les fonctionnalités de la TI-84 Plus CE-T Python Edition, visant ainsi la compatibilité immédiate avec les manuels scolaires et documents d'enseignants traitant des TI-84 Plus CE ou TI-83 Premium CE.

Sa dernière révision ZGC4 a fait l'objet d'une petite série de production à des fins de tests de validation, et est actuellement entre les mains de testeurs choisis dans la communauté. Sauf nouvel incident, la sortie est prévue d'ici la rentrée 2025.

Contrairement aux révisions précédentes ZGC1, ZGC2 et ZGC3, la ZGC4 est enfin munie d'un numéro de série sous la forme d'un autocollant manuscrit présent sur la coque. Mon autocollant indique 7#, c'est-à-dire que j'ai reçu la 7e ZGC4 de la série.

21714Jesse McLaughlin, la tête pensante du projet, nous révèle que cette série de production comprend 15 unités, et qu'ils en ont juste conservé 3 :
  • la 11# pour lui-même
  • les 1# et 2# pour les ingénieurs

Reste donc à identifier la localisation des 11 autres ZGC4.

Une partie des testeurs ont fort aimablement mis à jour leur inventaire avec l'échantillon reçu sur MyCalcs et l'autre a fort gentiment partagé des photos de leur ZGC4 sur le Discord associé.

Si bien que nous pouvons dès aujourd'hui te révéler la liste intégrale :
21425Si c'est iPhoenix qui semble avoir gagné avec le numéro le plus proche de la ZGC4 numéro 1, pour ma part j'ai apparemment reçu une pièce exceptionnelle, la seule ZGC4 avec un défaut d'assemblage, la touche séparateur décimal
.
ayant été montée à l'envers… 😍

Il est vrai que pour un effectif modeste de 15 unités, on peut encore croire à un assemblage non entièrement automatisé avec intervention d'opérateurs humains sujets à ce genre d'erreur.

Bref, si tu as des questions sur la ZGC4, te voici dès à présent pourvu(e) d'un bon carnet d'adresses. ;)




Source : via viewtopic.php?t=26908&p=277127#p277127
Link to topic: Découvre les testeurs des 15 Zero ZGC4 (Comments: 2)

Mise à jour img2calc : support images Pic Zero ZGC4

New postby critor » 02 Jan 2025, 12:16

2160013917img2calc est notre service en ligne gratuit te permettant de convertir facilement et rapidement des images pour tes projets sur calculatrices.

Un large choix de formats cible t'était proposé :
  • fichiers à appeler depuis tes programmes en langage Basic :
    • .g3p pour Casio Graph 90+E, Graph Math+ et fx-CG100/50/20/10
    • .c2p pour Casio fx-CP400 et fx-CG500
    • .8ca ou .8ci pour TI-82 Advanced Edition Python, TI-83 Premium CE, TI-84 Plus CE et TI-84 Plus C Silver Edition
    • .8xi pour TI-83 Plus (compatible TI-82 Plus, TI-82 Advanced monochrome et TI-84 monochrome),
    • .83i pour TI-83 (compatible TI-82 Stats et TI-76.fr)
    • .82i pour TI-82
    • .86i pour TI-86
    • .85i pour TI-85
    • .73i pour TI-73
  • fichiers à appeler depuis tes scripts en langage Python :
    • IM8C.8xv pour les éditions Python des TI-83 Premium CE et TI-84 Plus CE
  • scripts Python pour les différentes bibliothèques de tracé par pixels disponibles selon les modèles :
    • ti_draw (TI-Nspire CX II)
    • graphic (TI-Nspire CX II avec KhiCAS, TI-Nspire CX avec KhiCAS, NumWorks avec KhiCAS, Casio Graph 90+E et fx-CG50 avec KhiCAS)
    • nsp (TI-Nspire avec Micropython)
    • ti_graphics (TI-83 Premium CE et TI-84 Plus CE éditions Python)
    • casioplot (Casio Graph 90/35+E II, fx-9750/9860GIII et fx-CG50)
    • hpprime (HP Prime)
    • kandinsky (NumWorks)

21425Sauf nouvel incident, l'année 2025 va voir la sortie d'une nouvelle calculatrice graphique qui nous était promise depuis 2022, la Zero ZGC4, dont nous avons l'honneur d'avoir un exemplaireses, un modèle s'inspirant très fortement des TI-84 Plus CE (équivalents hors de France aux TI-83 Premium CE) et comparable à une TI-84 Plus CE-T Python Edition.

Comme cette dernière, la ZGC4 est programmable dans 2 langages, Python et ZeroBasic.

215902159321589Pour tes projets en langage TI-Basic, les TI-84 Plus CE et TI-83 Premium CE géraient des images sous 2 formats de variables supportés par img2calc :
  • .8ca pour 10 images d'arrière plan Image0 à Image9 (affichées avant le tracé des axes graphes éventuels) : 134×83 pixels (affichées avec un zoom ×2) en 65536 couleurs librement décrites en RGB-565
    215912159421592
  • .8ci pour 10 images de premier plan Pic0 à Pic9 (affichées après le tracé des axes et graphes éventuels) : 265×165 pixels en 16 couleurs prises dans la palette du système (15 couleurs fixes illustrées ci-dessous + 1 couleur transparente)
2159521596

2159821597La Zero ZGC4 ainsi que ses prototypes prédécesseurs ZGC1/ZGC2/ZGC3 gèrent de façon similaire pour tes projets en langage ZeroBasic :
  • 10 images d'arrière plan Image0 à Image9
  • 10 images de premier plan Pic0 à Pic9
Mais les fichiers .8ci et .8ca générés pour TI-83 Premium CE et TI-84 Plus n'étaient pas reconnus une fois transférés sur ZGC4, les formats d'images étaient donc différents.

Nous avons étudié le format d'image de premier plan Pic de la ZGC4 et t'annonçons aujourd'hui son ajout à img2calc.

Le format des 10 images de premier plan Pic0 à Pic9 de la ZGC4 profite de sa différence pour nous apporter nombre d'avantages par rapport aux TI-83 Premium CE et TI-84 Plus CE
  • définition en 320×195 pixels (au lieu des 265×165 pixels du .8ci)
  • profondeur de 65536 couleurs (au lieu des 16 couleurs du .8ci), codées en RGB-565 exactement comme les images d'arrière plan .8ca !
  • à la différence du .8ca, gestion de la transparence !
Bref, le format combine donc et même améliore les avantages des .8ci et .8ca (définition meilleure que le .8ci, couleurs 16 bits comme le .8ca, transparence comme le .8ca), ouvrant ainsi la voie à de formidables futurs projets en langage ZeroBasic ! 👍
215872158821599

Liens :

-
Search
-
Social TI-Planet
-
Featured topics
Comparaisons des meilleurs prix pour acheter sa calculatrice !
"1 calculatrice pour tous", le programme solidaire de Texas Instruments. Reçois gratuitement et sans aucune obligation d'achat, 5 calculatrices couleur programmables en Python à donner aux élèves les plus nécessiteux de ton lycée. Tu peux recevoir au choix 5 TI-82 Advanced Edition Python ou bien 5 TI-83 Premium CE Edition Python.
Enseignant(e), reçois gratuitement 1 exemplaire de test de la TI-82 Advanced Edition Python. À demander d'ici le 31 décembre 2024.
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
1512 utilisateurs:
>1486 invités
>20 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)