Routines 'système' de Ndless

[grosged]

@nbenm, pas mal
Ma version que je t'avais précédemment envoyée t'a apparemment aidé ou inspiré
Précision importante: cette routine est pour modèle W et supérieur (écran 240x320)

[Noury]

@nbenm, pas mal

Ça fait plaisir d'entendre (lire) ça.

Ma version que je t'avais précédemment envoyée t'a apparemment aidé ou inspiré

Pas vraiment, j'avoue que je ne l'ai pas encore lue. Mais ton code qui figure au début de ce topic, oui largement.
Je pense aux subroutines PAUSE et CLEAR, et à l'include.
Mais je vais prendre le temps de lire ton code maintenant. Par curiosité surtout.
L'information de @critor concernant les deux octets par pixel m'a permis de comprendre comment l'écran était constitué.
Mais plus important, tu m'as donné envie de faire de l'assembleur. Merci pour ça .
Pour le reste c'est de l'assembleur "old school". Je n'en ai pas fait depuis de nombreuses années.

Précision importante: cette routine est pour modèle W et supérieur (écran 240x320)

C'est vrai, je ne l'avais pas indiqué.

Autre chose, dans mon post précédent je n'avais pas mis le dessin des caractères. Je mets en PJ l'Excel dans lequel j'ai dessiné les caractères. Ça, et la saisie en hexa, c'est ce qui m'a demandé le plus de temps.

[Noury]

@grosged j'ai regardé ton code.
Il est beaucoup plus concis et élaboré que le mien.
Je n'ai jamais utilisé d'instructions conditionnelles comme strcsh par exemple. C'est un vrai plus.
Je vois que tu n'as pas non plus utilisé le scrolling. Mais c'était d'ailleurs un peu HS. Je suis curieux de savoir comment se comporte le syscall d'ailleurs à ce sujet. Idem pour les retours lignes (que toi tu gères).
Je n'ai pas eu le courage d'essayer de comprendre ta gestion de la police de caractères. J'ai essayé d'en décoder un, mais je pense être tombé sur "?". De plus, tu en as 255 si je ne me trompe pas.
Sur ce point, j'ai l'impression que nous sommes partis sur une idée similaire, mais que tu as des matrices de 8x8.
Un point m'intrigue. Comment gères-tu les versions de calculatrices ?

Tu devrais le publier. Il est chouette, et il y a des personnes que ça intéressera.

[grosged]

@nbenm, J'ai tardé à répondre car j'ai eu un sacré souci : impossible de relire ma clé usb contenant mes fichiers-source (versions 320x240 & 240x320). Heureusement, j'ai encore l'archive.zip que je t'avais envoyée
(Je vais finir par sauvegarder en "cloud", moi... )
J'ai fait quelques modifications (correction du bug d'affichage, suppression de la routine SCROLL, par ex)

Code: Select all

//      as -aln -mcpu=arm926ej-s -o .temp.o PrintW.s && objcopy -O binary .temp.o PrintW.prg.tns

        .asciz  "PRG"                   @ en-tête "PRG"
       
        push    {r0-r12,lr}
        bl      CLEAR                   @ efface l'écran
       
        adrl    r0,Texte
        mov     r1,#5                   @ coord X
        mov     r2,#4                   @ coord Y
        ldr     r3,=0b1111111111100000  @ couleur jaune
        ldr     r4,=0b0000000000011011  @ fond bleu
        bl      PRINT                   @ lance l'affichage
       
        mov     r1,#0                   @ autre coord X
        mov     r2,#9                   @ et Y
        bl      PRINT
       
        bl      PAUSE
        pop     {r0-r12,pc}

/***************************************************************/

PRINT:  cmp     r1,#40                  @ X>=40 ?
        movhs   r1,#0                   @ alors à zéro
        push    {r3-r12,lr}
        adr     r6,SaveX
        str     r1,[r6]                 @ mémorise X de départ
        mov     r5,#480
        adrl    r8,ATI8x8                       @ datas de la fonte
prnewp: cmp     r2,#30                  @ Y>=30 ?
        movhs   r2,#29                  @ si oui,  à 29
        mov     r9,#0xC0000010
        ldr     r9,[r9]                 @ début d'adresse écran
        mov     r7,#3840
        mla     r7,r1,r7,r9             @ r7=X*3840+adresse écran...
        add     r7,r7,r2,lsl#4          @ ...+Y*16=position précise en mém écran
pri_lp: ldrb    r9,[r0],#1              @ lis 1 caractère ASCII
        cmp     r9,#0                   @ = 0 ?
        popeq   {r3-r12,pc}             @ alors on arrète!
        cmp     r9,#124                 @ "|" ? (retour à la ligne)
        beq     retlig                  @ si oui, on y va!
        add     r1,r1,#1                        @ X=X+1
        add     r9,r8,r9,lsl#3          @ pointe sur les data adéquats
        mov     r10,#8                  @ val de loop (hauteur)
hbitlp: ldrb    r11,[r9],#1             @ 1 ligne de 8bit
        lsl     r11,r11,#24             @
        mov     r12,#8                  @ val de loop (largeur)
        add     r6,r7,#2
wbitlp: adds    r11,r11,r11             @ état du bit le+à gauche?
        strcsh  r3,[r7],r5              @=1 alors on écrit
        strcch  r4,[r7],r5              @=0 alors couleur de fond
        subs    r12,r12,#1
        bne     wbitlp
        mov     r7,r6                   @ Repositionne l'adr écran
        subs    r10,r10,#1              @ pour prochaine ligne à afficher
        bne     hbitlp                  @ Quand tout est fait: part 8 pixels
        add     r7,r7,#3824             @ sur la droite pour prochain caractère!
        cmp     r1,#40                  @ X >=40 ?
        bcc     pri_lp
        ldrb    r9,[r0],#1
        cmp     r9,#124                 @ "|" ? (retour à la ligne)
        subne   r0,r0,#1
retlig: adr     r1,SaveX
        ldr     r1,[r1]
        add     r2,r2,#1
        cmp     r9,#0
        bne     prnewp
        pop     {r3-r12,pc}
SaveX:  .word   0
        .align
       
       
CLEAR:  push    {r0-r2,lr}
        mov     r0,#0xC0000010
        ldr     r0,[r0]
        mov     r1,#0
        mov     r2,#9600
clr_lp: str     r1,[r0],#4
        subs    r2,#1
        bne     clr_lp
        pop     {r0-r2,pc}


PAUSE:  push    {r0,lr}
        mov     r0,#0x08000000
waitlp: subs    r0,#1
        bne     waitlp
        pop     {r0,pc}

/***************************************************************/
ATI8x8: .incbin "Bm437ATI8x8.bin"
        @ BIG thanks to VileR ( https://int10h.org/oldschool-pc-fonts/ )
        @ for these so cool retro fonts!
       
Texte:  .asciz  "Bienvenue!|"
        .ascii  "Hey ! On dirait que ca marche, non ?|Tout va bien?|Alors, c'est OKAY !!|"     
        .asciz  "Qu'est-ce que je pourrais ameliorer..?"
         

Voilà ! Je vais joindre à ce post un lien vers l'archive
archives_voir.php?id=2061392

Toujours en assembleur, en ce qui concerne une façon de distinguer si l'on a affaire à un écran 240x320 ou non , j'ai une idée "purement graphique" mais je n'ai encore rien testé (sinon , pour les autres tests comme monochrome/couleur , ou clickpad/touchpad , voir viewtopic.php?f=20&t=20375 )

EDIT: je viens de relire ce post ...viewtopic.php?f=20&t=22363
Serait-ce possible d'écrire une version assembleur de ces quelques ligne de C ?

[Limonadd]

Salut! Alors nbem et grosged bravo pour vos routines d'affichages! J'en avais fais une pour ti 83 pce, donc en asm ez80, mais les données pour la police prenaient beaucoup de place. J'en ai pour 16ko pour la police, ce qui est énorme. La routine pour afficher en elle même ne prend pas beaucoup de place. Je pense pouvoir optimiser les données de police pour arriver à 10ko environ. Mais @grosged, j'ai vu que tu n'avais que 2ko pour ta police!!!! Si tu pouvais nous donner ton astuce, enfin comment tu as organisé le truc ça serait super, et ça m'aiderait grandement à m'améliorer en terme d'optimisation! je pense pouvoir réduire un peu la taille, mais jamais je n'arriverais à avoir seulement 2ko... bravo à toi en tout cas!

[grosged]

Merci, @Limonadd

Je pense deviner pourquoi ta police prends 16 Ko : ça doit être une fonte 8x8 pixel que tu as certainement codée avec 1 pixel = 1 octet.
Par contre, si tu passes en codage binaire, avec 1 pixel = 1 bit = 1/8 d'octet, là tu passes tout de suite de 16Ko à 2Ko ( parce que 256 caractères x 8 octets, exactement comme dans ma routine )
On peut même encore descendre en dessous des 2ko : en limitant le nombre de caractères disponibles ( comme l'a fait @nbenm dans sa routine).
Après , il y a d'autres astuces pour aller plus loin dans l'économie de données, par exemple, en utilisant un affichage de type "segment".
En effet, 7 segments plus le point, ça ne prends qu'un octet !!
Mais on pourrait grapiller encore (donc baisser le nombre de bit pour coder un caractère) en étudiant la nature d'apparition de tel ou tel segment : lesquels sont toujours ensemble? Lesquels ne sont jamais utilisés? .. etc

Sinon, en terme d'optimisation , je trouve très intéressant un affichage "texte" (police 8x8) en mode graphique 1bpp (1bit par pixel) : bien qu'ayant seulement 2 couleurs disponibles (tout de même définies par nos soins en composantes rouge/vert/bleu) , dans ce mode , l'écriture d'un simple octet en mémoire-écran affiche 8 pixels d'un coup !!! (donc , plus la peine de lire chacun des 8 bits de chacun des 8 octets représentant un caractère : un copier/coller suffit

[Limonadd]

Ah oui je vois! Merci beaucoup

[Noury]

l'écriture d'un simple octet en mémoire-écran affiche 8 pixels d'un coup !!! (donc , plus la peine de lire chacun des 8 bits de chacun des 8 octets représentant un caractère : un copier/coller suffit

Bien vu. Avec mes 10 pixels en vertical ce n'était pas possible. Donc code plus complexe.
Pour certains lecteurs ce sera de la tétrapilotomie*, mais c'est très intéressant pour la gymnastique de l'esprit.

*tétrapilotomie: art de couper les cheveux en quatre (il me semble que ça vient de San Antonio - Frédéric Dard)

[Noury]

Bonjour,

L'histoire de l'appel de fonctions système pour écrire sur l'écran m'a pas mal tracassé.
J'ai donc repris mon baton de pèlerin, et j'ai réussi à obtenir quelques résultats.

J'ai utilisé deux formes d'affichage:
1 - écriture sur la console
2 - écriture sur l'écran

Pour la première, il faut soit utiliser un émulateur, soit relier le port TX à une console sur un ordi pour pouvoir observer le résultat.
Pour celle-ci, j'ai utilisé deux méthodes:
1 - appel à la fonction printf
2 - interruption software et appel à une routine système (appel 10)
C'est ce qu'on voit au début du programme (lignes 22 à 26).
C'est assez simple.

Dans la suite du programme, on utilise les fonctions nSDL. Il s'agit d'un portage de la bibliothèque SDL sur Nspire. Les include sont dans Ndless/ndless-sdk/include/SDL.
Le code est assez bien commenté pour être compréhensible.

Code: Select all

.data
.balign 4
hello1: .asciz "\nHello World!\n"
hello2: .asciz "\nHello TI-Planet!\n"

.text
.global main
.extern printf
.extern SDL_Init
.extern SDL_SetVideoMode
.extern nSDL_LoadFont
.extern SDL_MapRGB
.extern SDL_FillRect
.extern nSDL_DrawString
.extern SDL_Flip
.extern SDL_Delay
.extern SDL_Quit

main:
    push    {r0-r12, lr}

    ldr     r0, =hello1
    bl      printf     // par fonction externe

    ldr     r0, =hello2
    svc     10         // par interruption software e_printf

    // Initialisation SDL
    mov     r0,#0x00000020 // SDL_INIT_VIDEO
    bl      SDL_Init
    // Mode vidéo
    mov     r0,#320
    mov     r1,#240
    mov     r2,#16     // Nspire couleur. Sinon mettre 8
    mov     r3,#0      // SDL_SWSURFACE (surface dans la mémoire système)
    bl      SDL_SetVideoMode
    mov     r4,r0      // screen dans r4
    // sélection de la police de caractères, et de sa couleur
    mov     r0,#0      // police NSDL_FONT_THIN
    mov     r1,#255    // |
    mov     r2,#255    // | on choisit d'écrire en blanc
    mov     r3,#255    // |
    bl      nSDL_LoadFont
    mov     r5,r0      // font dans r5
    // dessin d'un fond d'écran rectangulaire d'une couleur donnée
    ldr     r0,[r4,#4] // screen format
    mov     r1,#0      // |
    mov     r2,#0      // | fond noir
    mov     r3,#0      // |
    bl      SDL_MapRGB
    mov     r6,r0
    mov     r0,r4      // screen
    mov     r1,#0
    mov     r2,r6
    bl      SDL_FillRect
    // dessin de la chaine aux coordonnées indiquées
    mov     r0,r4
    mov     r1,r5
    mov     r2,#100    // |
    mov     r3,#100    // | coordonnées en pixels
    ldr     r6,=hello2
    str     r6,[sp]
    bl      nSDL_DrawString // On dessine la chaine mais rien n'est visible
    // affichage sur l'écran
    mov     r0,r4      // surface
    bl      SDL_Flip   // Affichage réel sur l'écran
    // on temporise (en principe ms d'après SDL_timer.h, mais à vérifier)
    mov     r0,#0x1000 // temporisation avant de quitter
    bl      SDL_Delay
    // et enfin, on quitte
    bl      SDL_Quit   // on quitte

    pop     {r0-r12, pc}

Je n'ai testé que sur ma Nspire récente.