byte 'vergroten' naar 2 byes

Arco

Special Member

Momenteel gebruik ik voor een grafisch display een 8x16 font. Da's opgeslagen in een array en dat werkt prima.
Nu wil ik er echter ook een groter font bij hebben van 16x32 pixels.

Ik kan natuurlijk een nieuwe arraytabel maken, maar dat is veel werk en kost 6k aan geheugen. Daarom wil ik de 8x16 tabel 'uitvergroten'
Dit door iedere pixel gewoon twee keer achtereen hetzelfde uit te voeren.

Stel dat een tabelwaarde 0xF8 is. Dat is %11111000. Ik moet dan iedere pixel verdubbelen. Dat wordt dan %11111111 11000000 (is 0xFF en 0xC0)
(zo krijg ik effectief 16 pixels i.p.v. 8 pixels, hoop dat het duidelijk is...)

Hoe kan ik die berekening van 1 naar 2 bytes het eenvoudigst doen?
(het lijkt simpel, maar ik kom er even niet op, zal de warmte wel zijn... ;) )

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

misschien een hele brute methode
maar het eerste wat mij binnen schiet is
for bit 8 -> 1 : copy, shift, copy, shift

Ik denk dat een tabel van 256x 2 bytes (indexeren met het originele byte) of een tabel van 16x 1 byte waarbij je elk byte apart opzoekt het snelst een simpelst is.

Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken

Ik neem aan dat je werkt in PIC ASM :)

pic asm code:


clrf newbyte_H    ; beginsituatie = alle 16 bits laag
clrf newbyte_L    ;
btfsc oldbyte,7  ; test bit7
bsf newbyte_H,7   ; bit7 is hoog dus maak bit15 hoog
btfsc oldbyte,7
bsf newbyte_H,6   ; bit7 is hoog dus maak bit14 hoog
btfsc oldbyte,6  ; test bit6
bsf newbyte_H,5   ; bit6 is hoog dus maak bit13 hoog
btfsc oldbyte,6
bsf newbyte_H,4   ; bit6 is hoog dus maak bit12 hoog

En zo deze reeks verder afmaken.
Arco

Special Member

Nee, assembly is voor grote projecten niet erg productief helaas... (Mikrobasic)
Ik heb nu ook zoiets wat wel werkt, maar ik heb het gevoel dat het simpeler moet kunnen... :)

pic basic code:


  For BitB = 0 To 7                 
    BitW = BitB << 1
    Word_Out.BitW = Byte_In.BitB
    Inc(BitW)
    Word_Out.BitW = Byte_In.BitB
  Next BitB
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
Arco

Special Member

Geeft mooi groot font op 0.96" oled... :)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Sparky heeft wel een leuke suggestie:

code:


  const unsigned char tbl[16] = { 0x00, 0x03, 0x0c, 0x0f, 
                                  0x30, 0x33, 0x3c, 0x3f,                                                         
                                  0xc0, 0xc3, 0xcc, 0xcf, 
                                  0xf0, 0xf3, 0xfc, 0xff};
  hibyte = tbl[inbyte >> 4];
  lobyte = tbl[inbyte & 0xf];

(door de const KAN ie in progmem als de CPU dat kan (AVR kan dat niet zomaar).)

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Op 7 augustus 2018 21:28:44 schreef Arco:

-knip-

Stel dat een tabelwaarde 0xF8 is. Dat is %11111000. Ik moet dan iedere pixel verdubbelen. Dat wordt dan %11111111 11000000 (is 0xFF en 0xC0)
(zo krijg ik effectief 16 pixels i.p.v. 8 pixels, hoop dat het duidelijk is...)

Hoe kan ik die berekening van 1 naar 2 bytes het eenvoudigst doen?
(het lijkt simpel, maar ik kom er even niet op, zal de warmte wel zijn... ;) )

Meest eenvoudige/snelle methode is denk ik een conversie array waarbij je per byte eenmalig de 2x8 bits versie opslaat. Kost je 512 bytes aan ruimte.

Als je de conversie echt realtime wil doen met een functie denk ik dat dit de snelste methode is: een "and 1 check", die 2x inschuiven in de 16bit versie, en daarna het volgende bit er voor schuiven (8x), en per keer 2x doorschuiven voor 16 bit versie. Zal minder snel zijn maar je pakt wel een paar honderd bytes aan ruimte winst.

En een combinatie van? Per 4 bits kijken, daar de variant byte van opslaan
Kost 2 acties maar qua geheugen ben je dan met 16 bytes klaar

Edit, ook al voorbij gekomen dus,
Zijn niet zoveel wegen die naar Rome leiden deze keer

[Bericht gewijzigd door DK op woensdag 8 augustus 2018 15:30:43 (25%)

Op 8 augustus 2018 00:06:10 schreef Arco:
Geeft mooi groot font op 0.96" oled... :)

[bijlage]

Ziet er netjes uit. Maar je kan de fonts denk ik nog strakker krijgen als je ze niet 1 op 1 opblaast, maar er een soort anti alias filter over heen gooit waardoor de randen wat minder hoekig worden zit ik me net te bedenken. Al heb ik eigenlijk geen idee of dit haalbaar is op een low power cpu systeem qua timing. Iets als het font eerst in een tussen buffer zetten, filter er over, en dan door naar het display .. maar misschien draaf ik wat door en is dit overkill :)