Cemetech | Forum | z80 Assembly [Topic]

Path: Forum / z80 Assembly / Useful Routines

New Post	New Topic
Goto page Previous 1, 2, 3, 4, 5, 6 Next

09 Oct 2011 09:16:38 am by KermMartian		Quote
Indeed you can, but I think it's still more elegant to have as much code cross-compatible as possible. Plus, wouldn't the logical extreme of a single OS version that would work properly on all the calculators be better anyway?

09 Oct 2011 01:29:38 pm by SirCmpwn		Quote
No, one OS version to rule them all is a bad idea. For one, routines need to be as fast as possible (I have plenty of space). If I add model detecting code, then they slow down. Plus, USB code shouldn't be in all versions, and hardware is set up differently on some models. Different versions is the way to go.

10 Oct 2011 08:35:19 am by KermMartian		Quote
Fair enough, for an OS, that makes somewhat sense. For a non-OS program or application, though, I believe we should go with portable, device-detecting code.

06 Nov 2011 10:31:43 am by arriopolis

Menuroutine 2.0 :D

Quote

Hey all!

I finally did what I promised to do months before. Smile

I created a multiple, scrollable, menuroutine.

Menuroutine
INPUT:
Via the code stream, using the following "syntaxis":

Code:

CALL Menu
.DB 2 ;Number of menus
.DB "Tit1", 0 ;Title of menu1
.DB "Tit2", 0 ;Title of menu2
.DB 3 ;Number of options in menu1
.DB 4 ;Number of options in menu2
.DB "Opt1", 0 \ .DW Lbl1 ;Optiontext + Lable to jump to when selected.
.DB "Opt2", 0 \ .DW Lbl2
.DB "Opt3", 0 \ .DW Lbl3
.DB "U", 0 \ .DW LblU
.DB "R", 0 \ .DW LblR
.DB "2", 0 \ .DW LblToo
.DB "Fat", 0 \ .DW LblFat ;Sorry, could not resist.
Lbl1: Code
Lbl2: Code
Lbl3: Code
LblU: Code
LblR: Code
LblToo: Code
LblFat: Code

Output: PC: The desired lable.
Registers destroyed: AF, BC, DE, HL, IX
Size: Huge.
Remarks: Does reset AppAutoScroll and TextInverse.
I'm sure there are numurous optimizations possible, so do not hesitate to inform me. Smile

Code:

Menu:
;- Objective: Create a scrollable menu, with multiple titles possible.
;- INPUT: Data from codestream.
;- Variables:
; - Current menu selected = IXL
; - Current option selected = B
; - Number of menus = IXH
; - Number of options = C
; - Current option at first row = D
RES AppAutoScroll, (IY + AppFlags)
POP HL          ;Gain the baseaddress of the input data.
LD C, 1
LD IXL, C          ;IXL = Current menu selected.
LD C, (HL)
LD IXH, C          ;IXH = Number of menus.
INC HL
LD (MenuTitleAddress), HL
LD B, C
CALL MenuSkipMenus       ;B = Number of menus; becomes 0.
LD (MenuNrOptionsAddress), HL
ADD HL, BC          ;B = 0, C = Number of menus, so BC = number of menus
LD (MenuOptionsAddress), HL
;Now, HL is at the beginning of the optionslist.

MenuDrawMenu:
b_call(_ClrLCDFull)
b_call(_HomeUp)
LD HL, (MenuTitleAddress)
LD C, IXL          ;Now C = Current menu selected.
LD B, IXH          ;Now B = Number of menus.
LD A, " "          ;Now A = A space, to put inbetween the menus.
MenuDrawMenuTitle:
DEC C
CALL NZ, TextInverseOff
CALL Z, TextInverseOn
b_call(_PutS)       ;Draw the title
CALL TextInverseOff
b_call(_PutC)       ;Put a space inbetween
DJNZ MenuDrawMenuTitle    ;Do this "number of menus" times, B is left 0.
;Now to get the number of options etc.
LD HL, (MenuOptionsAddress)
LD C, IXL
DEC C
JR Z, MenuNoSkipMenu
LD DE, (MenuNrOptionsAddress)
MenuSkipMenu:
LD A, (DE)
LD B, A
CALL MenuSkipOptions    ;Makes sure B = 0
INC DE
DEC C
JR NZ, MenuSkipMenu
MenuNoSkipMenu:
LD (Temp), HL
LD C, IXL
DEC C
LD HL, (MenuNrOptionsAddress)
ADD HL, BC          ;B = 0, so BC = C = Number of menus.
LD C, (HL)          ;C = Number of options.
LD B, 1          ;D = Current option at first row
LD D, B          ;B = Current option selected

MenuDrawText:
LD HL, $0001
LD (CurRow), HL
LD HL, (Temp)
PUSH BC
LD B, D          ;Now B = Option at row 1.
DEC B
CALL NZ, MenuSkipOptions    ;If row 1 is not 1, then skip the options before the one at row1.
LD B, 7
LD E, D          ;Start off with the option at row1.
MenuDrawTextOptions:
LD A, E
CP C          ;If there is no more option to write, abort.
JR Z, MenuDrawTextOptionsCont
JR NC, MenuDrawTextNoMore
MenuDrawTextOptionsCont:
LD A, 2
LD (CurCol), A
b_call(_PutS)       ;Wrtite em.
MenuDrawTextOptionsSpaces:
LD A, (CurCol)
OR A
JR Z, MenuDrawTextOptionsSpacesEnd
LD A, " "
b_call(_PutC)
JR MenuDrawTextOptionsSpaces
MenuDrawTextOptionsSpacesEnd:
INC E
INC HL
INC HL
DJNZ MenuDrawTextOptions    ;7 times.
MenuDrawTextNoMore:
POP BC

MenuDrawOptions:
LD HL, $0001
LD (CurRow), HL
PUSH BC          ;Save B and C temporarely, but copy B into E, because we want to use B again soon.
LD E, B
LD A, D          ;Begin with the option at row1.
LD B, 7          ;7 options to write max.
MenuDrawOptionsLoop:
PUSH AF          ;Save AF for further use (A = current option drawn).
PUSH AF
CP E
CALL Z, TextInverseOn
CALL NZ, TextInverseOff
ADD A, $30          ;Add the number of bytes to get to the correct symbols.
CP $3A
JR Z, MenuDrawOptionsZero
JR C, MenuDrawOptionsLoopNumber
ADD A, 6          ;6 to get to the lettersymbols.
JR MenuDrawOptionsLoopNumber
MenuDrawOptionsZero:
LD A, L0
MenuDrawOptionsLoopNumber:
b_call(_PutC)
POP AF
CP D          ;If TopOption = CurOption, then top option is being drawn.
JR NZ, MenuDrawOptionsCont
CP 1          ;If TopOption = CurOption = 1, no uparrow.
JR Z, MenuDrawOptionsCont2
LD A, LUpArrow
JR MenuDrawOptionsLoopCont
MenuDrawOptionsCont:
CP C          ;If CurOption = Number of options
JR Z, MenuDrawOptionsCont2
LD A, (CurRow)
CP 7
JR NZ, MenuDrawOptionsCont2
LD A, LDownArrow
JR MenuDrawOptionsLoopCont
MenuDrawOptionsCont2
LD A, ":"
MenuDrawOptionsLoopCont:
b_call(_PutC)
b_call(_NewLine)
POP AF
INC A
CP C
JR Z, MenuDrawOptionsLoopEnd
JR NC, MenuDrawOptionsEnd
MenuDrawOptionsLoopEnd:
DJNZ MenuDrawOptionsLoop
MenuDrawOptionsEnd:
POP BC
CALL TextInverseOff

MenuUserInput:
LD E, C
PUSH DE
b_call(_getKey)
POP DE
LD C, E
CP kDown
JR Z, MenuDown
CP kUp
JR Z, MenuUp
CP kLeft
JR Z, MenuLeft
CP kRight
JP Z, MenuRight
CP kEnter
JR Z, MenuEnter
CP kVarx
JR NC, MenuUserInput
SUB k0
JR C, MenuUserInput
JR NZ, MenuUserInputNotZero
LD A, 10
JR MenuUserInputNumber
MenuUserInputNotZero:
CP 10
JR C, MenuUserInputNumber
DEC A
MenuUserInputNumber:
CP C
JR Z, MenuUserInputNumberCont
JR NC, MenuUserInput
MenuUserInputNumberCont
LD B, A

MenuEnter:
LD HL, (MenuOptionsAddress)
PUSH BC
LD B, IXL
DEC B
JR Z, MenuEnterSkipSkipLoop
LD DE, (MenuNrOptionsAddress)
LD C, 0
MenuEnterSkipLoop:
LD A, (DE)
ADD A, C
LD C, A
INC DE
DJNZ MenuEnterSkipLoop
LD B, C
CALL MenuSkipOptions
MenuEnterSkipSkipLoop:
POP BC
CALL MenuSkipOptions
DEC HL
LD A, (HL)
LD D, A
DEC HL
LD A, (HL)
LD E, A
EX DE, HL
JP (HL)             ;Exit routine.

MenuDown:
LD A, B
CP C
JR Z, MenuDownWrap
INC B
LD A, B
SUB D
CP 7
JP NZ, MenuDrawOptions
INC D
JP MenuDrawText
MenuDownWrap:
LD B, 1
LD D, B
JP MenuDrawText

MenuUp:
LD A, B
DEC A
JR Z, MenuUpWrap
LD A, B
CP D
PUSH AF
DEC B
POP AF
JP NZ, MenuDrawOptions
DEC D
JP MenuDrawText
MenuUpWrap:
LD B, C
LD A, C
SUB 6
LD D, A
JP NC, MenuDrawText
LD D, 1
JP MenuDrawText

MenuLeft:
LD D, 1
LD B, 0
DEC IXL
JR NZ, MenuLeftCont
LD IXL, IXH
MenuLeftCont:
LD C, IXL
DEC C
LD HL, (MenuNrOptionsAddress)
ADD HL, BC
LD C, (HL)
INC B
JP MenuDrawMenu

MenuRight:
LD D, 1
LD B, 0
LD A, IXL
CP IXH
JR NZ, MenuRightCont
LD IXL, 0
MenuRightCont:
INC IXL
LD C, IXL
DEC C
LD HL, (MenuNrOptionsAddress)
ADD HL, BC
LD C, (HL)
INC B
JP MenuDrawMenu

TextInverseOn:
SET TextInverse, (IY + TextFlags)
RET
TextInverseOff:
RES TextInverse, (IY + TextFlags)
RET

MenuSkipOptions:
LD A, (HL)
INC HL
OR A
JR NZ, MenuSkipOptions
INC HL
INC HL             ;Skip labelbytes.
DJNZ MenuSkipOptions
RET

MenuSkipMenus:
LD A, (HL)
INC HL
OR A
JR NZ, MenuSkipMenus
DJNZ MenuSkipMenus
RET

MenuTitleAddress: .DW 0
MenuNrOptionsAddress: .DW 0
MenuOptionsAddress: .DW 0
Temp: .DW 0

06 Nov 2011 12:10:36 pm by arriopolis

Inputroutine 1.0 :D

Quote

Hi all!

I found some time to write a far from perfect inputroutine. There is plenty of room for optimization, in both speed and size, but I'm just too lazy to fix it.

Inputroutine:
Input:
- DE = Start of address for the string to be stored to.
- C = The maximum number of characters.
Output: String at initial DE.
Remarks: This inputroutine works with letters instead of tokens, so multiletter symbols like sin( aren't included.
Registers destroyed: AF, BC, DE, HL, IX, I.
Setup:
Since this routine uses its own Interrupt Service Routine, you need to include that one too. I've placed it at $9D9D, meaning you've gotta place it near the beginning of the program. I usually do something lik this:

Code:

<Usual crap>
.DB t2ByteTok, tAsmCmp
b_call(_ClrLCDFull)
b_call(_HomeUp)
JR Start
<InputISR goes here>
Start:

This makes sure the InputISR is in its correct location. Here is the InputISR:

Code:

InputISR: ;$9D9D
EX AF, AF'
EXX
XOR A
OUT (3), A
LD HL, CurTime
INC (HL)
LD A, $32
CP (HL)
JR NZ, InputNoblink
LD (HL), 0
LD A, (IY + CurFlags)
XOR %00001000
LD (IY + CurFlags), A
InputNoblink:
LD A, %00001010
OUT (3), A
EXX
EX AF, AF'
EI
RET

And finally the Inputroutine itself:

Code:

Input:
;INPUTROUTINE: Asks user to enter characters.
;INPUT:
;- IX = Address of string    (Constant)
;- C = Maximum amount of characters (Constant)
;VARIABLES:
;- Cursorplace: (CurRow)&(CurCol)
;- Length of string: B
;- Current character: E
;- 2nd & Alpha: Shiftflags
;- Cursorblink: (CurTime)
;OUTPUT:
;- String at InputData (DE = Crap at the end)
;- Carry if error
;PSEUDOCODE:
;- Wait for keypress
; - If Clear: Delete all
; - If Del: Delete current charachter
; - If Left: Move cursor left if possible
; - If Right: Move cursor right if possible
; - If Up: Move cursor up if possible
; - If Down: Move cursor down if possible
; - If Enter: Exit without error
;- Convert to charachter
;- Check insertflag
; - If Insert, insert the character
; - If not, overwrite the character
;- Return to begin
;OTHER DATA:
;- Keyport (1):
; +-------------------------------------------------------------------------------------------------------------------------------+
; ¦ Read: ¦
; +-------------------------------------------------------------------------------------------------------------------------------¦
; ¦$FE = %11111110¦$FD = %11111101¦$FB = %11111011¦$F7 = %11110111¦$EF = %11101111¦$DF = %11011111¦$BF = %10111111¦$7F = %01111111¦
;+-----------------+---------------+---------------+---------------+---------------+---------------+---------------+---------------+---------------¦
;¦ ¦$BF = %10111111¦ [GRAPH] ¦ [TRACE] ¦ [ZOOM] ¦ [WINDOW] ¦ [Y=] ¦ [2nd] ¦ [MODE] ¦ [DEL] ¦
;¦W¦$DF = %11011111¦ ¦ [STO] ¦ [LN] ¦ [LOG] ¦ [X²] ¦ [X-1] ¦ [MATH] ¦ [ALPHA] ¦
;¦R¦$EF = %11101111¦ [0] ¦ [1] ¦ [4] ¦ [7] ¦ [,] ¦ [SIN] ¦ [APPS] ¦ [X,T,Q,n] ¦
;¦I¦$F7 = %11110111¦ [.] ¦ [2] ¦ [5] ¦ [8] ¦ [)] ¦ [COS] ¦ [PRGM] ¦ [STAT] ¦
;¦T¦$FB = %11111011¦ [(-)] ¦ [3] ¦ [6] ¦ [9] ¦ [(] ¦ [TAN] ¦ [VARS] ¦ ¦
;¦E¦$FD = %11111101¦ [ENTER] ¦ [+] ¦ [-] ¦ [X] ¦ [/] ¦ [^] ¦ [CLEAR] ¦ ¦
;¦ ¦$FE = %11111110¦ [DOWN] ¦ [LEFT] ¦ [RIGHT] ¦ [UP] ¦ ¦ ¦ ¦ ¦
;+-------------------------------------------------------------------------------------------------------------------------------------------------+
LD B, 0                         ;String has 0 characters at first
LD E, 0                         ;We have character 0 selected at first
PUSH BC                         ;Save settings
PUSH IX
PUSH DE
RES Shift2nd, (IY + ShiftFlags)
RES ShiftAlpha, (IY + ShiftFlags)
RES ShiftLwrAlph, (IY + ShiftFlags)
RES ShiftALock, (IY + ShiftFlags)
RES TextInsMode, (IY + TextFlags)

SET CurOn, (IY + CurFlags)    ;Set up interrupt
DI
LD A, 0
LD (CurTime), A
LD A, $99          ;AppBackupScreen is at $9872
LD I, A
LD HL, $9900       ;Load Vector Table, $9900 - $99FF
LD (HL), $9D
LD D, H
LD E, 1
LD BC, 256
LDIR
LD A, %00001010
OUT (3), A
IM 2
EI             ;Enable the interrupts again

InputKey:
BIT CurOn, (IY + CurFlags)
JR Z, InputNoCursor
BIT Shift2nd, (IY + ShiftFlags)
JR Z, InputNot2nd
BIT TextInsMode, (IY + TextFlags)
JR NZ, Input2ndIns
LD A, $E1          ;$E1 = Shiftcursor
JR InputCursorDisp
Input2ndIns:
LD A, $E5
JR InputCursorDisp
InputNot2nd:
BIT ShiftAlpha, (IY + ShiftFlags)
JR Z, InputNotAlpha
BIT TextInsMode, (IY + TextFlags)
JR NZ, InputAlphaIns
LD A, $E2          ;$E2 = Alphacursor
JR InputCursorDisp
InputAlphaIns:
LD A, $E6
JR InputCursorDisp
InputNotAlpha:
BIT ShiftLwrAlph, (IY + ShiftFlags)
JR Z, InputNotLwrAlph
BIT TextInsMode, (IY + TextFlags)
JR NZ, InputLwrAlphIns
LD A, $E3          ;$E3 = LwrAlphcursor
JR InputCursorDisp
InputLwrAlphIns:
LD A, $E7
JR InputCursorDisp
InputNotLwrAlph:
BIT TextInsMode, (IY + TextFlags)
JR NZ, InputNormIns
LD A, $E0          ;$E0 = Cursor
JR InputCursorDisp
InputNormIns:
LD A, $E4
JR InputCursorDisp
InputNoCursor:
POP DE
POP IX
LD A, (IX)
PUSH IX
PUSH DE
OR A
JR NZ, InputCursorDisp
LD A, " "
InputCursorDisp:
b_call(_PutMap)       ;Disables interrupts
EI

LD C, 1          ;b_call(_GetCSC) doesn't work, so let's make our own
LD HL, KeyGroups
InputCheckKeyGroup:
LD A, (HL)
OUT (C), A
LD B, 8          ;7 Cycles, enough to let the keyport respond
IN A, (C)
InputCheckKey:
RLCA          ;Load the reset bit into carry
JR NC, InputKeyRead
DJNZ InputCheckKey
INC HL
LD A, (HL)
OR A
JR NZ, InputCheckKeyGroup
JR InputCont

InputKeyRead:
LD DE, KeyGroups       ;Let's find the key selected
XOR A          ;Resets Carry flag
SBC HL, DE          ;Find keygroup
LD A, L          ;HL is not higher than 256, so load it into A
SLA A          ;A * 8 --> A...
SLA A          ;...because there are 8 keys per group
SLA A
ADD A, B          ;Add B to A, to distinguish the key selected inside the group

;NOTE: A = the same as the scancodeequates now.

POP DE
CP D
PUSH DE
JP Z, InputKey       ;If the key pressed is the same, restart

InputCont:
POP DE          ;Save last key into D
LD D, A
PUSH DE
JP Z, InputKey       ;If no key was pressed, restart

;--------------------Actual checking of keys--------------------
CP skEnter
JP Z, InputEnd
CP sk2nd
JP Z, Input2ndPressed
CP skLeft
JP Z, InputLeft
CP skRight
JP Z, InputRight
CP skUp
JP Z, InputUp
CP skDown
JP Z, InputDown
CP skClear
JP Z, InputClear
BIT Shift2nd, (IY + ShiftFlags)
JR NZ, Input2nd
CP skDel
JP Z, InputDel
BIT ShiftAlpha, (IY + ShiftFlags)
JR NZ, InputAlpha
BIT ShiftLwrAlph, (IY + ShiftFlags)
JR NZ, InputLwrAlph
CP skAlpha
JP Z, InputAlphaPressed
LD HL, NormalLUT
JR InputCharCheck

Input2nd:
CP skAlpha
JP Z, Input2ndAlphaPressed
CP skDel
JP Z, InputIns
LD HL, 2ndLUT
JR InputCharCheck

InputAlpha:
CP skAlpha
JP Z, InputAlphaAlphaPressed
LD HL, AlphaLUT
JR InputCharCheck

InputLwrAlph:
CP skAlpha
JP Z, InputLwrAlphAlphaPressed
LD HL, LwrAlphLUT

InputCharCheck:
SUB 10          ;Cut down size for the LUT
JP C, InputKey
CP 38
JP NC, InputKey
LD C, A          ;Load the address for the LUT
LD B, 0
ADD HL, BC
LD A, (HL)          ;Load character in A
OR A          ;If character is not valid...
JP Z, InputKey       ;Abort
POP DE
POP IX
POP BC
PUSH AF
LD A, E
CP C          ;If the maximum characters is reached...
JR Z, InputCharAbort    ;...Abort
CP B          ;If we are dealing with the last character...
JR Z, InputCharCont2
BIT TextInsMode, (IY + TextFlags)
JR Z, InputCharCont
InputCharIns:
PUSH BC
PUSH IX
PUSH DE
LD A, B
SUB E
LD C, A
LD B, 0
ADD IX, BC
PUSH IX
POP DE
DEC IX
PUSH IX
POP HL
LDDR
POP DE
POP IX
POP BC
LD HL, (CurRow)
PUSH HL
PUSH BC
PUSH DE
LD A, " "
b_call(_PutC)
PUSH IX
POP HL
INC HL
b_call(_PutS)
POP DE
POP BC
POP HL
LD (CurRow), HL
InputCharCont2:
INC B          ;...incline the length of the string
InputCharCont:
INC E          ;Incline the letterpointer
POP AF
LD (IX), A          ;Load character into string data
INC IX          ;Go to next character in string data
b_call(_PutC)       ;Display the character
InputResetFlags:
CALL InputResetCursor
RES Shift2nd, (IY + ShiftFlags)
BIT ShiftALock, (IY + ShiftFlags)
JR NZ, InputCharEnd
RES ShiftAlpha, (IY + ShiftFlags)
RES ShiftLwrAlph, (IY + ShiftFlags)
InputCharEnd:
PUSH BC
PUSH IX
PUSH DE
JP InputKey
InputCharAbort:
POP AF
JR InputCharEnd

Input2ndPressed:
LD A, (IY + ShiftFlags)
XOR 1 << Shift2nd
LD (IY + ShiftFlags), A
JR InputEndFlag

InputAlphaPressed:
SET ShiftAlpha, (IY + ShiftFlags)
JR InputEndFlag

Input2ndAlphaPressed:
LD A, (IY + ShiftFlags)
XOR 1 << ShiftAlock
LD (IY + ShiftFlags), A
RES Shift2nd, (IY + ShiftFlags)
BIT ShiftLwrAlph, (IY + ShiftFlags)
JR NZ, InputEndFlag
SET ShiftAlpha, (IY + ShiftFlags)
JR InputEndFlag

InputAlphaAlphaPressed:
RES ShiftAlpha, (IY + ShiftFlags)
SET ShiftLwrAlph, (IY + ShiftFlags)
JR InputEndFlag

InputLwrAlphAlphaPressed:
RES ShiftLwrAlph, (IY + ShiftFlags)
RES ShiftALock, (IY + ShiftFlags)

InputEndFlag:
CALL InputResetCursor
JP InputKey

InputDel:
RES TextInsMode, (IY + TextFlags)
POP DE
POP IX
POP BC
LD A, E
CP B
JR Z, InputCharEnd
LD HL, (CurRow)
PUSH HL
PUSH DE
PUSH BC
PUSH IX
PUSH IX
POP HL
POP DE
INC HL
InputDelMoveLoop:
LD A, (HL)
OR A
LDI
JR Z, InputDelMoveLoopEnd
b_call(_PutC)
JR InputDelMoveLoop
InputDelMoveLoopEnd:
LD A, " "
b_call(_PutMap)
EI
POP BC
POP DE
POP HL
LD (CurRow), HL
DEC B
CALL InputResetCursor
JR InputCharEnd

InputIns:
LD A, (IY + TextFlags)
XOR 1 << TextInsMode
LD (IY + TextFlags), A
CALL InputResetCursor
RES Shift2nd, (IY + ShiftFlags)
JP InputKey

InputClear:
POP DE
POP IX
POP BC
LD A, B
OR A
JP Z, InputClearEnd
SUB E
PUSH BC
LD C, A
LD B, 0
ADD IX, BC
LD HL, CurCol
LD B, (HL)
ADD A, B
LD B, 0
InputClearCheckWrap:
CP 16
JR C, InputClearWrapEnd
SUB 16
INC B
JR InputClearCheckWrap
InputClearWrapEnd:
LD (HL), A
DEC HL
LD A, (HL)
ADD A, B
LD (HL), A
POP BC
INC HL
InputClearLoop:
LD (IX), 0
DEC IX
LD A, " "
b_call(_PutMap)
LD A, (HL)
OR A
JR Z, InputClearLoopWrap
DEC (HL)
JR InputClearLoopEnd
InputClearLoopWrap:
LD (HL), 15
DEC HL
DEC (HL)
INC HL
InputClearLoopEnd:
DJNZ InputClearLoop
LD (IX), 0
LD E, 0
InputClearEnd:
RES TextInsMode, (IY + TextFlags)
JP InputResetFlags

InputLeft:
CALL InputResetCursor
POP DE
POP IX
LD A, (IX)
OR A
JR NZ, InputLeftNotZero
LD A, " "
InputLeftNotZero:
b_call(_PutMap)
EI
LD A, E
OR A
JR Z, InputLeftEnd
DEC E
DEC IX
LD HL, CurCol
LD A, (HL)
DEC (HL)
OR A
JR NZ, InputLeftEnd
LD (HL), 15
DEC HL
DEC (HL)
InputLeftEnd:
PUSH IX
PUSH DE
RES TextInsMode, (IY + TextFlags)
JP InputKey

InputRight:
CALL InputResetCursor
POP DE
POP IX
POP BC
LD A, (IX)
OR A
JR NZ, InputRightNotZero
LD A, " "
InputRightNotZero:
b_call(_PutMap)
EI
LD A, E
CP B
JR Z, InputRightEnd
INC E
INC IX
LD HL, CurCol
LD A, (HL)
INC (HL)
SUB 15
JR NZ, InputRightEnd
LD (HL), 0
DEC HL
INC (HL)
InputRightEnd:
PUSH BC
PUSH IX
PUSH DE
RES TextInsMode, (IY + TextFlags)
JP InputKey

InputUp:
CALL InputResetCursor
POP DE
POP IX
POP BC
LD A, (IX)
OR A
JR NZ, InputUpNotZero
LD A, " "
InputUpNotZero:
b_call(_PutMap)
EI
LD A, E
SRL A          ;Divide by 16, to see if there is a row to go up
SRL A
SRL A
SRL A
JP Z, InputCharEnd       ;Cancel if on the top row
LD A, E
SUB 16
LD E, A
PUSH DE
LD HL, CurRow
DEC (HL)
LD DE, 16
OR A
PUSH IX
POP HL
SBC HL, DE
PUSH HL
POP IX
POP DE
RES TextInsMode, (IY + TextFlags)
JP InputCharEnd

InputDown:
CALL InputResetCursor
POP DE
POP IX
POP BC
LD A, (IX)          ;Erase the cursor
OR A
JR NZ, InputDownNotZero
LD A, " "
InputDownNotZero:
b_call(_PutMap)
EI
LD A, E          ;Check if there is any row below the one you're on now
SRL A          ;Devide E by 16 to see the current row and store it to H
SRL A
SRL A
SRL A
LD H, A
LD A, B          ;Devide B by 16 to see the maximum amount of rows
SRL A
SRL A
SRL A
SRL A
SUB H
JP Z, InputCharEnd       ;If they are the same, quit
LD HL, CurRow
INC (HL)
DEC A
JR NZ, InputDownNoShift    ;If you are not on the last row, it'll never have to shift <<
LD A, B          ;Check if the cursor should go << aswell
AND $0F          ;Get the colomn of the final character
LD HL, CurCol       ;Get the colomn of the cursor
SUB (HL)          ;If ColFin - ColCur < 0, no <<
JR NC, InputDownNoShift
NEG
PUSH BC
LD C, A
LD B, 0
PUSH IX
POP HL
OR A
SBC HL, BC
PUSH HL
POP IX
LD A, (CurCol)
SUB C
LD (CurCol), A
LD BC, 16
ADD IX, BC
POP BC
LD A, B
LD E, A
JP InputCharEnd
InputDownNoShift:
PUSH DE
LD DE, 16
ADD IX, DE
POP DE
LD A, E
ADD A, 16
LD E, A
JP InputCharEnd

InputEnd:
POP DE
POP IX
POP BC
DI
LD A, %00010011
OUT (3), A
IM 1
EI
RET

InputResetCursor:
XOR A
LD (CurTime), A
SET CurOn, (IY + CurFlags)
RET

NormalLUT: .DB "+-*/^", 0, 0, Lneg, "369)", 0, 0, 0, ".258(", 0, 0, 0, "0147,", 0, 0, "X", 0, Lstore, 0, 0, Lsquare, LInverse, 0
2ndLUT: .DB 0, "][", Llne, Lpi, 0, 0, 0, 0, 0, "w}", 0, 0, 0, LimagI, 0, 0, "v{", 0, 0, 0, 0, 0, 0, "u", Lexponent, 0, 0, "X", 0, 0, 0, 0, 0, 0, 0
AlphaLUT: .DB LQuote, "WRMH", 0, 0, "?", LTheta, "VQLG", 0, 0, ":ZUPKFC", 0, " YTOJEBX", 0, "XSNIDA"
LwrAlphLUT: .DB LQuote, "wrmh", 0, 0, "?", LTheta, "vqlg", 0, 0, ":zupkfc", 0, " ytojebx", 0, "xsnida"

Keygroups: .DB $FE, $FD, $FB, $F7, $EF, $DF, $BF, 0

07 Nov 2011 12:22:48 pm by KermMartian		Quote
Out of curiosity, that looks like well over 1KB of code. Any reason not to use either the DCS GUI or MOS input functions, both provided from Doors CS, instead?

07 Nov 2011 03:55:47 pm by arriopolis		Quote
Yep, I'm wanting to create an app, using these routines, and DCS doesn't provide an apprunning feature, so I've gotta write them myself. Btw, does DCS include the multimenuroutine?

07 Nov 2011 11:25:54 pm by KermMartian

Quote

arriopolis wrote:

Yep, I'm wanting to create an app, using these routines, and DCS doesn't provide an apprunning feature, so I've gotta write them myself.
Btw, does DCS include the multimenuroutine?

Doors CS includes tools for simple, fast menus for ASM and BASIC programs, but as you say, it is much harder to use its features from an app/.

04 Jan 2012 03:42:16 pm by Xeda112358

Quote

KermMartian wrote:

That's some of the ugliest code I've ever seen. You need to seriously learn bitmath already. I also made the device type checking dynamic so you don't need to compile a different version for the TI-83+.

GetBatteryLevel
Gets an accurate battery level on non-TI-83+ devices.
Inputs:
None
Outputs:
B: Battery level (0-4)
Destroys:
None

Code:

; Outputs: B: Value from 0-4 indicating battery level (0 is critical)
GetBatteryLevel:
push af
in a, (2)
rlca ;Roll bit 7 into carry.
jr c, GetBatteryLevel_Not3Plus
in a, (2)
and 1
ld b, a
pop af
ret
GetBatteryLevel_Not3Plus:
ld b,3
GetBatteryLevelLoop:
ld a,b
sla a
sla a
sla a
sla a
sla a
sla a
or %00000110
out (6), a
in a, (2)
bit 0, a
jr z, GetBatteryLevel_Done
djnz GetBatteryLevelLoop
ld b,4
GetBatteryLevel_Done:
ld a, %110
out (6), a
pop af
ret

Kerm is there any reason for the sla as? I know it takes twice as many bytes and cycles as add a,a, so is it a timing thing? Otherwise, why not replace those 12 bytes and 48 cycles with 4 bytes and 15 cycles?

Code:

rrca
rrca
and $C0

And if you need the timing, you can use 8 bytes instead of 12 if you add this, too:

Code:

push hl
inc hl
dec hl
pop hl

I was going to post about the A_Times_DE routine that I wrote that averages 313 cycles, but I am still trying to optimise. Does anybody have a faster routine that doesn't use a LUT? Worst case is 355, best case is 166.

04 Jan 2012 07:54:54 pm by arriopolis		Quote
I gave it a try. My minimum is 382, and my maximum is 510. I'm pretty curious what your code is like actually.

04 Jan 2012 09:38:32 pm by Xeda112358

Quote

Okay, then I may as well post it and hope others can optimise Smile

Code:

A_Times_DE:
;Input:
; A,DE
;Outputs:
; A is 0
; BC is not changed
; DE is not changed
; HL is the result
; z flag is set
; c flag is set if the input A is not 0
;Notes:
; If A is 0, 29 cycles
;Speed: 145+6n+21b cycles
; n=floor(log(a)/log(2))
; b is the number of bits in the number
; Testing over all values of A from 1 to 255:
; 313.7058824 average cycles
; Worst: 355
; Best : 166 (non trivial)
;Size: 25 bytes
ld hl,0 ;10
or a \ ret z ;9
cpl \ scf ;8
adc a,a ;4
jp nc,$+7 ;10 ;45
Loop:
add a,a ;4
jp c,$-1 ;10 ;14(7-n)

add hl,de ;11 ;11 (the rest are counted below)
add a,a ;4 ;4b
ret z ;5|11 ;5b+6
add hl,hl ;11 ;11b-11
jp p,$-4 ;21|20 ;20n+b
jp $-7

I compared it to the following routine that I thought was pretty well optimised:

Code:

DE_Times_A:
;Inputs:
; DE and A are factors
;Outputs:
; A is not changed
; B is 0
; C is not changed
; DE is not changed
; HL is the product
;Time:
; 342+6x
;
ld b,8 ;7 7
ld hl,0 ;10 10
add hl,hl ;11*8 88
rlca ;4*8 32
jr nc,$+3 ;(12|18)*8 96+6x
add hl,de ;-- --
djnz $-5 ;13*7+8 99
ret ;10 10

Notice that the first does not use a traditional counter at all and so it only modifies A and spits out the result in HL.

EDIT: The second one works anywhere from 342 to 390 cycles

05 Jan 2012 06:08:31 am by arriopolis

Quote

Ah, mine is only 15 bytes... I prefer size over speed actually, so I think I'd stick with the one which takes up the least amount of memory.

Code:

A_Times_DE:    ;Cycles ;Bytes
LD HL, 0    ;10 ;3
LD B, 8       ;7 ;2
A_Times_DE_Loop:
RRA       ;4 ;1
JR NC, NoMult    ;12/7 ;2
ADD HL, DE    ;11 ;1
NoMult:
SLA E       ;8 ;1
RL D       ;8 ;1
DJNZ A_Times_DE_Loop ;13/8 ;3
RET          ;10 ;1

05 Jan 2012 11:01:38 am by Xeda112358		Quote
! You should use the second routine I provided, then, which is 13 bytes Your code is actually 16 bytes, too. The errors are: SLA E uses 2 bytes RL D uses 2 bytes DJNZ uses 2 bytes The timing on yours is 382+6x cycles, too, so the second routine I gave is 40 cycles faster. Nice coding, though!

05 Jan 2012 11:52:56 am by arriopolis		Quote
Well, yours is even nicer. But thanks anyway.

20 Feb 2012 09:53:09 pm by Ashbad

Quote

quite fast, but large 8 bit signed or unsigned itoa implementation Smile

Edit: the reason it's so large is because I inline a semi-generic division routine in there twice, and for multiplication by 10 and 100 I use an unrolled series of additions, and instead of looping three times using the dividends 100, 10, and 1, I unrolled it to 3 inline operations. The only real extra optimization to be had for speed is unrolling division to shave off maybe 150-200 cycles, but that's just overkill I would think. Optimizing it for size is rather easy, but usually I prefer speed over size so that's what I aimed for here.

Code:

; convert from reg8 to string
; input: a - reg8, b - 1 if signed, 0 if unsigned, hl - place to output to
; output: original place to output to

ITOA_8:
push hl
pop ix
push hl
push af
xor a
cp b
jr z, {@}
pop af
ld d, 127
cp d
jr c, {2@}
ld d, '-'
pop hl
ld (hl), d
inc hl
push hl
neg
jr {2@}
@
pop af
@
ld l, a
ld h, 0
ld d, 100
push af
xor a
ld b, 16
@
add hl,hl
rla
cp d
jp c, {@}
sub d
inc l
@
djnz {-2@}
ld a, l
add a, a
add a, a
add a, a
ld h, a
add a, a
add a, h
add a, l
add a, a
add a, a
ld d, a
pop af
sub d
ld d, a
ld a, l
cp 0
jr z, {@}
pop hl
add a, '0'
ld (hl), a
inc hl
push hl
@
ld a, d

ld l, a
ld h, 0
ld d, 10
push af
xor a
ld b, 16
@
add hl,hl
rla
cp d
jp c, {@}
sub d
inc l
@
djnz {-2@}
ld a, l
add a, a
add a, a
add a, l
add a, a
ld d, a
pop af
sub d
ld d, a
ld a, l
cp 0
jr z, {@}
pop hl
add a, '0'
ld (hl), a
inc hl
push hl
@
ld a, d

add a, '0'
pop hl
ld (hl), a
xor a
inc hl
ld (hl), a
push ix
pop hl
ret

21 Feb 2012 02:28:27 pm by Xeda112358

Quote

That is for converting an 8-bit number to text, yes? Nice Smile

I recently had to update Grammer to support 32-bit number displaying, so I wrote some code for that. It is Grammer specific, but in this case, (TempWord1) is 2 bytes pointing to the end of where the string is to be displayed. It creates a zero-terminated string of the number:

Code:

DispNumBase32:
;Inputs:
; C is the base
; DEHL is the number to display
;Outputs:
; A, B, D, E is 0
; C is not changed
; HL points to the string
ld b,32
xor a
add hl,hl
rl e \ rl d
rla
cp c
jr c,$+4
inc l
sub c
djnz $-11
push bc
push de
push hl
add a,30h
cp 3Ah
jr c,$+4
add a,7
ld hl,(TempWord1)
dec hl
ld (TempWord1),hl
ld (hl),a
pop hl
pop de
pop bc
ld a,h
or l \ or d \ or e
jr nz,DispNumBase32
ld hl,(TempWord1)
ret

I am pretty sure that can be optimised a little with some DAA magic :/ I also have a pretty fast routine to convert a number string in base 10 to a 16-bit value in BC:

Code:

;===============================================================
ConvRStr:
;===============================================================
;Input:
; DE points to the byte before the first digit
;Outputs:
; A is the 8-bit value of the number
; BC is the 16-bit value of the number
; DE points to the byte after the number
; HL is the 16-bit value of the number
;Size: 23 bytes
;Speed: 117d+43[+12 if ending byte is >39h]
; d is the number of digits in the number
; max is 640 cycles for a 5 digit number
;===============================================================
ld hl,0 ;10
ConvLoop:
ld b,h \ ld c,l ;8
ld a,(de) ;7
sub 30h \ ret c ;12 (18 if it ends)
cp 10 \ ret nc ;12 (18 if it ends)
inc de ;6
add hl,hl ;11
add hl,hl ;11
add hl,bc ;11
add hl,hl ;11
ld b,0 ;7
add hl,bc ;11
jp ConvLoop ;10 2 cycles faster then jr, 1 byte larger

That will convert a number up to the first non base 10 digit (I use a variation of this in Grammer as well).

16 Mar 2012 02:16:45 pm by Xeda112358

Quote

Okay, I forgot to post this here as well, but these are two routines that I made a looong time ago and I use this in almost all of my programs that have graphics commands. These two are my first real use of RRD and RLD and that is why those are two of my favorite instructions in z80:

Code:

ShiftScreenRight4:
;Shifts the graph screen right 4 pixels
ld hl,plotSScreen
ld c,64
xor a
ld b,12
rrd
inc hl
djnz $-3
dec c
jr nz,$-9
ret
ShiftScreenLeft4:
;Shifts the graph screen left 4 pixels
ld hl,plotSScreen+767
ld c,64
xor a
ld b,12
rld
dec hl
djnz $-3
dec c
jr nz,$-9
ret

Why do I think these are so awesome? Compare those to routines that shift the graph buffer right or left 1 and you will see:
-They are the same size
-This routine is 7680 cycles slower

That last one might seem bad, but the fastest routine I have seen for shifting right or left is 22166 cycles. Now do that 4 times for 88664 cycles or do 29846 cycles once. That is about 3 times faster.

02 May 2012 07:19:48 pm by Xeda112358

Quote

I'm not sure if I posted this here, yet, or not, but I couldn't find it in a quick search. Anyways, this is similar to the routine Grammer uses to convert an ASCII string of decimal numbers to a 16-bit value. I hope the speed is suitable Smile

Code:

;===============================================================
ConvRStr:
;===============================================================
;Input:
; DE points to the base 10 number string in RAM.
;Outputs:
; HL is the 16-bit value of the number
; DE points to the byte after the number
; BC is HL/10
;Destroys:
; A (actually, add 30h and you get the ending token)
;Size: 24 bytes
;Speed: 109n+35+12a+11c
; n is the number of digits
; a is one if the ending byte is >39h, else 0
; c is at most n-2
; at most 625 cycles for any 16-bit decimal value
;===============================================================
ld hl,0 ; 10 : 210000
ConvLoop: ;
ld a,(de) ; 7 : 1A
sub 30h ; 7 : D630
ret c ;5|11 : D8
cp 10 ; 7 : FE0A
ret nc ;5|11 : D0
inc de ; 6 : 13
;
ld b,h ; 4 : 44
ld c,l ; 4 : 4D
add hl,hl ; 11 : 29
add hl,hl ; 11 : 29
add hl,bc ; 11 : 09
add hl,hl ; 11 : 29
;
add a,l ; 4 : 85
ld l,a ; 4 : 6F
jr nc,ConvLoop ;12|23: 30EE
inc h ; --- : 24
jr ConvLoop ; --- : 18EB

The ones with t-states as '---' are computed along with the previous instruction to make calculations easier. Anyways, to give an idea, at the slowest, this can execute 9345 times per second (assuming you are using call which takes another 17 t-states). This stops reading when a character that is not a decimal number is run into (for example, a comma or newline).

07 Jun 2012 05:00:52 am by Xeda112358

Quote

This is a line drawing routine with full clipping and it allows for drawing with patterns. This isn't the most optimised code (the RAM routine is better, but this version is meant for apps).

Code:

;=====================================
DrawLine:
; H is X1
; L is Y1
; D is width
; E is height
; A is the method
; 0 = Pxl-Off
; 1 = Pxl-On
; 2 = PxlInvert
; 3 =
; +4 = Draw with Merth pattern
; +8 = Draw with Ray pattern
; IX points to the draw pattern
; *Patterns are read backwards. This can be easily adjusted.
; *Patterns are terminated by a -1
; *Patterns are the number of pixels to draw, followed by the number of pixels to ignore for the Merth Pattern
; For the Ray pattern, it is the number of rows to draw followed by the number to ignore.
;=====================================
di
res 5,(iy+33)
res 6,(iy+33)
bit 2,a
jr z,$+6
set 5,(iy+33)
bit 3,a
jr z,$+6
set 6,(iy+33)
and $F3 ;3^5=243=$F3
.db 01h \ cpl \ and (hl)
dec a
jr nz,$+5
.db 01h \ or (hl) \ nop
dec a
jr nz,$+5
.db 01h \ xor (hl) \ nop
ld (PlotLinePix+1),bc
ld a,-1
ld (PatternIncVar2),a
res 7,(iy+33)
ld a,(ix)
bit 6,(iy+33)
jr nz,$+3
inc a
ld (PatternIncVar),a
or a
call z,PatternNext

ld c,0
ld a,d
bit 7,a
jr z,$+7
neg
set 6,c
ld d,a
ld a,e
bit 7,a
jr z,$+7
neg
set 7,c
ld e,a
ld b,a
ex af,af'
ld a,c
exx
rla
ld de,12
ld bc,1
jr nc,$+5
ld de,-12
rla
jr nc,$+4
dec bc \ dec bc
exx
ld a,h
push hl
push bc
ld h,0
ld b,h
ld c,l
add hl,hl
add hl,bc
add hl,hl
add hl,hl
ld c,a
sra c
sra c
sra c
jp p,$+4
dec b
add hl,bc
ld bc,(DrawBufPtr)
add hl,bc
and 7
ld b,a
ld a,80h
jr z,$+5
rrca
djnz $-1
push hl
exx
pop hl
exx
ex af,af'
pop bc
pop hl

sla e
jr nz,$+12
ld b,d
call DrawLinePixel
call ChangeX
djnz $-6
ret
sla d
;a is the width/2
;d is width
;e is height
;b is the height
;c is the method
;h is X
;l is Y
DrawLineLoop:
call DrawLinePixel
sub d
jr c,subline
call ChangeY
djnz DrawLineLoop
ret
subline:
call ChangeX
add a,e
jr c,$+8
call DrawLinePixel
jp subline
call ChangeY
djnz DrawLineLoop
ret
ChangeY:
bit RayPattern,(iy+33)
call nz,PatternInc
exx
add hl,de
exx
inc l
bit 7,c
jr z,$+4
dec l \ dec l
ret
ChangeX:
ex af,af'
rrca
inc h
bit 6,c
jr z,$+6
dec h \ dec h \ rlca \ rlca
jr nc,$+5
exx
add hl,bc
exx
ex af,af'
ret
DrawLinePixel:
bit MerthPattern,(iy+33)
call nz,PatternInc
bit 7,(iy+33)
ret nz
push af
ld a,l
cp 64
jr nc,ExitDrawPixel
ld a,h
cp 96
jr nc,ExitDrawPixel
ex af,af'
exx
call PlotLinePix
exx
ex af,af'
ExitDrawPixel:
pop af
ret

RAMCode:
PlotLinePix equ $-RAMCode+RAMCodeLoc
push af
nop
or (hl)
ld (hl),a
pop af
ret
PatternInc equ $-RAMCode+RAMCodeLoc
push hl
push af
PatternIncVar equ 1+$-RAMCode+RAMCodeLoc
ld a,0
dec a
jr nz,EndPatternInc
PatternNext:
ld a,80h
xor (iy+33)
ld (iy+33),a
ld hl,PatternIncVar2
PatternIncVar2 equ 2+$-RAMCode+RAMCodeLoc
ld a,(ix-1)
inc a
jr nz,$+6
ld (hl),0
jr $-8
dec (hl)
dec a
jr z,PatternNext
EndPatternInc:
ld (PatternIncVar),a
pop af
pop hl
ret

07 Jun 2012 09:23:47 am by merthsoft		Quote
Haha, I'm a fan of the Merth pattern! I don't know enough about z80 to say anything about the code, but I'm glad you added that patterning in

New Post	New Topic
Goto page Previous 1, 2, 3, 4, 5, 6 Next