Skip to content

Latest commit

 

History

History
155 lines (131 loc) · 9.87 KB

README.md

File metadata and controls

155 lines (131 loc) · 9.87 KB
Raw

FPLIB-51

Experimental MCS-51 Family Single Precision Floating Point Math Library

This project is a free implementation of single precision floating-point math routines for the MCS-51 family of micro-controllers.

The project contains the following assembly source files:

  • INOUT.S03: terminal I/O routines.
  • FPLIB.S03: the floating-point math routines and FP Executive;
  • FPEVAL.S03: a math expression parser and evaluator;
  • FPTEST.S03: a sample test program;

FP executive

The FP Executive is a calculator that performs FP calculations specified by a sequence of P-Code instructions each specifying the math operation or function call. The operations are performed using reverse Polish notation and a stack of 4 registers X, Y, Z and T.

The sequence of instructions can be stored either in CODE memory (called using call fp_run_pc if the sequence immediately follows this call, or using call fp_run_cdptr where the sequence is pointed by DPTR) or in XDATA memory (called using call fp_run_xdptr where the sequence is pointed by DPTR). This sequence is terminated with %ret, and the control returns to the calling program.

The P-Code statements are:

P-Code Operation
%nop NOP: No operation
%ret RET: Return to caller / End of P-Code sequence
%call a CALL: call procedure at given address
%push PUSH: Push X on stack push X on stack (roll stack up, keeping X)
%stox a STOX: store X to xdata memory at given address
%rclx a RCLX: recall from xdata memory at given address to X (roll stack up)
%swap SWAP: swap X and Y values
%rldn RLDN: roll stack down (T -> Z -> Y -> X -> T)
%add ADD: X <- Y + X; Y <- Z; Z <- T
%sub SUB: X <- Y - X; Y <- Z; Z <- T
%mul MUL: X <- Y * X; Y <- Z; Z <- T
%div DIV: X <- Y / X; Y <- Z; Z <- T
%pow POW: X <- Y ^ X; Y <- Z; Z <- T
%chs CHS: X <- -X
%inv INV: X <- 1 / X
%lastx LASTX: T <- Z; Z <- Y; Y <- X; X <- LASTX
%input INPUT: T <- Z; Z <- Y; Y <- X; X <- user input
%write s WRITE: write text to string buffer until null char
%prompt PROMPT: write string from string buffer to terminal and wait user input
%readx READX: T <- Z; Z <- Y; Y <- X; X <- value in string buffer
%writex WRITEX: print X to string buffer
%ln LN: X <- ln(X)
%exp EXP: X <- exp(X)
%sin SIN: X <- sin(X)
%cos COS: X <- cos(X)
%tan TAN: X <- tan(X)
%asin ASIN: X <- asin(X)
%acos ACOS: X <- acos(X)
%atan ATAN: X <- atan(X)
%log LOG: X <- log(X)
%pow2 POW2: X <- X * X
%sqrt SQRT: X <- sqrt(x)
%enter f ENTER: T <- Z; Z <- Y; Y <- X; X <- immediate value
%aclear ACLEAR: clear string buffer
%clear CLEAR: X <- 0; Y <- 0; Z <- 0; T <- 0
%print PRINT: print string to terminal
%int INT: integer portion
%frac FRAC: fractional portion
%sto n STO: store X to storage area
%rcl n RCL: recall from storage area to X (roll stack up)
%cint CINT: convert X to unsigned integer
%pi PI: load PI
%e E: load e = exp(1)
%stow n STOW: store X as 16 bit unsigned int to storage area using half registers
%rclw n RCL: recall 16 bit unsigned int from storage area to X (roll stack up) using half registers
%cmp CMP: compare
%jmp a JMP: jump
%jc a JC: jump if carry
%jnc a JNC: jump if no carry
%jz a JZ: jump if zero
%jnz a JNZ: jump if not zero
%je a JE: jump if error
%jne a JNE: jump if no error
%djnz n,a DJNZ: decrement register and jump if not zero
%test TEST: test register X
%fmt n FMT: set output format

FPLIB: the floating-point math ROUTINES

The following public routines are implemented:

  • Routines on packed values in internal memory via pointers:
    • addfp: @r0 := @r0 + @r1
    • subfp: @r0 := @r0 - @r1
    • chsfp: @r0 := -@r0
    • intfp: @r0 := int(@r0)
    • fracfp: @r0 := @r0-int(@r0)
    • mulfp: @r0 := @r0 * @r1
    • divfp: @r0 := @r0 / @r1
    • invfp: @r0 := 1 / @r0
    • sqrtfp: @r0 := sqrt( @r0 ) [Newton-Raphson]
    • pow2fp: @r0 := @r0 * @r0
    • lnfp: @r0 := ln( @r0 ) = log2( @r0 ) * ln( 2 )
    • logfp: @r0 := log( @r0 ) = ln( @r0 ) / ln( 10 )
    • expfp: @r0 := exp( @r0 ) [Taylor expansion]
    • sinfp: @r0 := sin( @r0 ) [Taylor expansion]
    • cosfp: @r0 := cos( @r0 ) = sin( @r0 + Pi/2 )
    • tanfp: @r0 := sin( @r0 ) / cos( @r0 )
    • atanfp: @r0 := arctan( @r0 ) [Taylor expansion]
    • asinfp: @r0 := arctan( @r0 / sqrt( 1 - @r0 * @r0 ) )
    • acosfp: @r0 := Pi / 1 - arcsin( @r0 )
    • powfp: @r0 := pow( @r0, @r1 ) = exp( @r0 * ln( @r1 ) )
    • pifp: @r0 := Pi
    • efp: @r0 := E = exp( 1 )
    • writefp: write @r0 to string buffer
    • readfp: parse and read @rO from string buffer
  • Routines using X-Y-Z-T stack and the FP Executive (see below):
    • fp_run_pc: execute FP Executive code from CODE memory at current PC
    • fp_run_xdptr: execute FP Executive code from DATA memory at dptr
    • fp_run_cdptr: execute FP Executive code from CODE memory at dptr

FPEVAL: the floating-point math expression evaluator

The procedure fpeval in this module can parse and evaluate a math expression stored in XDATA memory and pointer by DPTR.

The result of the expression is stored in internal DATA memory at the location pointed by R0.

The syntax is:

expr   := sum

sum    := prod
       |  sum + prod
       |  sum - prod

prod    := pow
        |  prod * pow
        |  prod / pow

pow     := func
        |  func ^ pow

func    := value
        |  PI
        |  func_id value

value   := ( expr )
        |  number

number  := -expr
        |  [[0-9...].]0-9...

func_id := SQRT | SQR | LOG | LN | EXP | SIN | COS | TAN | ASIN | ACOS | ATAN | INT | FRAC

(tbc)