fc_ctrl.rmh

来自「和picoblaze完全兼容的mcu ip core」· RMH 代码 · 共 1,493 行 · 第 1/4 页

// #142: ; delay_1us_constant =  (clock_rate - 6)/4       Where 'clock_rate' is in MHz
// #143: ;
// #144: ;Example: For a 50MHz clock the constant value is (10-6)/4 = 11  (0B Hex).
// #145: ;For clock rates below 10MHz the value of 1 must be used and the operation will
// #146: ;become lower than intended.
// #147: ;
// #148: CONSTANT(delay_1us_constant,11)
// #149: ;
// #150: ;
// #151: ;
// #152: ;ASCII table
// #153: ;
// #154: CONSTANT(character_a,97)
// #155: CONSTANT(character_b,98)
// #156: CONSTANT(character_c,99)
// #157: CONSTANT(character_d,100)
// #158: CONSTANT(character_e,101)
// #159: CONSTANT(character_f,102)
// #160: CONSTANT(character_g,103)
// #161: CONSTANT(character_h,104)
// #162: CONSTANT(character_i,105)
// #163: CONSTANT(character_j,106)
// #164: CONSTANT(character_k,107)
// #165: CONSTANT(character_l,108)
// #166: CONSTANT(character_m,109)
// #167: CONSTANT(character_n,110)
// #168: CONSTANT(character_o,111)
// #169: CONSTANT(character_p,112)
// #170: CONSTANT(character_q,113)
// #171: CONSTANT(character_r,114)
// #172: CONSTANT(character_s,115)
// #173: CONSTANT(character_t,116)
// #174: CONSTANT(character_u,117)
// #175: CONSTANT(character_v,118)
// #176: CONSTANT(character_w,119)
// #177: CONSTANT(character_x,120)
// #178: CONSTANT(character_y,121)
// #179: CONSTANT(character_z,122)
// #180: CONSTANT(character_A,65)
// #181: CONSTANT(character_B,66)
// #182: CONSTANT(character_C,67)
// #183: CONSTANT(character_D,68)
// #184: CONSTANT(character_E,69)
// #185: CONSTANT(character_F,70)
// #186: CONSTANT(character_G,71)
// #187: CONSTANT(character_H,72)
// #188: CONSTANT(character_I,73)
// #189: CONSTANT(character_J,74)
// #190: CONSTANT(character_K,75)
// #191: CONSTANT(character_L,76)
// #192: CONSTANT(character_M,77)
// #193: CONSTANT(character_N,78)
// #194: CONSTANT(character_O,79)
// #195: CONSTANT(character_P,80)
// #196: CONSTANT(character_Q,81)
// #197: CONSTANT(character_R,82)
// #198: CONSTANT(character_S,83)
// #199: CONSTANT(character_T,84)
// #200: CONSTANT(character_U,85)
// #201: CONSTANT(character_V,86)
// #202: CONSTANT(character_W,87)
// #203: CONSTANT(character_X,88)
// #204: CONSTANT(character_Y,89)
// #205: CONSTANT(character_Z,90)
// #206: CONSTANT(character_0,48)
// #207: CONSTANT(character_1,49)
// #208: CONSTANT(character_2,50)
// #209: CONSTANT(character_3,51)
// #210: CONSTANT(character_4,52)
// #211: CONSTANT(character_5,53)
// #212: CONSTANT(character_6,54)
// #213: CONSTANT(character_7,55)
// #214: CONSTANT(character_8,56)
// #215: CONSTANT(character_9,57)
// #216: CONSTANT(character_colon,58)
// #217: CONSTANT(character_stop,46)
// #218: CONSTANT(character_semi_colon,59)
// #219: CONSTANT(character_minus,45)
// #220: CONSTANT(character_divide,47) ;'/'
// #221: CONSTANT(character_plus,43)
// #222: CONSTANT(character_comma,44)
// #223: CONSTANT(character_less_than,60)
// #224: CONSTANT(character_greater_than,62)
// #225: CONSTANT(character_equals,61)
// #226: CONSTANT(character_space,32)
// #227: CONSTANT(character_CR,13) ;carriage return
// #228: CONSTANT(character_question,63) ;'?'
// #229: CONSTANT(character_dollar,36)
// #230: CONSTANT(character_exclaim,33) ;'!'
// #231: CONSTANT(character_BS,8) ;Back Space command character
// #232: ;
// #233: ;
// #234: ;
// #235: ;
// #236: ;
// #237: ;**************************************************************************************
// #238: ;Initialise the system
// #239: ;**************************************************************************************
// #240: ;
// @000 #241: [cold_start]
301fd // @000 #241: CALL(LCD_reset) ;initialise LCD display
00000 // @001 #242: LOAD(s0,0) ;Turn off LEDs
2c001 // @002 #243: OUTPUT(s0,LED_port)
// #244: ;
// #245: ;
// #246: ;Write welcome message to LCD display
// #247: ;
00510 // @003 #248: LOAD(s5,16) ;Line 1 position 0
30213 // @004 #249: CALL(LCD_cursor)
300c0 // @005 #250: CALL(disp_PicoBlaze) ;Display 'PicoBlaze Inside'
301b5 // @006 #251: CALL(delay_1s) ;wait 3 seconds
301b5 // @007 #252: CALL(delay_1s)
301b5 // @008 #253: CALL(delay_1s)
00510 // @009 #254: LOAD(s5,16) ;Line 1 position 0
30213 // @00a #255: CALL(LCD_cursor)
300d3 // @00b #256: CALL(disp_Frequency) ;Display 'Frequency Counter V1.00'
00521 // @00c #257: LOAD(s5,33) ;Line 2 position 1
30213 // @00d #258: CALL(LCD_cursor)
300e6 // @00e #259: CALL(disp_Counter)
0052b // @00f #260: LOAD(s5,43) ;Line 2 position 11
30213 // @010 #261: CALL(LCD_cursor)
300f5 // @011 #262: CALL(disp_version)
301b5 // @012 #263: CALL(delay_1s) ;wait 5 seconds
301b5 // @013 #264: CALL(delay_1s)
301b5 // @014 #265: CALL(delay_1s)
301b5 // @015 #266: CALL(delay_1s)
301b5 // @016 #267: CALL(delay_1s)
3020e // @017 #268: CALL(LCD_clear) ;Clear display
// #269: ;
// #270: ;Kick start the DCM oscillator.
// #271: ; Just requires a few cyles of activity
// #272: ;
000ff // @018 #273: LOAD(s0,FF)
00100 // @019 #274: LOAD(s1,0)
// @01a #275: [kick_loop]
2c108 // @01a #275: OUTPUT(s1,source_control_port)
0e180 // @01b #276: XOR(s1,dcm_kick) ;toggle kick start signal
1c001 // @01c #277: SUB(s0,1)
3541a // @01d #278: JUMP(NZ,kick_loop)
// #279: ;
// #280: ;clear all scratch pad memory locations
// #281: ;
0013f // @01e #282: LOAD(s1,63)
00000 // @01f #283: LOAD(s0,0)
// @020 #284: [clear_spm]
2f010 // @020 #284: STORE(s0,s1)
1c101 // @021 #285: SUB(s1,1)
35c20 // @022 #286: JUMP(NC,clear_spm)
// #287: ;
3c001 // @023 #288: ENABLE(INTERRUPT)
// #289: ;
// #290: ;**************************************************************************************
// #291: ;Main Program
// #292: ;**************************************************************************************
// #293: ;
// #294: ;The task of the main program is just to read the most recent values from
// #295: ;scratch pad memory and display them as fast as it can.
// #296: ;
// #297: ;It also reads the slide switches controls the selection of the source frequency to
// #298: ;be measured.
// #299: ;
// @024 #300: [warm_start]
00521 // @024 #300: LOAD(s5,33) ;Line 2 position 1
30213 // @025 #301: CALL(LCD_cursor)
04f80 // @026 #302: INPUT(sF,status_port) ;select source based on switches
14f00 // @027 #303: COMPARE(sF,0) ;test for no switches active
0af0f // @028 #304: AND(sF,15) ;isolate switches
3542c // @029 #305: JUMP(NZ,test_SMA)
3015d // @02a #306: CALL(disp_menu)
34024 // @02b #307: JUMP(warm_start)
// @02c #308: [test_SMA]
14f01 // @02c #308: COMPARE(sF,switch0)
35431 // @02d #309: JUMP(NZ,test_50M)
30100 // @02e #310: CALL(disp_SMA_input)
00f00 // @02f #311: LOAD(sF,0)
34041 // @030 #312: JUMP(select_source)
// @031 #313: [test_50M]
14f02 // @031 #313: COMPARE(sF,switch1)
35436 // @032 #314: JUMP(NZ,test_DCM)
30114 // @033 #315: CALL(disp_50MHz_Crystal)
00f01 // @034 #316: LOAD(sF,1)
34041 // @035 #317: JUMP(select_source)
// @036 #318: [test_DCM]
14f04 // @036 #318: COMPARE(sF,switch2)
3543b // @037 #319: JUMP(NZ,test_Ring)
30130 // @038 #320: CALL(disp_DCM_Oscillator)
00f02 // @039 #321: LOAD(sF,2)
34041 // @03a #322: JUMP(select_source)
// @03b #323: [test_Ring]
14f08 // @03b #323: COMPARE(sF,switch3)
3503f // @03c #324: JUMP(Z,Ring_select)
3015d // @03d #325: CALL(disp_menu) ;more than one switch is set
34024 // @03e #326: JUMP(warm_start)
// @03f #327: [Ring_select]
3014e // @03f #327: CALL(disp_Ring_Oscillator)
00f03 // @040 #328: LOAD(sF,3)
// @041 #329: [select_source]
2cf08 // @041 #329: OUTPUT(sF,source_control_port) ;select source control
// #330: ;
// #331: ;Read the most recent values from display on LCD.
// #332: ;
// #333: ;Interrupts will be disabled during the reading of values to ensure a clean
// #334: ;value is obtained when reading multi-byte values.
// #335: ;
// #336: ;
// #337: ;Display the count value in the top right of the LCD display
// #338: ;Up to 999,999,999
// #339: ;
3c000 // @042 #340: DISABLE(INTERRUPT) ;copy cycle count to register set [s5,s4,s3,s2]
06200 // @043 #341: FETCH(s2,count0)
06301 // @044 #342: FETCH(s3,count1)
06402 // @045 #343: FETCH(s4,count2)
06503 // @046 #344: FETCH(s5,count3)
3c001 // @047 #345: ENABLE(INTERRUPT)
30094 // @048 #346: CALL(integer_to_BCD) ;convert last 32-bit value to BCD digits
00510 // @049 #347: LOAD(s5,16) ;Line 1 position 0
30213 // @04a #348: CALL(LCD_cursor)
00619 // @04b #349: LOAD(s6,decimal8) ;up to 999,999,999 Hz
3004e // @04c #350: CALL(disp_digits)
34024 // @04d #351: JUMP(warm_start)
// #352: ;
// #353: ;
// #354: ;
// #355: ;**************************************************************************************
// #356: ; Display frequency value on LCD display
// #357: ;**************************************************************************************
// #358: ;
// #359: ;
// #360: ;Display value on the LCD display at current position.
// #361: ;The values to be displayed must be stored in scratch pad memory
// #362: ;locations 'decimal0' to 'decimal9' which must be in ascending locations.
// #363: ;
// #364: ;The routing performs leading zero suppression and scales to Hz, KHz or MHz ranges.
// #365: ;
// #366: ;Registers used s0,s1,s4,s5,sE,sF
// #367: ;
// @04e #368: [disp_digits]
00fff // @04e #368: LOAD(sF,FF) ;set blanking flag
00e20 // @04f #369: LOAD(sE,character_space) ;scaling character for MHz, KHz or Hz
06519 // @050 #370: FETCH(s5,decimal8) ;100MHz digit
30088 // @051 #371: CALL(zero_test)
3008c // @052 #372: CALL(disp_digit)
06518 // @053 #373: FETCH(s5,decimal7) ;10MHz digit
30088 // @054 #374: CALL(zero_test)
3008c // @055 #375: CALL(disp_digit)
06517 // @056 #376: FETCH(s5,decimal6) ;1MHz digit
30088 // @057 #377: CALL(zero_test)
3008c // @058 #378: CALL(disp_digit)
14fff // @059 #379: COMPARE(sF,FF) ;check if any MHz were active
3505f // @05a #380: JUMP(Z,khz_space)
0052e // @05b #381: LOAD(s5,character_stop)
301d3 // @05c #382: CALL(LCD_write_data)
00e4d // @05d #383: LOAD(sE,character_M)
34061 // @05e #384: JUMP(khz_digits)
// @05f #385: [khz_space]
00520 // @05f #385: LOAD(s5,character_space)
301d3 // @060 #386: CALL(LCD_write_data)
// @061 #387: [khz_digits]
06516 // @061 #387: FETCH(s5,decimal5) ;100KHz digit
30088 // @062 #388: CALL(zero_test)
3008c // @063 #389: CALL(disp_digit)
06515 // @064 #390: FETCH(s5,decimal4) ;10KHz digit
30088 // @065 #391: CALL(zero_test)
3008c // @066 #392: CALL(disp_digit)
06514 // @067 #393: FETCH(s5,decimal3) ;1KHz digit
30088 // @068 #394: CALL(zero_test)
3008c // @069 #395: CALL(disp_digit)
14e4d // @06a #396: COMPARE(sE,character_M) ;check if any MHz were active
35072 // @06b #397: JUMP(Z,hz_space)
14fff // @06c #398: COMPARE(sF,FF) ;check if any KHz were active
35072 // @06d #399: JUMP(Z,hz_space)
0052e // @06e #400: LOAD(s5,character_stop)
301d3 // @06f #401: CALL(LCD_write_data)
00e4b // @070 #402: LOAD(sE,character_K)
34074 // @071 #403: JUMP(hz_digits)
// @072 #404: [hz_space]
00520 // @072 #404: LOAD(s5,character_space)
301d3 // @073 #405: CALL(LCD_write_data)
// @074 #406: [hz_digits]
06513 // @074 #406: FETCH(s5,decimal2) ;100KHz digit
30088 // @075 #407: CALL(zero_test)
3008c // @076 #408: CALL(disp_digit)
06512 // @077 #409: FETCH(s5,decimal1) ;10KHz digit
30088 // @078 #410: CALL(zero_test)
3008c // @079 #411: CALL(disp_digit)
06511 // @07a #412: FETCH(s5,decimal0) ;1KHz digit (always displayed)
18530 // @07b #413: ADD(s5,character_0) ;convert number to ASCII
301d3 // @07c #414: CALL(LCD_write_data)
00520 // @07d #415: LOAD(s5,character_space)
301d3 // @07e #416: CALL(LCD_write_data)
015e0 // @07f #417: LOAD(s5,sE)
301d3 // @080 #418: CALL(LCD_write_data)
00548 // @081 #419: LOAD(s5,character_H)
301d3 // @082 #420: CALL(LCD_write_data)
0057a // @083 #421: LOAD(s5,character_z)
301d3 // @084 #422: CALL(LCD_write_data)
00520 // @085 #423: LOAD(s5,character_space) ;ensure end of line is clear
301d3 // @086 #424: CALL(LCD_write_data)
2a000 // @087 #425: RETURN
// #426: ;
// #427: ;Check digit for zero. If not zero then clear
// #428: ;blanking flag (sF=00)
// @088 #429: [zero_test]
14500 // @088 #429: COMPARE(s5,0)
2b000 // @089 #430: RETURN(Z)
00f00 // @08a #431: LOAD(sF,0)
2a000 // @08b #432: RETURN
// #433: ;
// #434: ;Display single digit at current position
// #435: ;or space if blanking (sF=FF) is active
// #436: ;
// @08c #437: [disp_digit]
14fff // @08c #437: COMPARE(sF,FF)
35091 // @08d #438: JUMP(Z,blank_digit)
18530 // @08e #439: ADD(s5,character_0) ;convert number to ASCII
301d3 // @08f #440: CALL(LCD_write_data)
2a000 // @090 #441: RETURN
// @091 #442: [blank_digit]
00520 // @091 #442: LOAD(s5,character_space)
301d3 // @092 #443: CALL(LCD_write_data)
2a000 // @093 #444: RETURN
// #445: ;
// #446: ;
// #447: ;
// #448: ;**************************************************************************************
// #449: ; 32-bit integer to BCD conversion
// #450: ;**************************************************************************************
// #451: ;
// #452: ;Convert the 32 bit value in register set [s5,s4,s3,s2]
// #453: ;into the BCD decimal equivalent located in the scratch pad memory
// #454: ;locations 'decimal0' to 'decimal9' which must be in ascending locations.
// #455: ;
// #456: ;Each digit is formed in turn starting with the least significant.
// #457: ;
// #458: ;Registers used s0,s2,s3,s4,s5,s6,s7,s8,s9,sA,sB,sC,sD,sE,sF
// #459: ;
// @094 #460: [integer_to_BCD]
00e0a // @094 #460: LOAD(sE,10) ;10 digits to be formed from value upto 4294967295
00f11 // @095 #461: LOAD(sF,decimal0) ;pointer for LS-Digit
// @096 #462: [int_to_BCD_loop]
3009c // @096 #462: CALL(divide_32bit_by_10)
2f1f0 // @097 #463: STORE(s1,sF) ;remainder becomes digit value
18f01 // @098 #464: ADD(sF,1) ;move to next most significant digit
1ce01 // @099 #465: SUB(sE,1) ;one less digit to compute
35496 // @09a #466: JUMP(NZ,int_to_BCD_loop)
2a000 // @09b #467: RETURN
// #468: ;
// #469: ;Divide 32-bit binary integer by 10
// #470: ;
// #471: ;The value to be divided is held in register set [s5,s4,s3,s2]
// #472: ;and this is where the result is returned to.
// #473: ;
// #474: ;At then end of the integer division the remainder in the range 0 to 9
// #475: ;will be in register s1.
// #476: ;
// #477: ;Registers used s0, s2,s3,s4,s5,s6,s7,s8,s9,sA,sB,sC,sD
// #478: ;
// @09c #479: [divide_32bit_by_10]
01a20 // @09c #479: LOAD(sA,s2) ;copy input value to set [sD,sC,sB,sA]
01b30 // @09d #480: LOAD(sB,s3)
01c40 // @09e #481: LOAD(sC,s4)
01d50 // @09f #482: LOAD(sD,s5)
00200 // @0a0 #483: LOAD(s2,0) ;clear result
00300 // @0a1 #484: LOAD(s3,0)
00400 // @0a2 #485: LOAD(s4,0)
00500 // @0a3 #486: LOAD(s5,0)
009a0 // @0a4 #487: LOAD(s9,A0) ;initialise '10' value into msb's of set [s9,s8,s7,s6]
00800 // @0a5 #488: LOAD(s8,0)
00700 // @0a6 #489: LOAD(s7,0)
00600 // @0a7 #490: LOAD(s6,0)
0001d // @0a8 #491: LOAD(s0,29) ;29 subtract and shift iterations to be performed
// @0a9 #492: [div10_loop]
1da60 // @0a9 #492: SUB(sA,s6) ;perform 32-bit subtract [sD,sC,sB,sA]-[s9,s8,s7,s6]
1fb70 // @0aa #493: SUBCY(sB,s7)