* Fuzzy Logic Inferrence Engine * ** This is the fifth variation of this fuzzy engine. The first used * a macro and conditional assembly for entry of rules and MFs. It * also combined fuzzification with rule evaluation. The 2nd version * was more efficient because fuzzy ins are only calculated once. * Also a c program was written to simplify rule and MF entry rather * than a macro and conditional assembly which were not very * portable from one assembler to another. The 2nd version used fixed * data structures for 4 ins and 2 outs. This, the third version, is * identical to the 2nd version, except that the input and output size * is variable. The number of Inputs and Outputs is set by the Knowledge * Base Generator (kbg_11b1.exe). KBG_11B1 counts the actual number of * Inputs and Outputs that you defined and generates an assembly language * define statement for this Inference Engine to use. * * Revision: B2 - fourth variation * Author : Raymond Carr (813) 461-6963 * Filename: FUZZ11B2.ASM * Date : 06/30/92 * Notes: Errors were found in version Rev B1 which would not allow for * more than 2 outputs. The reason for this was the mask used * after the THEN_LOOP label was a #$0F. This mask is ANDed * with the B accumulator to strip off the MSB indicating the * THEN portion of the rule under evaluation. Since there are * 8 singletons per output this allowed access to only 16 ($0F) * singletons, hence 2 outputs. This mask was changed to #$7F to * allow for up to 16 outputs. The KBG knowledge base generator * will provide a valid rule base for only 4 outputs at this time. * * Revision B1 was designed to save memory by dynamically * allocating memory via a EQU for the number of inputs, NUMINP, * and the number of outputs, NUMOUT. The equations using these * EQU's were enclosed in parenthesis, e.g. (8*NUMINP). The AS11 * assembler available on the FREEWARE BBS will evaluate this * expression and return a result of 0. The equations were * modified to take out the parenthesis and reorder the * evaluation. AS11 will work with 8*NUMINP+FUZ_INS, but not * FUZ_INS+8*NUMINP. Also, the dynamic allocation of inputs * required a change that was not made in Rev B1. At the very * beginning of the inference engine the program PUSHes the * current actual inputs onto the stack starting with the last * one. This works well because it allows the grading routine * easy access to the next input by PULLing it off. However, * the dynamic allocation of inputs requires dynamic PUSHing * of the stack, otherwise every time you exit the routine * your stack would be off by 4-(# of inputs). Dynamic allocation * works now. * * Revision: B3 - fifth variation * Author : Raymond Carr (813) 461-6963 * Filename: FUZZ11B3.ASM * Date : 07/01/92 * Notes: A logic error was found in the rule evaluation when looking * for the smallest component of an; IF .. IS ..; clause, the * program was maxing all THEN outputs to $FF due to a * BHS instead of a BLS 3 lines before the FIND_THEN label. * Also, make sure if you are using the knowledge base generator * routines you have a version later than kbg_11b2.exe. The * earlier versions evaluate the rules incorrectly for this ASM * file. * An important observation is that if an output is not associated * with a rule in the rule base whose IF .. IS.. clause provides * some degree of membership the output value will be a 0. This * is important if you have defined an output SPEED with * singletons of HardReverse, MedReverse, SmallReverse, * StandStill, SmallForward, MedForward, HardForward. * HardReverse is associated with an actual binary value of 0 and * StandStill is associated with a value of $7F. Therefore if * SPEED is not associated with a rule whose IF .. IS.. clause is * somewhat true it will get a value of 0, not $7F, your car will * proceed backwards instead of standing still. i.e. HardReverse * instead of StandStill. One way to overcome this problem is to * provide a THEN clause for all defined outputs for every * IF .. IS .. rule. *** Data structures and variables * ORG $0000 ;Beginning of HC11 RAM CURRENT_INS RMB NUMINP ;Storage for 8-bit inputs FUZ_INS RMB 8*NUMINP ;Storage for fuzzy inputs (RIGHT NOW MAX=8) FUZ_OUTS RMB 8*NUMOUT ;Storage for fuzzy outputs (RIGHT NOW MAX=4) COG_OUTS RMB NUMOUT ;Defuzzified outputs 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 LP_COUNT RMB 1 ;Index for fuz loop SUMDEX RMB 1 ;Index for sum loop ORG $B600 ;Beginning of HC11 EEPROM * Add the output from KBG_11C.exe here..... ***** Fuzzy Inferrence Engine Starts Here * Program assumes at least 1 valid input * FUZZIFY LDY #FUZ_INS ;Point to fuzzy input table LDX #CURRENT_INS+NUMINP-1 ;Point to last input value PUSH_LOOP LDAA 0,X ;get value PSHA ;and store on stack CPX #CURRENT_INS ;last value? BEQ DONE_PUSH ;if so, then branch DEX ;else point to next byte BRA PUSH_LOOP ;branch for next value DONE_PUSH LDX #INPUT_MFS ;Point to input MF specs NXTIN_LP PULA ;Get next current input value LDAB #7 ;For 8 loop passes STAB LP_COUNT ;Initialize loop counter GRAD_LOOP EQU * ;Get grade for 1 label of 1 input ******************************************************************* * GET_GRADE - Routine to project a discrete input value onto * * the associated input membership function (fuzzification). * * Enter with Input value in A register and X pointing at the * * points and slopes defining the membership function. * * Finishes with grade in B, X points at next MF spec (X+4) * * and A is unchanged. * ******************************************************************* GET_GRADE PSHA ;Save input value of A CLRB ;In case grade = 0 SUBA 2,X ;Input value D pt2 -> A BLS NOT_SEG2 ;If input < pt2 LDAB 3,X ;Slope 2 BEQ HAV_GRAD ;Skip if vert slope MUL ;(In D pt1) * slp2 -> A:B TSTA ;Check for > $FF BEQ NO_FIX ;If upper 8 = 0 CLRB ;Limit grade to 0 BRA HAV_GRAD ;In limit region of seg 2 NO_FIX SUBB #$FF ;B D $FF NEGB ;$FF D B BRA HAV_GRAD ;($FF D((In D pt2) * slp2)) NOT_SEG2 ADDA 2,X ;Restore input value SUBA 0,X ;Input value D pt1 -> A BLO HAV_GRAD ;In < pt1 so grade = 0 LDAB 1,X ;Slope 1 BEQ VERT_SLP ;Skip if vert slope MUL ;(In D pt1) * slp1 -> A:B TSTA ;Check for > $FF BEQ HAV_GRAD ;Result OK in B VERT_SLP LDAB #$FF ;Limit region or vert slope HAV_GRAD INX ;Point at next MF spec INX INX INX PULA ;Restore A register STAB 0,Y ;Save @ fuzzy input INY ;Point at next DEC LP_COUNT ; BPL GRAD_LOOP ;For 8 labels of 1 input CMPY #NUMINP*8+FUZ_INS ;Done with all fuzzy ins? BNE NXTIN_LP ;If not, process next input * Done with fuzzification, evaluate rules next LDX #FUZ_OUTS ;Point at first fuzzy output LDAA #8*NUMOUT ;Number of 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 a rule string * A will hold grade of smallest (min) if part IF_LOOP LDAB 0,Y ;Get rule byte 000X XAAA; If X is A BMI THEN_LOOP ;If MSB=1, exit to then loop INY ;Point at next rule byte LDX #FUZ_INS ;Point at fuzzy inputs ABX ;Point to specific fuzzy input CMPA 0,X ;Is this fuzzy input lower? BLS IF_LOOP ;If not don't replace lowest LDAA 0,X ;Replace lowest if BNE IF_LOOP ;Unless zero, do next rule byte * A zero value fuzzy input makes rule completely not true * so skip rest of if parts and all then parts to start of next rule FIND_THEN LDAB 0,Y ;Get next rule byte BMI FIND_IF ;MSB set means its a then part INY ;Point at next rule byte BRA FIND_THEN ;Loop till pointing at 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 THEN_LOOP LDX #FUZ_OUTS ;Point at fuzzy outputs ANDB #$7F ;Save 8 times out # + label # ABX ;X points at fuzzy output * Grade of membership for rule is in A accumulator 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 ;Adv rule pointer to next byte LDAB 0,Y ;Get rule byte BPL RULE_TOP ;If MSB=0 its a new rule CHK_END CMPB #$FF ;Check for end of rules flag BNE THEN_LOOP ;If not $FF, must be a then part * All rules evaluated. Now defuzzify fuzzy outputs 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->1 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 #NUMOUT ;Done with outputs? BNE COG_LOOP ;If not, continue loop ***** * Inference engine has completed one pass of all rules. *****