Graphiques avec la carte Galaxia

Cet article a pour objet de proposer une bibliothèque minimale écrite en Python et destinée à afficher des graphiques et/ou du texte sur l’écran de la carte Galaxia. Pour cela nous proposons deux classes : une classe Font pour définir un jeu de caractères et une classe Screen comportant les différentes fonctions d’affichage.

La classe Font

Le choix s’est porté sur une fonte non proportionnelle de dimensions 8 pixels en largeur sur 8 pixels en hauteur. L’écran de la carte Galaxia ayant une résolution de 160 pixels en largeurs sur 128 pixels en hauteur, cela permet d’afficher 16 lignes de 20 caractères. Pour stocker un caractère, il faut 8 octets, La fonte est donc mémorisée dans un fichier binaire « font8x8.bin » de 2048 octets. Ce fichier a été généré à partir du fichier texte 8x8_horizontal_MSB_2.asm disponible sur github basti79 Cette fonte a l’apparence suivante:

Classe Font.py

Python

class Font:
    def __init__(self,path,w,h):
        self.path=path
        self.data=[]
        self.width=w
        self.height=h
        self.setFont(path,w,h)
        
    def setFont(self,path,w,h):
        self.w=w
        self.h=h
        with open(path,"rb") as finp:
            self.data=finp.read()

La classe Screen

La classe Screen a été écrite à partir d’informations obtenues avec l’aide GPT 3.5 en chattant sur micropython et circuitpython. Les suggestions de Chat GPT ont été éventuellement modifiées afin qu »elles donnent les résultats attendus. En résumé la classe Screen propose un constructeur permettant de définir les dimensions de l’écran, un bitmap correspondant à ces dimensions associé à une palette de 256 couleurs. Ainsi nous avons choisi que chaque pixel pouvait avoir l’une des 256 couleurs. Ces couleurs sont définies par un calcul à partir de 3 entiers compris entre 0 et 255 (rouge, vert, bleu).

Les fonctions disponibles sont:

setColor(r,g,b) : définit la couleur courante de tracé (composantes : rouge, vert et bleu). Toutes fonctions suivantes ( exceptée fillScreen )utilisent la couleur de tracé courante
drawPixel(x,y) : trace un pixel en colonne x et ligne y
drawLine(x0,y0,x1,y1) : trace un segment de droite du point (x0,y0) au point (x1,y1)
drawRect(x,y,w,h) : dessine un rectangle dont le point en haut et à gauche a pour coordonnées (x,y), de largeur w et de hauteur h
fillRect(x,y,w,h) : dessine un rectangle plein (voir drawRect pour les paramètres)
drawChar,c,x,y): affiche le caractère c en position colonne x et ligne y
drawString(string,x,y) : affiche la chaine de caractères string en position colonne x et ligne y
drawCircle(x,y,r) : dessine un cercle centré en x,y et de rayon r
fillScreen(r,g,b): remplit complétement l’écran avec la couleur spécifiée

Python

import board
import math
import displayio
from font import *

class Screen:
 
    def __init__(self,w,h):
        screen=displayio.Group()
        board.DISPLAY.show(screen)
        self.bitmap=displayio.Bitmap(w,h,256)
        self.palette=displayio.Palette(256)
        self.indexpal=255
        self.font=Font("font8x8.bin",8,8)
        for i in range(256):
            # Calculer les composantes RVB en fonction de la position dans la palette
            r = int((i >> 5) & 7) * 255 // 7
            g = int((i >> 2) & 7) * 255 // 7
            b = int((i >> 0) & 3) * 255 // 3
            # Ajouter la couleur à la palette
            self.palette[i] = (r << 16) | (g << 8) | b
        group = displayio.Group(x=0,y=0)
        group.append(displayio.TileGrid(self.bitmap,pixel_shader=self.palette))
        screen.append(group)
   
    def rgb_to_palette_index(self,r, g, b):
       # Calculer la distance euclidienne pour chaque couleur de la palette
       distances = [((r – ((color >> 16) & 0xFF))**2 +
                  (g – ((color >> 8) & 0xFF))**2 +
                  (b – (color & 0xFF))**2) for color in self.palette]
       # Trouver l'indice de la couleur de la palette avec la distance minimale
       return distances.index(min(distances))

    def setColor(self,r,g,b):
        self.indexpal=self.rgb_to_palette_index(r,g,b)
         
    def drawPixel(self,x,y):
        self.bitmap[x,y]=self.indexpal    
         
    def drawLine(self,x0, y0, x1, y1):
        dx = abs(x1 – x0)
        dy = abs(y1 – y0)
        sx = 1 if x0 < x1 else -1
        sy = 1 if y0 < y1 else -1
        err = dx – dy
        x=x0
        y=y0
        while True:
            self.drawPixel(x, y)
            if x == x1 and y == y1:
                break
            e2 = 2 * err
            if e2 > -dy:
                err -= dy
                x += sx
            if e2 < dx:
                err += dx
                y += sy    

    def drawRect(self,x,y,w,h):
        self.drawLine(x,y,x+w,y)
        self.drawLine(x+w,y,x+w,y+h)
        self.drawLine(x+w,y+h,x,y+h)
        self.drawLine(x,y+h,x,y)

    def fillRect(self,x,y,w,h):
        colfin=x+w-1
        for i in range(h):
            self.drawLine(x,y+i,colfin,y+i)
     
    def drawChar(self,c,x,y):
        nb=8                  # nboctets pour un caractere
        offset=int(ord(c)*nb) # offset dans la fonte
        for i in range(8):
             masque=128
             octet=self.font.data[offset+i]
             for j in range(8):
                    if octet & masque==masque:
                        self.drawPixel(x+j,y+i)
                    masque>>=1      
                    
    def drawString(self,string,x,y):
        for i in range(len(string)):
            self.drawChar(string[i],x+i*8,y)                  

    def fillScreen(self,r,g,b):
        self.bitmap.fill(self.rgb_to_palette_index(r,g,b))

    def drawCircle(self,x,y,r):
        nbpoints=8*r
        col=x
        lig=y
        for i in range(nbpoints):
            theta=2*math.pi*i/nbpoints
            col=int(x+r*math.cos(theta))
            lig=int(y+r*math.sin(theta))
            self.drawPixel(col,lig)

Exemple d’utilisation

Python

import traceback
import time
from screen import *
    
def ligne(x1,y1,x2,y2,r,g,b):
    ecran.setColor(r,g,b)
    ecran.drawLine(x1,y1,x2,y2)
    
try:
    ecran=Screen(160,128)
    ecran.fillScreen(255,255,255)
    ligne(0,0,159,0,255,0,0)
    ligne(0,0,0,127,0,0,255)
    ligne(0,127,159,127,0,255,0)
    ligne(159,0,159,127,255,0,255)
    ecran.drawRect(0,0,30,50)
    ecran.drawString("Hello world !",5,60)
    ecran.setColor(255,255,0)
    ecran.fillRect(1,100,80,5)
    ecran.setColor(0,255,0)
    ecran.drawCircle(80,64,63)
    time.sleep(5)
    ecran.fillScreen(0,0,0)
    ecran.setColor(255,255,255)
    col=0
    lig=0
    for i in range(256):
        ecran.drawChar(chr(i),col,lig)
        col+=8
        if col>152:
            col=0
            lig+=8
    
    """
    time.sleep(5)        
    ecran.fillScreen(0,0,0)
    ecran.drawCircle(80,64,63)
    """
except Exception as e:
    trace_str = ''.join(traceback.format_exception(type(e), e, e.__traceback__))
    print(trace_str)    
while True:
    pass

Grimeco

Graphiques avec la carte Galaxia

La classe Font

La classe Screen

Exemple d’utilisation

A DECOUVRIR EGALEMENT

Éditeur de Schémas Électroniques

Ollama : Intégration de LLMs en local

Raspberry Radio Internet (Partie 1)

Laisser un commentaire Annuler la réponse