test8.lst

hrisc cpu

CCS PCW C Compiler, Version 2.636, 5783

               Filename: D:\PIC_CO~1\PICC\SRC\TEST8.LST

               ROM used: 244 (24%)
                         244 (24%) including unused fragments
               RAM used: 16 (44%) at main() level
                         28 (78%) worst case
               Stack:    2 worst case (1 in main + 1 for interrupts)

0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   05F
0003:  NOP
....................  // Test8 
.................... // 
.................... // This tests out the risc16f84 to see if it can service interrupts. 
.................... // In particular, the interrupts will occur during subroutines, so 
.................... // the stack will be tested beyond one level. 
.................... // Periodic interrupts increment a byte counter, which is displayed 
.................... // on the LEDs, while the colored boxes are being printed to the LCD 
.................... // panel. 
.................... // 
.................... // Author: John Clayton 
.................... // Date  : 11/25/02 
....................  
.................... #device PIC16C84 
.................... #byte stat_reg     = 0x03 
.................... #byte addr_lo      = 0x05 
.................... #byte addr_hi      = 0x06 
.................... #byte data         = 0x08 
.................... #byte w_temp       = 0x0c 
.................... #byte stat_temp    = 0x0d 
.................... #byte addr_lo_temp = 0x0e 
.................... #byte addr_hi_temp = 0x0f 
....................  
.................... // Global type variables 
.................... int int_count; 
....................  
.................... // This functions plots a single pixel at coordinates (x,y) 
.................... // color should range from 0..7. 
.................... void plot(unsigned int x, unsigned int y, unsigned int color) 
.................... { 
.................... addr_hi = (y>>1) | 0x40; 
*
002E:  MOVF   24,W
002F:  MOVWF  0C
0030:  BCF    03,0
0031:  RRF    0C,F
0032:  MOVF   0C,W
0033:  IORLW  40
0034:  MOVWF  06
.................... addr_lo = x | (y<<7); 
0035:  MOVF   24,W
0036:  MOVWF  0C
0037:  SWAPF  0C,F
0038:  RLF    0C,F
0039:  RLF    0C,F
003A:  RLF    0C,F
003B:  MOVLW  80
003C:  ANDWF  0C,F
003D:  MOVF   0C,W
003E:  IORWF  23,W
003F:  MOVWF  05
.................... data = color; 
0040:  MOVF   25,W
0041:  MOVWF  08
.................... } 
....................  
.................... void fill_block(unsigned int x1, 
....................                 unsigned int y1, 
....................                 unsigned int x2, 
....................                 unsigned int y2, 
....................                 unsigned int color) 
.................... { 
.................... int i,j; 
....................  
.................... for (i=x1;i<x2;i++) 
*
001C:  MOVF   1C,W
001D:  MOVWF  21
001E:  MOVF   1E,W
001F:  SUBWF  21,W
0020:  BTFSC  03,0
0021:  GOTO   046
....................   for (j=y1;j<y2;j++) 
0022:  MOVF   1D,W
0023:  MOVWF  22
0024:  MOVF   1F,W
0025:  SUBWF  22,W
0026:  BTFSC  03,0
0027:  GOTO   044
....................     plot (i,j,color); 
0028:  MOVF   21,W
0029:  MOVWF  23
002A:  MOVF   22,W
002B:  MOVWF  24
002C:  MOVF   20,W
002D:  MOVWF  25
*
0042:  INCF   22,F
0043:  GOTO   024
0044:  INCF   21,F
0045:  GOTO   01E
0046:  RETLW  00
.................... } 
....................  
.................... void show_leds(unsigned int value) 
.................... { 
.................... addr_hi = 0xff; 
*
000E:  MOVLW  FF
000F:  MOVWF  06
.................... addr_lo = 0x07; 
0010:  MOVLW  07
0011:  MOVWF  05
.................... data = value; 
0012:  MOVF   27,W
0013:  MOVWF  08
.................... } 
....................  
.................... // This is an interrupt service routine 
.................... // #int_default -- this directive causes the compiler to produce 
.................... // code for saving registers and "cleanup."  It is not working 
.................... // too well. 
....................  
.................... #int_global 
.................... void isr1() 
.................... { 
....................   // Save the 'w' register, so that the ISR will not destroy 
....................   // any work in progress using the 'w' register at the time 
....................   // the interrupt occurred. 
....................   // Also, save the status register 
....................   // Also, save the aux address bus values 
....................   #asm 
....................     movwf w_temp 
*
0004:  MOVWF  0C
....................     movf  stat_reg,w 
0005:  MOVF   03,W
....................     movwf stat_temp 
0006:  MOVWF  0D
....................     movf  addr_hi,w 
0007:  MOVF   06,W
....................     movwf addr_hi_temp 
0008:  MOVWF  0F
....................     movf  addr_lo,w 
0009:  MOVF   05,W
....................     movwf addr_lo_temp 
....................   #endasm 
000A:  MOVWF  0E
....................   show_leds(++int_count); 
000B:  INCF   11,F
000C:  MOVF   11,W
000D:  MOVWF  27
....................   // Restore the contents of the 'w' register and status register 
....................   #asm 
....................     movf  addr_lo_temp,w 
*
0014:  MOVF   0E,W
....................     movwf addr_lo 
0015:  MOVWF  05
....................     movf  addr_hi_temp,w 
0016:  MOVF   0F,W
....................     movwf addr_hi 
0017:  MOVWF  06
....................     movf  stat_temp,w 
0018:  MOVF   0D,W
....................     movwf stat_reg 
0019:  MOVWF  03
....................     movf  w_temp,w 
....................   #endasm 
001A:  MOVF   0C,W
001B:  RETFIE
.................... } 
....................  
.................... int pn_sequence(unsigned int value) 
.................... // Takes a PN sequence value, and produces the next value... 
.................... { 
.................... return((value << 1) + (((value>>2) ^ (value>>7))&0x01)); 
*
0047:  MOVF   1C,W
0048:  MOVWF  1D
0049:  BCF    03,0
004A:  RLF    1D,F
004B:  MOVF   1C,W
004C:  MOVWF  1E
004D:  RRF    1E,F
004E:  RRF    1E,F
004F:  MOVLW  3F
0050:  ANDWF  1E,F
0051:  MOVF   1C,W
0052:  MOVWF  0C
0053:  SWAPF  0C,F
0054:  RRF    0C,F
0055:  RRF    0C,F
0056:  RRF    0C,F
0057:  MOVLW  01
0058:  ANDWF  0C,F
0059:  MOVF   0C,W
005A:  XORWF  1E,W
005B:  ANDLW  01
005C:  ADDWF  1D,W
005D:  MOVWF  0D
005E:  RETLW  00
.................... } 
....................  
.................... main() { 
.................... int rand; 
.................... int a, x1,x2,y1,y2,color,temp; 
.................... long b; 
005F:  CLRF   04
0060:  CLRF   03
....................  
.................... // Clear the screen 
....................   fill_block(0,0,128,96,0); 
0061:  CLRF   1C
0062:  CLRF   1D
0063:  MOVLW  80
0064:  MOVWF  1E
0065:  MOVLW  60
0066:  MOVWF  1F
0067:  CLRF   20
0068:  CALL   01C
....................  
.................... // Initialize the PN generator with a seed... 
.................... rand = 0xf0; 
0069:  MOVLW  F0
006A:  MOVWF  12
....................  
.................... // Enable the interrupts 
....................   #asm 
....................  
....................     bsf 0x0b,4        // set the interrupt flag 
006B:  BSF    0B,4
....................     bsf 0x0b,7        // set the GIE 
....................   #endasm 
006C:  BSF    0B,7
....................  
.................... while (1) { 
....................   rand = pn_sequence(rand); 
006D:  MOVF   12,W
006E:  MOVWF  1C
006F:  CALL   047
0070:  MOVF   0D,W
0071:  MOVWF  12
....................   x1 = rand; 
0072:  MOVF   12,W
0073:  MOVWF  14
....................   rand = pn_sequence(rand); 
0074:  MOVF   12,W
0075:  MOVWF  1C
0076:  CALL   047
0077:  MOVF   0D,W
0078:  MOVWF  12
....................   x2 = rand; 
0079:  MOVF   12,W
007A:  MOVWF  15
....................   rand = pn_sequence(rand); 
007B:  MOVF   12,W
007C:  MOVWF  1C
007D:  CALL   047
007E:  MOVF   0D,W
007F:  MOVWF  12
....................   y1 = rand; 
0080:  MOVF   12,W
0081:  MOVWF  16
....................   rand = pn_sequence(rand); 
0082:  MOVF   12,W
0083:  MOVWF  1C
0084:  CALL   047
0085:  MOVF   0D,W
0086:  MOVWF  12
....................   y2 = rand; 
0087:  MOVF   12,W
0088:  MOVWF  17
....................   rand = pn_sequence(rand); 
0089:  MOVF   12,W
008A:  MOVWF  1C
008B:  CALL   047
008C:  MOVF   0D,W
008D:  MOVWF  12
....................   color = rand; 
008E:  MOVF   12,W
008F:  MOVWF  18
....................   x1 = x1 >> 1; 
0090:  BCF    03,0
0091:  RRF    14,F
....................   x2 = x2 >> 1; 
0092:  BCF    03,0
0093:  RRF    15,F
....................   // Implement various checks to ensure that the coordinates 
....................   // are properly sized for drawing rectangles. 
....................   if (y1 > 95) y1 = 85; 
0094:  MOVLW  60
0095:  SUBWF  16,W
0096:  BTFSS  03,0
0097:  GOTO   09A
0098:  MOVLW  55
0099:  MOVWF  16
....................   if (y2 > 95) y2 = 95; 
009A:  MOVLW  60
009B:  SUBWF  17,W
009C:  BTFSS  03,0
009D:  GOTO   0A0
009E:  MOVLW  5F
009F:  MOVWF  17
....................   if (x1 > 126) x1 = 1; 
00A0:  MOVLW  7F
00A1:  SUBWF  14,W
00A2:  BTFSS  03,0
00A3:  GOTO   0A6
00A4:  MOVLW  01
00A5:  MOVWF  14
....................   if (x2 > 126) x2 = 120; 
00A6:  MOVLW  7F
00A7:  SUBWF  15,W
00A8:  BTFSS  03,0
00A9:  GOTO   0AC
00AA:  MOVLW  78
00AB:  MOVWF  15
....................   if (x1 == x2) x2+=10; 
00AC:  MOVF   15,W
00AD:  SUBWF  14,W
00AE:  BTFSS  03,2
00AF:  GOTO   0B3
00B0:  MOVLW  0A
00B1:  ADDWF  15,F
....................   else if (x1>x2) { 
00B2:  GOTO   0BD
00B3:  MOVF   14,W
00B4:  SUBWF  15,W
00B5:  BTFSC  03,0
00B6:  GOTO   0BD
.................... 	  temp = x1; 
00B7:  MOVF   14,W
00B8:  MOVWF  19
.................... 	  x1 = x2; 
00B9:  MOVF   15,W
00BA:  MOVWF  14
.................... 	  x2 = temp; 
00BB:  MOVF   19,W
00BC:  MOVWF  15
....................   } 
....................   if (y1 == y2) y2+= 12; 
00BD:  MOVF   17,W
00BE:  SUBWF  16,W
00BF:  BTFSS  03,2
00C0:  GOTO   0C4
00C1:  MOVLW  0C
00C2:  ADDWF  17,F
....................   else if (y1>y2) { 
00C3:  GOTO   0CE
00C4:  MOVF   16,W
00C5:  SUBWF  17,W
00C6:  BTFSC  03,0
00C7:  GOTO   0CE
.................... 	  temp = y1; 
00C8:  MOVF   16,W
00C9:  MOVWF  19
.................... 	  y1 = y2; 
00CA:  MOVF   17,W
00CB:  MOVWF  16
.................... 	  y2 = temp; 
00CC:  MOVF   19,W
00CD:  MOVWF  17
....................   } 
....................   fill_block(x1,y1,x2,y2,color); 
00CE:  MOVF   14,W
00CF:  MOVWF  1C
00D0:  MOVF   16,W
00D1:  MOVWF  1D
00D2:  MOVF   15,W
00D3:  MOVWF  1E
00D4:  MOVF   17,W
00D5:  MOVWF  1F
00D6:  MOVF   18,W
00D7:  MOVWF  20
00D8:  CALL   01C
....................   // Delay for debug 
....................   for (a=0;a<8;a++) 
00D9:  CLRF   13
00DA:  MOVLW  08
00DB:  SUBWF  13,W
00DC:  BTFSC  03,0
00DD:  GOTO   0F2
....................     for (b=0;b<16000;b++) {} 
00DE:  CLRF   1B
00DF:  CLRF   1A
00E0:  MOVLW  3E
00E1:  SUBWF  1B,W
00E2:  BTFSS  03,0
00E3:  GOTO   0EC
00E4:  MOVLW  3E
00E5:  SUBWF  1B,W
00E6:  BTFSS  03,2
00E7:  GOTO   0F0
00E8:  MOVLW  80
00E9:  SUBWF  1A,W
00EA:  BTFSC  03,0
00EB:  GOTO   0F0
00EC:  INCF   1A,F
00ED:  BTFSC  03,2
00EE:  INCF   1B,F
00EF:  GOTO   0E0
00F0:  INCF   13,F
00F1:  GOTO   0DA
....................  
.................... } // End of while loop 
00F2:  GOTO   06D
....................  
.................... } // End of main() 
00F3:  SLEEP