*       Fuzzy Logic Inferrence Engine
*
*** Data structures and variables
*
        ORG     $0000                ;Beginning of HC11 RAM
CURRENT_INS RMB 8                ;Storage for 8 8-bit inputs
FUZ_OUTS        RMB     32      ;Storage for fuzzy outputs
COG_OUTS        RMB     4        ;Defuzzified outputs
LOWEST_IF RMB   1    ;Holds min grade of IF parts
SUM_OF_FUZ RMB  2  ;11-bit sum of fuzzy outs
SUM_OF_PROD RMB 3                ;19-bit sum of products
COGDEX  RMB       1            ;Current out # for COG loop 0->4
SUMDEX  RMB       1            ;Index for sum loop 8->0

        ORG     $B600                Beginning of HC11 EEPROM
IN_MF_PTRS FDB  IN0MF          ;Addr of MF data for input 0
        FDB     IN1MF                ;Addr of MF data for input 1
        FDB     IN2MF                ;Addr of MF data for input 2
        FDB     IN3MF                ;Addr of MF data for input 3
        FDB     IN4MF                ;Addr of MF data for input 4
        FDB     IN5MF                ;Addr of MF data for input 5
        FDB     IN6MF                ;Addr of MF data for input 6
        FDB     IN7MF                ;Addr of MF data for input 7
*
* Input membership functions are defined by four 8-bit values per
* input label. Up to 8 labels per input so max size of MF data
* structure is 8*8*4=256 bytes. Unused labels take no space.
* Membership functions are trapezoids with the base greater than or
* equal to the top. Values are entered into this program as the
* X coordinates of 4 points but are stored as 2 points and 2 slopes.
*
***** MACRO Definition for input membership functions
*
INMF    MACR        ;For input membership functions
        FCB     0                        ;First inflection point
        IFNE 1-0                              ;Check for divide by zero
         FCB    ($FF+((1-0)/3))/(1-0) ;If not, calc slope
        ENDC
        IFEQ 1-0                              ;Check for divide by zero
         FCB    $00                     ;Indicates vertical slope
        ENDC
        FCB     2                        ;Third inflection point
        IFNE 3-2                              ;Check for divide by zero
         FCB    ($FF+((3-2)/3))/(3-2) ;If not, calc slope
        ENDC
        IFEQ 3-2                              ;Check for divide by zero
         FCB    $00                     ;Indicates vertical slope
        ENDC
        ENDM
*       
*****
INPUT_MFS EQU   *       ;Input membership functions

IN0MF   EQU        *                       ;(0) ROTATION
        INMF    0,0,0,8*4            ; (0) STOPPED
        INMF    0,8*4,$FF,$FF        ;      (1) NOT_STOPPED

IN1MF   EQU        *                       ;(1) EXAMPLE1
        INMF    $20,$40,$60,$A0      ;      (0) TEST1

IN2MF   EQU        *                       ;(2) TEMPERATURE
        INMF    2*0,2*0,2*40,2*50      ;       (0) COLD
        INMF    2*40,2*50,2*60,2*70  ;      (1) COOL
        INMF    2*60,2*70,2*80,2*90  ;      (2) WARM
        INMF    2*80,2*90,2*95,2*110 ;      (3) HOT
        INMF    2*90,2*110,$FF,$FF   ;      (4) VERY_HOT

IN3MF   EQU        *                       ;(3) DAYS_SINCE_RAIN
        INMF    $00,$00,$00,$08        ; (0) NONE
        INMF    $00,$10,$10,$18        ; (1) SHORT
        INMF    $10,$20,$28,$40        ; (2) MEDIUM
        INMF    $30,$40,$50,$60        ; (3) LONG
        INMF    $50,$70,$FF,$FF        ; (4) VERY_LONG

IN4MF   EQU        *              ;Not used
IN5MF   EQU        *              ;Not used
IN6MF   EQU        *              ;Not used
IN7MF   EQU        *              ;Not used

SGLTN_POS EQU   *    ;Output singleton positions
OUT0MF  EQU       *            ;(0) WATERING_TIME
        FCB     $00      ;(0) CUT_OFF
        FCB     $10      ;(1) DECREASE_GREATLY
        FCB     $40      ;(2) DECREASE
        FCB     $80      ;(3) NORMAL
        FCB     $B0      ;(4) INCREASE
        FCB     $F0      ;(5) INCREASE_GREATLY
        FCB     0,0    ;Unused; Must fill 8 per output
OUT1MF  FCB       0,0,0,0,0,0,0,0        ;Not used
OUT2MF  FCB       0,0,0,0,0,0,0,0        ;Not used
OUT3MF  FCB       0,0,0,0,0,0,0,0        ;Not used
*
* Each If part is of the form 00AA AXXX where AAA is a label (0-7)
* and XXX is an input (0-7). If parts are connected by ANDs. A rule
* may have any number of if parts (usually 2-8). Then parts are of
* the form 100Y YCCC where the MSB set indicates a then part, YY is
* the output number (0-3), and CCC is the output label (singleton
* 0-7). A rule may have any number of then parts (usually 1 or 2).
* A $FF indicates the end of a series of rules (number not limited).
* 
*       FCB    INx + 8*LABa        ;If input XXX is label AAA
*       FCB    $80+8*OUTy+LABc     ;Then output YY is label CCC

RULE_START EQU  *  ;Start of first rule
* Example rule: If TEMPERATURE is VERY_HOT and DAYS_SINCE_RAIN is LONG
* Then WATERING_TIME is INCREASE_GREATLY
RULE_1  FCB       2+(8*4),3+(8*3),$80+(8*0)+5
END_OF_RULE FCB $FF

***** Fuzzy Inferrence Engine Starts Here
*
        ORG     $B66B
INFER_TOP LDX   #FUZ_OUTS  ;Point at first fuzzy output
        LDAA    #32  ;32 fuzzy outputs
CLR_OUTS        CLR     0,X    ;Clear a fuzzy output
        INX               ;Point at next
        DECA            ;Loop index
        BNE     CLR_OUTS          ;Continue till all fuzzy outs 0
        LDY     #RULE_START  ;Point to start of 1st rule
RULE_TOP        LDAA    #$FF                ;Begin processing rule string
        STAA    LOWEST_IF   ;Will hold grade of min if part
IF_LOOP LDAB     0,Y    ;Get rule byte 00AA AXXX; If X is A
        BMI     THEN_LOOP    ;If MSB=1, exit to then loop
        LDX     #CURRENT_INS ;Point at current input data area
        ANDB    #$07                ;Save only input number
        PSHB            ;Will need input # again
        ABX               ;Point to specific input data
        LDAA    0,X  ;Get current input data
        LDX     #IN_MF_PTRS  ;Point at offsets for input MFs
        PULB            ;Recover input number 0000 0XXX
        ABX               ;Point at pointer for this input #
        LDX     0,X    ;Get pointer into MF data area
        LDAB    0,Y  ;Get rule if part 00AA AXXX
        ANDB    #$38                ;00AA A000 is 8 times AAA
        LSRB            ;000A AA00 4 times AAA
        ABX               ;X points at MF points & slopes
        CMPA    0,X  ;Compare input data to MF pt1
        BHS     NOT_SEG0          ;Branch if not segment zero
        CLRB            ;In seg 0 grade is zero
        BRA     HAVE_GRADE   ;Have grade of membership
NOT_SEG0        CMPA    2,X  ;Compare input data to MF pt2
        BHI     IS_SEG2            ;Branch if segment two
        LDAB    1,X  ;Slope1 -> B
        BEQ     JAM_FF              ;If vert slope, jam $FF
        SUBA    0,X  ;Input value - pt1 -> A
        MUL               ;Grade in B if D < $100
        CPD     #$100                ;Check for overflow
        BLO     HAVE_GRADE   ;If < $100 grade OK in B
JAM_FF  LDAB      #$FF    ;Else limit B to $FF
        BRA     HAVE_GRADE   ;Have grade of membership
IS_SEG2 LDAB     3,X    ;Slope2 -> B
        SUBA    2,X  ;Input value - pt2 -> A
        MUL               ;Grade in B if D < $100
        CPD     #$100                ;Check for overflow
        BLO     B_OK  ;If < $100 value in B OK
        LDAB    #$FF                ;Else limit B to $FF
B_OK    LDAA        #$FF        ;Grade should be $FF - (B)
        SBA               ;Grade of membership in B
HAVE_GRADE CMPB LOWEST_IF        ;Is grade lowest so far ?
        BHS     NOT_LOWR          ;Branch if not lower
        STAB    LOWEST_IF   ;If lower, replace lowest if
        BNE     NOT_LOWR          ;Skip ahead if not zero
FIND_THEN INY         ;Adv rule pointer to then part
        LDAB    0,Y  ;Get next rule byte
        BPL     FIND_THEN    ;MSB set means its a then part
FIND_IF INY                  ;Adv rule pointer to if part
        LDAB    0,Y  ;Get next rule byte
        BPL     RULE_TOP          ;MSB clear means its an if part
        CMPB    #$FF                ;$FF is no more rules marker
        BNE     FIND_IF            ;Continue looking for if or $FF
        BRA     DEFUZ                ;When all rules done, go defuzzify
NOT_LOWR        INY               ;Point to next rule byte
        BRA     IF_LOOP            ;Continue for all if parts
THEN_LOOP LDX   #FUZ_OUTS  ;Point at fuzzy outputs
        ANDB    #$1F                ;Save 8 times out # + label #
        ABX               ;X points at fuzzy output
        LDAA    LOWEST_IF   ;Grade of membership for rule
        CMPA    0,X  ;Compare to fuzzy output
        BLO     NOT_HIER          ;Branch if not higher
        STAA    0,X  ;Grade is higher so update
NOT_HIER        INY               ;Point to next rule byte
        LDAB    0,Y  ;Get rule byte
        BMI     CHK_END            ;If MSB=0 its a new rule
        JMP     RULE_TOP          ;Else process next rule byte
CHK_END CMPB     #$FF  ;Check for end of rules flag
        BNE     THEN_LOOP    ;If not $FF, must be a then part
DEFUZ   LDY        #SGLTN_POS      ;Point at 1st output singleton
        LDX     #FUZ_OUTS    ;Point at 1st fuzzy output
        CLR     COGDEX              ;Loop index will run from 0->4
COG_LOOP        LDAB    #8    ;8 fuzzy outs per COG output
        STAB    SUMDEX            ;Inner loop runs 8->0
        LDD     #$0000              ;Used for quicker clears
        STD     SUM_OF_FUZ   ;Sum of fuzzy outputs
        STD     SUM_OF_PROD+1        ;Low 16-bits of sum of products
        STAA    SUM_OF_PROD ;Upper 8-bits
SUM_LOOP        LDAB    0,X  ;Get a fuzzy output
        CLRA            ;Clear upper 8-bits
        ADDD    SUM_OF_FUZ  ;Add to sum of fuzzy outputs
        STD     SUM_OF_FUZ   ;Update RAM variable
        LDAA    0,X  ;Get fuzzy output again
        LDAB    0,Y  ;Get Output singleton position
        MUL               ;Position times weight
        ADDD    SUM_OF_PROD+1       ;Low 16-bits of sum of products
        STD     SUM_OF_PROD+1        ;Update low 16-bits
        LDAA    SUM_OF_PROD ;Upper 8-bits
        ADCA    #0    ;Add carry from 16-bit add
        STAA    SUM_OF_PROD ;Upper 8-bits of 24-bit sum
        INY               ;Point at next singleton pos.
        INX               ;Point at next fuzzy output
        DEC     SUMDEX              ;Inner loop index
        BNE     SUM_LOOP          ;For all labels this output
        PSHX            ;Save index for now
        CLRA            ;In case divide by zero
        LDX     SUM_OF_FUZ   ;Demominator for divide
        BEQ     SAV_OUT            ;Branch if denominator is 0
        TST     SUM_OF_PROD  ;See if more than 16-bit
        BNE     NUM_BIG            ;If not zero, # is > 16-bits
        LDD     SUM_OF_PROD+1        ;Numerator for divide
        IDIV            ;Result in low 8-bits of X
        XGDX            ;Result now in B
        TBA               ;Move result to A
        BRA     SAV_OUT            ;Go save output
NUM_BIG LDD      SUM_OF_PROD   ;Numerator upper 16 of 24-bit
        TST     SUM_OF_PROD+2        ;Check for rounding error
        BPL     NO_ROUND          ;If MSB clear, don't round
        ADDD    #1    ;Round numerator up 1
NO_ROUND        FDIV            ;D/X -> X, use upper 8 of 16
        XGDX            ;Result now in A
SAV_OUT LDX      #COG_OUTS     ;Point to 1st defuz output
        LDAB    COGDEX            ;Curent output number
        ABX               ;Point to correct output
        STAA    0,X  ;Update defuzzified output
        PULX            ;Recover index
        INCB            ;Increment loop index
        STAB    COGDEX            ;Update
        CMPB    #4    ;Done with all four outs?
        BNE     COG_LOOP          ;If not, continue loop

* Inference engine has completed one pass of all rules.