CCS PCW C Compiler, Version 3.059, 13114 Filename: c:\work\shutter_bring_up\pic_code\temp\ex_icd.LST ROM used: 2980 (38%) Largest free fragment is 2048 RAM used: 28 (16%) at main() level 59 (34%) worst case Stack: 5 worst case (3 in main + 2 for interrupts) * 0000: NOP 0001: MOVLW 08 0002: MOVWF 0A 0003: GOTO 2D2 0004: MOVWF 7F 0005: SWAPF 03,W 0006: BCF 03.5 0007: BCF 03.6 0008: MOVWF 21 0009: MOVF 0A,W 000A: MOVWF 20 000B: CLRF 0A 000C: MOVF 04,W 000D: MOVWF 22 000E: MOVF 77,W 000F: MOVWF 23 0010: MOVF 78,W 0011: MOVWF 24 0012: MOVF 79,W 0013: MOVWF 25 0014: MOVF 7A,W 0015: MOVWF 26 0016: MOVF 7B,W 0017: MOVWF 27 0018: BCF 03.7 0019: BCF 03.5 001A: BTFSS 0B.5 001B: GOTO 01E 001C: BTFSC 0B.2 001D: GOTO 031 001E: MOVF 22,W 001F: MOVWF 04 0020: MOVF 23,W 0021: MOVWF 77 0022: MOVF 24,W 0023: MOVWF 78 0024: MOVF 25,W 0025: MOVWF 79 0026: MOVF 26,W 0027: MOVWF 7A 0028: MOVF 27,W 0029: MOVWF 7B 002A: MOVF 20,W 002B: MOVWF 0A 002C: SWAPF 21,W 002D: MOVWF 03 002E: SWAPF 7F,F 002F: SWAPF 7F,W 0030: RETFIE 0031: BCF 0A.3 0032: BCF 0A.4 0033: GOTO 413 .................... #if defined(__PCM__) .................... #include <16f877.h> .................... //////// Standard Header file for the PIC16F877 device //////////////// .................... #device PIC16F877 .................... #list .................... .................... #device ICD=TRUE .................... #device ADC=10 .................... #fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT .................... #use delay(clock=4000000) * 06EB: MOVLW 3B 06EC: MOVWF 04 06ED: MOVF 00,W 06EE: BTFSC 03.2 06EF: GOTO 6FF 06F0: MOVLW 01 06F1: MOVWF 78 06F2: CLRF 77 06F3: DECFSZ 77,F 06F4: GOTO 6F3 06F5: DECFSZ 78,F 06F6: GOTO 6F2 06F7: MOVLW 4A 06F8: MOVWF 77 06F9: DECFSZ 77,F 06FA: GOTO 6F9 06FB: NOP 06FC: NOP 06FD: DECFSZ 00,F 06FE: GOTO 6F0 06FF: RETLW 00 .................... #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, ERRORS) * 0550: BTFSS 0C.5 0551: GOTO 550 0552: MOVF 18,W 0553: MOVWF 28 0554: MOVF 1A,W 0555: MOVWF 78 0556: BTFSS 28.1 0557: GOTO 55A 0558: BCF 18.4 0559: BSF 18.4 055A: NOP 055B: BSF 0A.3 055C: BCF 0A.4 055D: GOTO 33C (RETURN) .................... #endif .................... .................... /********************************** GLOBS ***********************************/ .................... .................... .................... int32 motor_position; .................... .................... /* .................... The motor_moving var is set to true if at least one encoder count was .................... read at sample time, otherwise it is false. .................... */ .................... .................... int motor_moving; .................... .................... int dir_state = 0; .................... int pwm_state = 0; .................... int run_state = 0; .................... .................... //temp var for int_rtcc status .................... int status_bit = 0; .................... .................... byte clock_ticks = 0; .................... byte seconds = 0; .................... .................... //#define TICKS_PER_SEC 61 .................... #define TICKS_PER_SEC 244 .................... .................... /********************************** GLOBS ***********************************/ .................... .................... int read_encoder() .................... { .................... int encoder_val; .................... //assert read signal .................... output_bit(PIN_E0, 0); * 0404: BCF 09.0 0405: BSF 03.5 0406: BCF 09.0 .................... //read encoder .................... encoder_val = input_d(); 0407: MOVLW FF 0408: MOVWF 08 0409: BCF 03.5 040A: MOVF 08,W 040B: MOVWF 55 .................... //de-assert read signal .................... output_bit(PIN_E0, 1); 040C: BSF 09.0 040D: BSF 03.5 040E: BCF 09.0 .................... return encoder_val; 040F: BCF 03.5 0410: MOVF 55,W 0411: MOVWF 78 0412: RETLW 00 .................... } .................... .................... void clear_encoder() .................... { .................... //use PSP CS for now .................... .................... //assert clear signal .................... output_bit(PIN_E2, 0); * 0462: BCF 09.2 0463: BSF 03.5 0464: BCF 09.2 .................... //de-assert clear signal .................... output_bit(PIN_E2, 1); 0465: BCF 03.5 0466: BSF 09.2 0467: BSF 03.5 0468: BCF 09.2 0469: BCF 03.5 .................... } .................... .................... #INT_RTCC .................... clock_isr() .................... { .................... // Update the actual position. This assumes that the position sensor is .................... // an 8 bit device and the actual position is 32 bits. The following .................... // code converts from 8 bit to 32 bit and handles roll-overs. .................... /* .................... motor_position += (read_encoder() - ((int8)motor_position)); .................... */ .................... int8 old_encoder; .................... int8 cur_encoder; .................... int8 encoder_delta; .................... .................... cur_encoder = read_encoder(); * 0413: CALL 404 0414: MOVF 78,W 0415: MOVWF 53 .................... old_encoder = (int8)motor_position; // get the lower 8 bits of the motor position 0416: MOVF 29,W 0417: MOVWF 52 .................... encoder_delta = cur_encoder - old_encoder; 0418: MOVF 52,W 0419: SUBWF 53,W 041A: MOVWF 54 .................... .................... if ( encoder_delta & 0xFF ) 041B: MOVF 54,W 041C: XORLW 00 041D: BTFSC 03.2 041E: GOTO 422 .................... motor_moving = TRUE; 041F: MOVLW 01 0420: MOVWF 2D .................... else 0421: GOTO 423 .................... motor_moving = FALSE; 0422: CLRF 2D .................... .................... //compiler is having trouble mixing 8 and 32 bit types .................... if ( encoder_delta & 0x80 ) 0423: MOVF 54,W 0424: ANDLW 80 0425: XORLW 00 0426: BTFSC 03.2 0427: GOTO 439 .................... motor_position -= (~encoder_delta + 0x01); 0428: MOVF 54,W 0429: XORLW FF 042A: ADDLW 01 042B: SUBWF 29,F 042C: MOVLW 00 042D: BTFSS 03.0 042E: MOVLW 01 042F: SUBWF 2A,F 0430: MOVLW 00 0431: BTFSS 03.0 0432: MOVLW 01 0433: SUBWF 2B,F 0434: MOVLW 00 0435: BTFSS 03.0 0436: MOVLW 01 0437: SUBWF 2C,F .................... else 0438: GOTO 447 .................... motor_position += encoder_delta; 0439: MOVF 54,W 043A: ADDWF 29,F 043B: MOVLW 00 043C: BTFSC 03.0 043D: MOVLW 01 043E: ADDWF 2A,F 043F: MOVLW 00 0440: BTFSC 03.0 0441: MOVLW 01 0442: ADDWF 2B,F 0443: MOVLW 00 0444: BTFSC 03.0 0445: MOVLW 01 0446: ADDWF 2C,F .................... .................... if ( (--clock_ticks) == 0 ) 0447: DECFSZ 32,F 0448: GOTO 45E .................... { .................... ++seconds; 0449: INCF 33,F .................... //debug toggle of pin C0 for int_rtcc status .................... status_bit = !status_bit; 044A: MOVF 31,F 044B: BTFSC 03.2 044C: GOTO 44F 044D: MOVLW 00 044E: GOTO 450 044F: MOVLW 01 0450: MOVWF 31 .................... output_bit(PIN_C0, status_bit); 0451: MOVF 31,F 0452: BTFSS 03.2 0453: GOTO 456 0454: BCF 07.0 0455: GOTO 457 0456: BSF 07.0 0457: BCF 34.0 0458: MOVF 34,W 0459: BSF 03.5 045A: MOVWF 07 .................... .................... clock_ticks = TICKS_PER_SEC; 045B: MOVLW F4 045C: BCF 03.5 045D: MOVWF 32 .................... } 045E: BCF 0B.2 045F: BCF 0A.3 0460: BCF 0A.4 0461: GOTO 01E .................... } .................... .................... void clear_timer() .................... { .................... set_rtcc(0); * 0700: CLRF 01 .................... clock_ticks = TICKS_PER_SEC; 0701: MOVLW F4 0702: MOVWF 32 .................... seconds = 0; 0703: CLRF 33 0704: RETLW 00 .................... } .................... .................... void show_version() .................... { .................... printf("Smart Shutter v 0.4\r\n"); * 0034: BCF 0A.0 0035: BCF 0A.1 0036: BCF 0A.2 0037: ADDWF 02,F 0038: RETLW 53 0039: RETLW 6D 003A: RETLW 61 003B: RETLW 72 003C: RETLW 74 003D: RETLW 20 003E: RETLW 53 003F: RETLW 68 0040: RETLW 75 0041: RETLW 74 0042: RETLW 74 0043: RETLW 65 0044: RETLW 72 0045: RETLW 20 0046: RETLW 76 0047: RETLW 20 0048: RETLW 30 0049: RETLW 2E 004A: RETLW 34 004B: RETLW 0D 004C: RETLW 0A 004D: RETLW 00 * 046F: CLRF 36 0470: MOVF 36,W 0471: CALL 034 0472: INCF 36,F 0473: BTFSS 0C.4 0474: GOTO 473 0475: MOVWF 19 0476: MOVLW 15 0477: SUBWF 36,W 0478: BTFSS 03.2 0479: GOTO 470 .................... printf("built on "); * 004E: BCF 0A.0 004F: BCF 0A.1 0050: BCF 0A.2 0051: ADDWF 02,F 0052: RETLW 62 0053: RETLW 75 0054: RETLW 69 0055: RETLW 6C 0056: RETLW 74 0057: RETLW 20 0058: RETLW 6F 0059: RETLW 6E 005A: RETLW 20 005B: RETLW 00 * 047A: CLRF 36 047B: MOVF 36,W 047C: CALL 04E 047D: INCF 36,F 047E: BTFSS 0C.4 047F: GOTO 47E 0480: MOVWF 19 0481: MOVLW 09 0482: SUBWF 36,W 0483: BTFSS 03.2 0484: GOTO 47B .................... printf(__DATE__); * 005C: BCF 0A.0 005D: BCF 0A.1 005E: BCF 0A.2 005F: ADDWF 02,F 0060: RETLW 31 0061: RETLW 31 0062: RETLW 2D 0063: RETLW 46 0064: RETLW 65 0065: RETLW 62 0066: RETLW 2D 0067: RETLW 30 0068: RETLW 32 0069: RETLW 00 * 0485: CLRF 36 0486: MOVF 36,W 0487: CALL 05C 0488: INCF 36,F 0489: BTFSS 0C.4 048A: GOTO 489 048B: MOVWF 19 048C: MOVLW 09 048D: SUBWF 36,W 048E: BTFSS 03.2 048F: GOTO 486 .................... printf("\r\n\n"); 0490: MOVLW 0D 0491: BTFSS 0C.4 0492: GOTO 491 0493: MOVWF 19 0494: MOVLW 0A 0495: BTFSS 0C.4 0496: GOTO 495 0497: MOVWF 19 0498: MOVLW 0A 0499: BTFSS 0C.4 049A: GOTO 499 049B: MOVWF 19 049C: BSF 0A.3 049D: BCF 0A.4 049E: GOTO 336 (RETURN) .................... } .................... .................... void get_motor_pos() .................... { * 05C2: CLRF 36 05C3: CLRF 37 .................... long value = 0; .................... .................... value = read_adc(); 05C4: BSF 1F.2 05C5: BTFSC 1F.2 05C6: GOTO 5C5 05C7: BSF 03.5 05C8: MOVF 1E,W 05C9: BCF 03.5 05CA: MOVWF 36 05CB: MOVF 1E,W 05CC: MOVWF 37 .................... printf("adc value = %ld\r\n", value); * 006A: BCF 0A.0 006B: BCF 0A.1 006C: BCF 0A.2 006D: ADDWF 02,F 006E: RETLW 61 006F: RETLW 64 0070: RETLW 63 0071: RETLW 20 0072: RETLW 76 0073: RETLW 61 0074: RETLW 6C 0075: RETLW 75 0076: RETLW 65 0077: RETLW 20 0078: RETLW 3D 0079: RETLW 20 007A: RETLW 25 007B: RETLW 6C 007C: RETLW 64 007D: RETLW 0D 007E: RETLW 0A 007F: RETLW 00 * 055E: MOVF 04,W 055F: MOVWF 40 0560: BTFSS 3A.7 0561: GOTO 56C 0562: MOVLW 2D 0563: BTFSS 0C.4 0564: GOTO 563 0565: MOVWF 19 0566: DECF 04,F 0567: COMF 39,F 0568: COMF 3A,F 0569: INCF 39,F 056A: BTFSC 03.2 056B: INCF 3A,F 056C: SWAPF 3A,W 056D: IORLW F0 056E: MOVWF 3C 056F: ADDWF 3C,F 0570: ADDLW E2 0571: MOVWF 3D 0572: ADDLW 32 0573: MOVWF 3F 0574: MOVF 3A,W 0575: ANDLW 0F 0576: ADDWF 3D,F 0577: ADDWF 3D,F 0578: ADDWF 3F,F 0579: ADDLW E9 057A: MOVWF 3E 057B: ADDWF 3E,F 057C: ADDWF 3E,F 057D: SWAPF 39,W 057E: ANDLW 0F 057F: ADDWF 3E,F 0580: ADDWF 3F,F 0581: RLF 3E,F 0582: RLF 3F,F 0583: COMF 3F,F 0584: RLF 3F,F 0585: MOVF 39,W 0586: ANDLW 0F 0587: ADDWF 3F,F 0588: RLF 3C,F 0589: MOVLW 07 058A: MOVWF 3B 058B: MOVLW 0A 058C: ADDWF 3F,F 058D: DECF 3E,F 058E: BTFSS 03.0 058F: GOTO 58C 0590: ADDWF 3E,F 0591: DECF 3D,F 0592: BTFSS 03.0 0593: GOTO 590 0594: ADDWF 3D,F 0595: DECF 3C,F 0596: BTFSS 03.0 0597: GOTO 594 0598: ADDWF 3C,F 0599: DECF 3B,F 059A: BTFSS 03.0 059B: GOTO 598 059C: MOVLW 3B 059D: MOVWF 04 059E: MOVLW 07 059F: ANDWF 40,W 05A0: ADDWF 04,F 05A1: MOVLW 3F 05A2: SUBWF 04,W 05A3: BTFSC 03.2 05A4: GOTO 5B9 05A5: MOVF 00,W 05A6: MOVWF 77 05A7: BTFSS 03.2 05A8: GOTO 5AF 05A9: BTFSC 40.4 05AA: GOTO 5B7 05AB: BTFSC 40.3 05AC: GOTO 5B1 05AD: MOVLW 20 05AE: GOTO 5B2 05AF: MOVLW 08 05B0: MOVWF 40 05B1: MOVLW 30 05B2: ADDWF 77,F 05B3: MOVF 77,W 05B4: BTFSS 0C.4 05B5: GOTO 5B4 05B6: MOVWF 19 05B7: INCF 04,F 05B8: GOTO 5A1 05B9: MOVF 00,W 05BA: MOVWF 77 05BB: MOVLW 30 05BC: ADDWF 77,F 05BD: MOVF 77,W 05BE: BTFSS 0C.4 05BF: GOTO 5BE 05C0: MOVWF 19 05C1: RETLW 00 * 05CD: CLRF 38 05CE: MOVF 38,W 05CF: CALL 06A 05D0: INCF 38,F 05D1: BTFSS 0C.4 05D2: GOTO 5D1 05D3: MOVWF 19 05D4: MOVLW 0C 05D5: SUBWF 38,W 05D6: BTFSS 03.2 05D7: GOTO 5CE 05D8: MOVLW 10 05D9: MOVWF 04 05DA: MOVF 37,W 05DB: MOVWF 3A 05DC: MOVF 36,W 05DD: MOVWF 39 05DE: CALL 55E 05DF: MOVLW 0D 05E0: BTFSS 0C.4 05E1: GOTO 5E0 05E2: MOVWF 19 05E3: MOVLW 0A 05E4: BTFSS 0C.4 05E5: GOTO 5E4 05E6: MOVWF 19 05E7: BSF 0A.3 05E8: BCF 0A.4 05E9: GOTO 384 (RETURN) .................... } .................... .................... void toggle_direction() .................... { .................... dir_state = !dir_state; * 05FF: MOVF 2E,F 0600: BTFSC 03.2 0601: GOTO 604 0602: MOVLW 00 0603: GOTO 605 0604: MOVLW 01 0605: MOVWF 2E .................... output_bit(PIN_B5, dir_state); 0606: MOVF 2E,F 0607: BTFSS 03.2 0608: GOTO 60B 0609: BCF 06.5 060A: GOTO 60C 060B: BSF 06.5 060C: BSF 03.5 060D: BCF 06.5 060E: BCF 03.5 060F: BSF 0A.3 0610: BCF 0A.4 0611: GOTO 38C (RETURN) .................... } .................... .................... void toggle_pwm() .................... { .................... pwm_state = !pwm_state; * 05EA: MOVF 2F,F 05EB: BTFSC 03.2 05EC: GOTO 5EF 05ED: MOVLW 00 05EE: GOTO 5F0 05EF: MOVLW 01 05F0: MOVWF 2F .................... output_bit(PIN_C2, pwm_state); 05F1: MOVF 2F,F 05F2: BTFSS 03.2 05F3: GOTO 5F6 05F4: BCF 07.2 05F5: GOTO 5F7 05F6: BSF 07.2 05F7: BCF 34.2 05F8: MOVF 34,W 05F9: BSF 03.5 05FA: MOVWF 07 05FB: BCF 03.5 05FC: BSF 0A.3 05FD: BCF 0A.4 05FE: GOTO 388 (RETURN) .................... } .................... .................... void toggle_run_sense() .................... { .................... run_state = !run_state; * 0612: MOVF 30,F 0613: BTFSC 03.2 0614: GOTO 617 0615: MOVLW 00 0616: GOTO 618 0617: MOVLW 01 0618: MOVWF 30 .................... output_bit(PIN_B4, run_state); 0619: MOVF 30,F 061A: BTFSS 03.2 061B: GOTO 61E 061C: BCF 06.4 061D: GOTO 61F 061E: BSF 06.4 061F: BSF 03.5 0620: BCF 06.4 0621: BCF 03.5 0622: BSF 0A.3 0623: BCF 0A.4 0624: GOTO 390 (RETURN) .................... } .................... .................... void show_io_state() .................... { .................... printf("--------------\r\n"); * 0680: MOVLW 0E 0681: MOVWF 36 0682: MOVLW 2D 0683: BTFSS 0C.4 0684: GOTO 683 0685: MOVWF 19 0686: DECFSZ 36,F 0687: GOTO 682 0688: MOVLW 0D 0689: BTFSS 0C.4 068A: GOTO 689 068B: MOVWF 19 068C: MOVLW 0A 068D: BTFSS 0C.4 068E: GOTO 68D 068F: MOVWF 19 .................... printf("dir_state = %d\r\n", dir_state); * 0080: BCF 0A.0 0081: BCF 0A.1 0082: BCF 0A.2 0083: ADDWF 02,F 0084: RETLW 64 0085: RETLW 69 0086: RETLW 72 0087: RETLW 5F 0088: RETLW 73 0089: RETLW 74 008A: RETLW 61 008B: RETLW 74 008C: RETLW 65 008D: RETLW 20 008E: RETLW 3D 008F: RETLW 20 0090: RETLW 25 0091: RETLW 64 0092: RETLW 0D 0093: RETLW 0A 0094: RETLW 00 * 063A: MOVLW 20 063B: MOVWF 78 063C: MOVF 37,W 063D: MOVWF 77 063E: BTFSS 37.7 063F: GOTO 646 0640: COMF 77,F 0641: INCF 77,F 0642: MOVF 77,W 0643: MOVWF 37 0644: MOVLW 2D 0645: MOVWF 78 0646: MOVF 78,W 0647: BTFSS 0C.4 0648: GOTO 647 0649: MOVWF 19 064A: BTFSC 38.0 064B: GOTO 665 064C: BTFSC 38.1 064D: GOTO 679 064E: MOVF 37,W 064F: MOVWF 3A 0650: MOVLW 64 0651: MOVWF 3B 0652: CALL 625 0653: MOVF 77,W 0654: MOVWF 37 0655: MOVF 78,W 0656: MOVLW 30 0657: BTFSS 03.2 0658: GOTO 65E 0659: BTFSC 38.2 065A: GOTO 665 065B: BTFSC 38.3 065C: MOVLW 20 065D: GOTO 660 065E: BCF 38.2 065F: BCF 38.3 0660: ADDWF 78,F 0661: MOVF 78,W 0662: BTFSS 0C.4 0663: GOTO 662 0664: MOVWF 19 0665: MOVF 37,W 0666: MOVWF 3A 0667: MOVLW 0A 0668: MOVWF 3B 0669: CALL 625 066A: MOVF 77,W 066B: MOVWF 37 066C: MOVF 78,W 066D: MOVLW 30 066E: BTFSS 03.2 066F: GOTO 674 0670: BTFSC 38.2 0671: GOTO 679 0672: BTFSC 38.3 0673: MOVLW 20 0674: ADDWF 78,F 0675: MOVF 78,W 0676: BTFSS 0C.4 0677: GOTO 676 0678: MOVWF 19 0679: MOVLW 30 067A: ADDWF 37,F 067B: MOVF 37,W 067C: BTFSS 0C.4 067D: GOTO 67C 067E: MOVWF 19 067F: RETLW 00 * 0690: CLRF 36 0691: MOVF 36,W 0692: CALL 080 0693: INCF 36,F 0694: BTFSS 0C.4 0695: GOTO 694 0696: MOVWF 19 0697: MOVLW 0C 0698: SUBWF 36,W 0699: BTFSS 03.2 069A: GOTO 691 069B: MOVF 2E,W 069C: MOVWF 37 069D: MOVLW 0C 069E: MOVWF 38 069F: CALL 63A 06A0: MOVLW 0D 06A1: BTFSS 0C.4 06A2: GOTO 6A1 06A3: MOVWF 19 06A4: MOVLW 0A 06A5: BTFSS 0C.4 06A6: GOTO 6A5 06A7: MOVWF 19 .................... printf("pwm_state = %d\r\n", pwm_state); * 0095: BCF 0A.0 0096: BCF 0A.1 0097: BCF 0A.2 0098: ADDWF 02,F 0099: RETLW 70 009A: RETLW 77 009B: RETLW 6D 009C: RETLW 5F 009D: RETLW 73 009E: RETLW 74 009F: RETLW 61 00A0: RETLW 74 00A1: RETLW 65 00A2: RETLW 20 00A3: RETLW 3D 00A4: RETLW 20 00A5: RETLW 25 00A6: RETLW 64 00A7: RETLW 0D 00A8: RETLW 0A 00A9: RETLW 00 * 06A8: CLRF 36 06A9: MOVF 36,W 06AA: CALL 095 06AB: INCF 36,F 06AC: BTFSS 0C.4 06AD: GOTO 6AC 06AE: MOVWF 19 06AF: MOVLW 0C 06B0: SUBWF 36,W 06B1: BTFSS 03.2 06B2: GOTO 6A9 06B3: MOVF 2F,W 06B4: MOVWF 37 06B5: MOVLW 0C 06B6: MOVWF 38 06B7: CALL 63A 06B8: MOVLW 0D 06B9: BTFSS 0C.4 06BA: GOTO 6B9 06BB: MOVWF 19 06BC: MOVLW 0A 06BD: BTFSS 0C.4 06BE: GOTO 6BD 06BF: MOVWF 19 .................... printf("run_state = %d\r\n", run_state); * 00AA: BCF 0A.0 00AB: BCF 0A.1 00AC: BCF 0A.2 00AD: ADDWF 02,F 00AE: RETLW 72 00AF: RETLW 75 00B0: RETLW 6E 00B1: RETLW 5F 00B2: RETLW 73 00B3: RETLW 74 00B4: RETLW 61 00B5: RETLW 74 00B6: RETLW 65 00B7: RETLW 20 00B8: RETLW 3D 00B9: RETLW 20 00BA: RETLW 25 00BB: RETLW 64 00BC: RETLW 0D 00BD: RETLW 0A 00BE: RETLW 00 * 06C0: CLRF 36 06C1: MOVF 36,W 06C2: CALL 0AA 06C3: INCF 36,F 06C4: BTFSS 0C.4 06C5: GOTO 6C4 06C6: MOVWF 19 06C7: MOVLW 0C 06C8: SUBWF 36,W 06C9: BTFSS 03.2 06CA: GOTO 6C1 06CB: MOVF 30,W 06CC: MOVWF 37 06CD: MOVLW 0C 06CE: MOVWF 38 06CF: CALL 63A 06D0: MOVLW 0D 06D1: BTFSS 0C.4 06D2: GOTO 6D1 06D3: MOVWF 19 06D4: MOVLW 0A 06D5: BTFSS 0C.4 06D6: GOTO 6D5 06D7: MOVWF 19 .................... printf("--------------\r\n"); 06D8: MOVLW 0E 06D9: MOVWF 36 06DA: MOVLW 2D 06DB: BTFSS 0C.4 06DC: GOTO 6DB 06DD: MOVWF 19 06DE: DECFSZ 36,F 06DF: GOTO 6DA 06E0: MOVLW 0D 06E1: BTFSS 0C.4 06E2: GOTO 6E1 06E3: MOVWF 19 06E4: MOVLW 0A 06E5: BTFSS 0C.4 06E6: GOTO 6E5 06E7: MOVWF 19 06E8: BSF 0A.3 06E9: BCF 0A.4 06EA: GOTO 394 (RETURN) .................... } .................... .................... #define OPEN_POS 800 .................... #define CLOSE_POS 200 .................... #define TIME_OUT 4 .................... .................... void run_shutter(int val) .................... { .................... if ( val == 0 ) * 0705: MOVF 36,F 0706: BTFSS 03.2 0707: GOTO 770 .................... { .................... /* if shutter is closed get out */ .................... if ( read_adc() < CLOSE_POS ) 0708: BSF 1F.2 0709: BTFSC 1F.2 070A: GOTO 709 070B: MOVF 1E,W 070C: MOVWF 7A 070D: BSF 03.5 070E: MOVF 1E,W 070F: BCF 03.5 0710: MOVWF 37 0711: MOVF 1E,W 0712: MOVWF 38 0713: MOVF 38,F 0714: BTFSS 03.2 0715: GOTO 71A 0716: MOVF 37,W 0717: SUBLW C7 0718: BTFSC 03.0 .................... return; 0719: GOTO 7DD .................... .................... /* set direction to close */ .................... dir_state = 0; 071A: CLRF 2E .................... output_bit(PIN_B5, dir_state); 071B: MOVF 2E,F 071C: BTFSS 03.2 071D: GOTO 720 071E: BCF 06.5 071F: GOTO 721 0720: BSF 06.5 0721: BSF 03.5 0722: BCF 06.5 .................... /* start shutter motor */ .................... output_bit(PIN_B4, 1); 0723: BCF 03.5 0724: BSF 06.4 0725: BSF 03.5 0726: BCF 06.4 .................... delay_ms(20); 0727: MOVLW 14 0728: BCF 03.5 0729: MOVWF 3B 072A: CALL 6EB .................... output_float(PIN_B4); 072B: BSF 03.5 072C: BSF 06.4 .................... .................... /* clear system timer as shutter open and close is timed */ .................... clear_timer(); 072D: BCF 03.5 072E: CALL 700 .................... .................... while (read_adc() > CLOSE_POS) 072F: BSF 1F.2 0730: BTFSC 1F.2 0731: GOTO 730 0732: MOVF 1E,W 0733: MOVWF 7A 0734: BSF 03.5 0735: MOVF 1E,W 0736: BCF 03.5 0737: MOVWF 37 0738: MOVF 1E,W 0739: MOVWF 38 073A: MOVF 38,F 073B: BTFSS 03.2 073C: GOTO 741 073D: MOVF 37,W 073E: SUBLW C8 073F: BTFSC 03.0 0740: GOTO 76B .................... { .................... /*wait for shutter to close*/ .................... if ( seconds > (TIME_OUT - 1) ) 0741: MOVF 33,W 0742: SUBLW 03 0743: BTFSC 03.0 0744: GOTO 755 .................... { .................... printf("\r\n_err shutter close timed out\r\n"); * 00BF: BCF 0A.0 00C0: BCF 0A.1 00C1: BCF 0A.2 00C2: ADDWF 02,F 00C3: RETLW 0D 00C4: RETLW 0A 00C5: RETLW 5F 00C6: RETLW 65 00C7: RETLW 72 00C8: RETLW 72 00C9: RETLW 20 00CA: RETLW 73 00CB: RETLW 68 00CC: RETLW 75 00CD: RETLW 74 00CE: RETLW 74 00CF: RETLW 65 00D0: RETLW 72 00D1: RETLW 20 00D2: RETLW 63 00D3: RETLW 6C 00D4: RETLW 6F 00D5: RETLW 73 00D6: RETLW 65 00D7: RETLW 20 00D8: RETLW 74 00D9: RETLW 69 00DA: RETLW 6D 00DB: RETLW 65 00DC: RETLW 64 00DD: RETLW 20 00DE: RETLW 6F 00DF: RETLW 75 00E0: RETLW 74 00E1: RETLW 0D 00E2: RETLW 0A 00E3: RETLW 00 * 0745: CLRF 37 0746: MOVF 37,W 0747: CALL 0BF 0748: INCF 37,F 0749: BTFSS 0C.4 074A: GOTO 749 074B: MOVWF 19 074C: MOVLW 20 074D: SUBWF 37,W 074E: BTFSS 03.2 074F: GOTO 746 .................... /* stop shutter motor */ .................... output_bit(PIN_B4, 0); 0750: BCF 06.4 0751: BSF 03.5 0752: BCF 06.4 .................... break; 0753: BCF 03.5 0754: GOTO 76B .................... } .................... .................... if ( !input(PIN_B4) ) 0755: BSF 03.5 0756: BSF 06.4 0757: BCF 03.5 0758: BTFSC 06.4 0759: GOTO 76A .................... { .................... /* set run_sense low */ .................... output_bit(PIN_B4, 0); 075A: BCF 06.4 075B: BSF 03.5 075C: BCF 06.4 .................... printf("\r\n_err shutter close current trip\r\n"); * 00E4: BCF 0A.0 00E5: BCF 0A.1 00E6: BCF 0A.2 00E7: ADDLW EB 00E8: BTFSC 03.0 00E9: INCF 0A,F 00EA: MOVWF 02 00EB: RETLW 0D 00EC: RETLW 0A 00ED: RETLW 5F 00EE: RETLW 65 00EF: RETLW 72 00F0: RETLW 72 00F1: RETLW 20 00F2: RETLW 73 00F3: RETLW 68 00F4: RETLW 75 00F5: RETLW 74 00F6: RETLW 74 00F7: RETLW 65 00F8: RETLW 72 00F9: RETLW 20 00FA: RETLW 63 00FB: RETLW 6C 00FC: RETLW 6F 00FD: RETLW 73 00FE: RETLW 65 00FF: RETLW 20 0100: RETLW 63 0101: RETLW 75 0102: RETLW 72 0103: RETLW 72 0104: RETLW 65 0105: RETLW 6E 0106: RETLW 74 0107: RETLW 20 0108: RETLW 74 0109: RETLW 72 010A: RETLW 69 010B: RETLW 70 010C: RETLW 0D 010D: RETLW 0A 010E: RETLW 00 * 075D: BCF 03.5 075E: CLRF 37 075F: MOVF 37,W 0760: CALL 0E4 0761: INCF 37,F 0762: BTFSS 0C.4 0763: GOTO 762 0764: MOVWF 19 0765: MOVLW 23 0766: SUBWF 37,W 0767: BTFSS 03.2 0768: GOTO 75F .................... break; 0769: GOTO 76B .................... } .................... } 076A: GOTO 72F .................... .................... /* stop shutter motor */ .................... output_bit(PIN_B4, 0); 076B: BCF 06.4 076C: BSF 03.5 076D: BCF 06.4 .................... .................... } .................... else 076E: BCF 03.5 076F: GOTO 7DD .................... { .................... .................... /* if shutter is opened get out */ .................... if ( read_adc() > OPEN_POS ) 0770: BSF 1F.2 0771: BTFSC 1F.2 0772: GOTO 771 0773: MOVF 1E,W 0774: MOVWF 7A 0775: BSF 03.5 0776: MOVF 1E,W 0777: BCF 03.5 0778: MOVWF 37 0779: MOVF 1E,W 077A: MOVWF 38 077B: SUBLW 02 077C: BTFSC 03.0 077D: GOTO 785 077E: XORLW FF 077F: BTFSS 03.2 0780: GOTO 784 0781: MOVF 37,W 0782: SUBLW 20 0783: BTFSS 03.0 .................... return; 0784: GOTO 7DD .................... .................... /* set direction to open */ .................... dir_state = 1; 0785: MOVLW 01 0786: MOVWF 2E .................... output_bit(PIN_B5, dir_state); 0787: MOVF 2E,F 0788: BTFSS 03.2 0789: GOTO 78C 078A: BCF 06.5 078B: GOTO 78D 078C: BSF 06.5 078D: BSF 03.5 078E: BCF 06.5 .................... /* start shutter motor */ .................... output_bit(PIN_B4, 1); 078F: BCF 03.5 0790: BSF 06.4 0791: BSF 03.5 0792: BCF 06.4 .................... delay_ms(20); 0793: MOVLW 14 0794: BCF 03.5 0795: MOVWF 3B 0796: CALL 6EB .................... output_float(PIN_B4); 0797: BSF 03.5 0798: BSF 06.4 .................... .................... /* clear system timer as shutter open and close is timed */ .................... clear_timer(); 0799: BCF 03.5 079A: CALL 700 .................... .................... while (read_adc() < OPEN_POS) 079B: BSF 1F.2 079C: BTFSC 1F.2 079D: GOTO 79C 079E: MOVF 1E,W 079F: MOVWF 7A 07A0: BSF 03.5 07A1: MOVF 1E,W 07A2: BCF 03.5 07A3: MOVWF 37 07A4: MOVF 1E,W 07A5: MOVWF 38 07A6: SUBLW 03 07A7: BTFSS 03.0 07A8: GOTO 7D9 07A9: BTFSS 03.2 07AA: GOTO 7AF 07AB: MOVF 37,W 07AC: SUBLW 1F 07AD: BTFSS 03.0 07AE: GOTO 7D9 .................... { .................... /*wait for shutter to close*/ .................... if ( seconds > (TIME_OUT - 1) ) 07AF: MOVF 33,W 07B0: SUBLW 03 07B1: BTFSC 03.0 07B2: GOTO 7C3 .................... { .................... printf("\r\n_err shutter open timed out\r\n"); * 010F: BSF 0A.0 0110: BCF 0A.1 0111: BCF 0A.2 0112: ADDWF 02,F 0113: RETLW 0D 0114: RETLW 0A 0115: RETLW 5F 0116: RETLW 65 0117: RETLW 72 0118: RETLW 72 0119: RETLW 20 011A: RETLW 73 011B: RETLW 68 011C: RETLW 75 011D: RETLW 74 011E: RETLW 74 011F: RETLW 65 0120: RETLW 72 0121: RETLW 20 0122: RETLW 6F 0123: RETLW 70 0124: RETLW 65 0125: RETLW 6E 0126: RETLW 20 0127: RETLW 74 0128: RETLW 69 0129: RETLW 6D 012A: RETLW 65 012B: RETLW 64 012C: RETLW 20 012D: RETLW 6F 012E: RETLW 75 012F: RETLW 74 0130: RETLW 0D 0131: RETLW 0A 0132: RETLW 00 * 07B3: CLRF 37 07B4: MOVF 37,W 07B5: CALL 10F 07B6: INCF 37,F 07B7: BTFSS 0C.4 07B8: GOTO 7B7 07B9: MOVWF 19 07BA: MOVLW 1F 07BB: SUBWF 37,W 07BC: BTFSS 03.2 07BD: GOTO 7B4 .................... /* stop shutter motor */ .................... output_bit(PIN_B4, 0); 07BE: BCF 06.4 07BF: BSF 03.5 07C0: BCF 06.4 .................... break; 07C1: BCF 03.5 07C2: GOTO 7D9 .................... } .................... .................... if ( !input(PIN_B4) ) 07C3: BSF 03.5 07C4: BSF 06.4 07C5: BCF 03.5 07C6: BTFSC 06.4 07C7: GOTO 7D8 .................... { .................... /* set run_sense low */ .................... output_bit(PIN_B4, 0); 07C8: BCF 06.4 07C9: BSF 03.5 07CA: BCF 06.4 .................... printf("\r\n_err shutter open current trip\r\n"); * 0133: BSF 0A.0 0134: BCF 0A.1 0135: BCF 0A.2 0136: ADDWF 02,F 0137: RETLW 0D 0138: RETLW 0A 0139: RETLW 5F 013A: RETLW 65 013B: RETLW 72 013C: RETLW 72 013D: RETLW 20 013E: RETLW 73 013F: RETLW 68 0140: RETLW 75 0141: RETLW 74 0142: RETLW 74 0143: RETLW 65 0144: RETLW 72 0145: RETLW 20 0146: RETLW 6F 0147: RETLW 70 0148: RETLW 65 0149: RETLW 6E 014A: RETLW 20 014B: RETLW 63 014C: RETLW 75 014D: RETLW 72 014E: RETLW 72 014F: RETLW 65 0150: RETLW 6E 0151: RETLW 74 0152: RETLW 20 0153: RETLW 74 0154: RETLW 72 0155: RETLW 69 0156: RETLW 70 0157: RETLW 0D 0158: RETLW 0A 0159: RETLW 00 * 07CB: BCF 03.5 07CC: CLRF 37 07CD: MOVF 37,W 07CE: CALL 133 07CF: INCF 37,F 07D0: BTFSS 0C.4 07D1: GOTO 7D0 07D2: MOVWF 19 07D3: MOVLW 22 07D4: SUBWF 37,W 07D5: BTFSS 03.2 07D6: GOTO 7CD .................... break; 07D7: GOTO 7D9 .................... } .................... .................... } 07D8: GOTO 79B .................... .................... /* stop shutter motor */ .................... output_bit(PIN_B4, 0); 07D9: BCF 06.4 07DA: BSF 03.5 07DB: BCF 06.4 07DC: BCF 03.5 .................... } 07DD: RETLW 00 .................... } .................... .................... void store_position() .................... { .................... long value; .................... .................... value = read_adc(); * 0800: BSF 1F.2 0801: BTFSC 1F.2 0802: GOTO 001 0803: BSF 03.5 0804: MOVF 1E,W 0805: BCF 03.5 0806: MOVWF 36 0807: MOVF 1E,W 0808: MOVWF 37 .................... // value = read_encoder(); .................... printf("storing adc value = %ld\r\n", value); * 015A: BSF 0A.0 015B: BCF 0A.1 015C: BCF 0A.2 015D: ADDWF 02,F 015E: RETLW 73 015F: RETLW 74 0160: RETLW 6F 0161: RETLW 72 0162: RETLW 69 0163: RETLW 6E 0164: RETLW 67 0165: RETLW 20 0166: RETLW 61 0167: RETLW 64 0168: RETLW 63 0169: RETLW 20 016A: RETLW 76 016B: RETLW 61 016C: RETLW 6C 016D: RETLW 75 016E: RETLW 65 016F: RETLW 20 0170: RETLW 3D 0171: RETLW 20 0172: RETLW 25 0173: RETLW 6C 0174: RETLW 64 0175: RETLW 0D 0176: RETLW 0A 0177: RETLW 00 * 0809: CLRF 38 080A: MOVF 38,W 080B: BCF 0A.3 080C: CALL 15A 080D: BSF 0A.3 080E: INCF 38,F 080F: BTFSS 0C.4 0810: GOTO 00F 0811: MOVWF 19 0812: MOVLW 14 0813: SUBWF 38,W 0814: BTFSS 03.2 0815: GOTO 00A 0816: MOVLW 10 0817: MOVWF 04 0818: MOVF 37,W 0819: MOVWF 3A 081A: MOVF 36,W 081B: MOVWF 39 081C: BCF 0A.3 081D: CALL 55E 081E: BSF 0A.3 081F: MOVLW 0D 0820: BTFSS 0C.4 0821: GOTO 020 0822: MOVWF 19 0823: MOVLW 0A 0824: BTFSS 0C.4 0825: GOTO 024 0826: MOVWF 19 .................... .................... /* store MSB of value */ .................... write_eeprom(0, make8(value, 1)); 0827: MOVF 37,W 0828: MOVWF 38 0829: BSF 03.6 082A: CLRF 0D 082B: CLRF 0F 082C: BCF 03.6 082D: MOVF 38,W 082E: BSF 03.6 082F: MOVWF 0C 0830: BSF 03.5 0831: BCF 0C.7 0832: BSF 0C.2 0833: BCF 03.5 0834: BCF 03.6 0835: MOVF 0B,W 0836: MOVWF 77 0837: BCF 0B.7 0838: MOVLW 55 0839: BSF 03.5 083A: BSF 03.6 083B: MOVWF 0D 083C: MOVLW AA 083D: MOVWF 0D 083E: BSF 0C.1 083F: BCF 03.5 0840: BCF 03.6 0841: BSF 03.5 0842: BSF 03.6 0843: BTFSS 0C.1 0844: GOTO 048 0845: BCF 03.5 0846: BCF 03.6 0847: GOTO 041 0848: BCF 0C.2 0849: MOVF 77,W 084A: BCF 03.5 084B: BCF 03.6 084C: IORWF 0B,F .................... /* store LSB of value */ .................... write_eeprom(1, make8(value, 0)); 084D: MOVF 36,W 084E: MOVWF 38 084F: MOVLW 01 0850: BSF 03.6 0851: MOVWF 0D 0852: CLRF 0F 0853: BCF 03.6 0854: MOVF 38,W 0855: BSF 03.6 0856: MOVWF 0C 0857: BSF 03.5 0858: BCF 0C.7 0859: BSF 0C.2 085A: BCF 03.5 085B: BCF 03.6 085C: MOVF 0B,W 085D: MOVWF 77 085E: BCF 0B.7 085F: MOVLW 55 0860: BSF 03.5 0861: BSF 03.6 0862: MOVWF 0D 0863: MOVLW AA 0864: MOVWF 0D 0865: BSF 0C.1 0866: BCF 03.5 0867: BCF 03.6 0868: BSF 03.5 0869: BSF 03.6 086A: BTFSS 0C.1 086B: GOTO 06F 086C: BCF 03.5 086D: BCF 03.6 086E: GOTO 068 086F: BCF 0C.2 0870: MOVF 77,W 0871: BCF 03.5 0872: BCF 03.6 0873: IORWF 0B,F 0874: BSF 0A.3 0875: BCF 0A.4 0876: GOTO 3A2 (RETURN) .................... } .................... .................... void read_position() .................... { .................... long value; .................... .................... value = make16(read_eeprom(0), read_eeprom(1)); 0877: BSF 03.6 0878: CLRF 0D 0879: CLRF 0F 087A: BSF 03.5 087B: BCF 0C.7 087C: BSF 0C.0 087D: BCF 03.5 087E: MOVF 0C,W 087F: BCF 03.6 0880: MOVWF 38 0881: MOVLW 01 0882: BSF 03.6 0883: MOVWF 0D 0884: CLRF 0F 0885: BSF 03.5 0886: BCF 0C.7 0887: BSF 0C.0 0888: BCF 03.5 0889: MOVF 0C,W 088A: BCF 03.6 088B: MOVWF 39 088C: MOVF 38,W 088D: MOVWF 37 088E: MOVF 39,W 088F: MOVWF 36 .................... .................... printf("read value = %ld from eeprom\r\n", value); * 0178: BSF 0A.0 0179: BCF 0A.1 017A: BCF 0A.2 017B: ADDWF 02,F 017C: RETLW 72 017D: RETLW 65 017E: RETLW 61 017F: RETLW 64 0180: RETLW 20 0181: RETLW 76 0182: RETLW 61 0183: RETLW 6C 0184: RETLW 75 0185: RETLW 65 0186: RETLW 20 0187: RETLW 3D 0188: RETLW 20 0189: RETLW 25 018A: RETLW 6C 018B: RETLW 64 018C: RETLW 20 018D: RETLW 66 018E: RETLW 72 018F: RETLW 6F 0190: RETLW 6D 0191: RETLW 20 0192: RETLW 65 0193: RETLW 65 0194: RETLW 70 0195: RETLW 72 0196: RETLW 6F 0197: RETLW 6D 0198: RETLW 0D 0199: RETLW 0A 019A: RETLW 00 * 0890: CLRF 38 0891: MOVF 38,W 0892: BCF 0A.3 0893: CALL 178 0894: BSF 0A.3 0895: INCF 38,F 0896: BTFSS 0C.4 0897: GOTO 096 0898: MOVWF 19 0899: MOVLW 0D 089A: SUBWF 38,W 089B: BTFSS 03.2 089C: GOTO 091 089D: MOVLW 10 089E: MOVWF 04 089F: MOVF 37,W 08A0: MOVWF 3A 08A1: MOVF 36,W 08A2: MOVWF 39 08A3: BCF 0A.3 08A4: CALL 55E 08A5: BSF 0A.3 08A6: MOVLW 10 08A7: MOVWF 39 08A8: MOVF 39,W 08A9: BCF 0A.3 08AA: CALL 178 08AB: BSF 0A.3 08AC: INCF 39,F 08AD: BTFSS 0C.4 08AE: GOTO 0AD 08AF: MOVWF 19 08B0: MOVLW 1E 08B1: SUBWF 39,W 08B2: BTFSS 03.2 08B3: GOTO 0A8 08B4: BSF 0A.3 08B5: BCF 0A.4 08B6: GOTO 3A4 (RETURN) .................... } .................... .................... void motor_pos() .................... { .................... // Update the actual position. This assumes that the position sensor is .................... // an 8 bit device and the actual position is 32 bits. The following .................... // code converts from 8 bit to 32 bit and handles roll-overs. .................... /* .................... motor_position += (read_encoder() - ((int8)motor_position)); .................... */ .................... .................... /* .................... int8 old_encoder; .................... int8 cur_encoder; .................... int8 encoder_delta; .................... .................... cur_encoder = read_encoder(); .................... old_encoder = (int8)motor_position; // get the lower 8 bits of the motor position .................... encoder_delta = cur_encoder - old_encoder; .................... .................... puts("------------------------------------- 4\r\n"); .................... printf("cur_encoder = %X %d\r\n", cur_encoder, cur_encoder); .................... printf("old_encoder = %X %d\r\n", old_encoder, old_encoder); .................... printf("encoder_delta = %X %d\r\n", encoder_delta, encoder_delta); .................... .................... //compiler is having trouble mixing 8 and 32 bit types .................... if (encoder_delta & 0x80) .................... { .................... puts("encoder_delta minus\r\n"); .................... motor_position -= (~encoder_delta + 0x01); .................... .................... } .................... else .................... { .................... puts("encoder_delta plus\r\n"); .................... motor_position += encoder_delta; .................... .................... } .................... .................... */ .................... printf("motor_position = %ld\r\n", motor_position); * 019B: BSF 0A.0 019C: BCF 0A.1 019D: BCF 0A.2 019E: ADDWF 02,F 019F: RETLW 6D 01A0: RETLW 6F 01A1: RETLW 74 01A2: RETLW 6F 01A3: RETLW 72 01A4: RETLW 5F 01A5: RETLW 70 01A6: RETLW 6F 01A7: RETLW 73 01A8: RETLW 69 01A9: RETLW 74 01AA: RETLW 69 01AB: RETLW 6F 01AC: RETLW 6E 01AD: RETLW 20 01AE: RETLW 3D 01AF: RETLW 20 01B0: RETLW 25 01B1: RETLW 6C 01B2: RETLW 64 01B3: RETLW 0D 01B4: RETLW 0A 01B5: RETLW 00 * 08F9: MOVF 04,W 08FA: MOVWF 3F 08FB: BTFSS 3E.7 08FC: GOTO 10C 08FD: MOVLW 2D 08FE: BTFSS 0C.4 08FF: GOTO 0FE 0900: MOVWF 19 0901: COMF 3B,F 0902: COMF 3C,F 0903: COMF 3D,F 0904: COMF 3E,F 0905: INCF 3B,F 0906: BTFSC 03.2 0907: INCF 3C,F 0908: BTFSC 03.2 0909: INCF 3D,F 090A: BTFSC 03.2 090B: INCF 3E,F 090C: MOVLW 3B 090D: MOVWF 44 090E: MOVLW 9A 090F: MOVWF 43 0910: MOVLW CA 0911: MOVWF 42 0912: CLRF 41 0913: MOVLW 0A 0914: MOVWF 40 0915: MOVF 3E,W 0916: MOVWF 48 0917: MOVF 3D,W 0918: MOVWF 47 0919: MOVF 3C,W 091A: MOVWF 46 091B: MOVF 3B,W 091C: MOVWF 45 091D: MOVF 44,W 091E: MOVWF 4C 091F: MOVF 43,W 0920: MOVWF 4B 0921: MOVF 42,W 0922: MOVWF 4A 0923: MOVF 41,W 0924: MOVWF 49 0925: CALL 0B7 0926: MOVF 00,W 0927: MOVWF 3B 0928: INCF 04,F 0929: MOVF 00,W 092A: MOVWF 3C 092B: INCF 04,F 092C: MOVF 00,W 092D: MOVWF 3D 092E: INCF 04,F 092F: MOVF 00,W 0930: MOVWF 3E 0931: MOVLW FD 0932: ADDWF 04,F 0933: MOVF 77,F 0934: BTFSS 03.2 0935: GOTO 148 0936: MOVF 40,W 0937: XORLW 01 0938: BTFSC 03.2 0939: GOTO 148 093A: MOVF 3F,W 093B: BTFSC 03.2 093C: GOTO 149 093D: ANDLW 0F 093E: SUBWF 40,W 093F: BTFSC 03.2 0940: GOTO 143 0941: BTFSC 03.0 0942: GOTO 14F 0943: MOVLW F0 0944: BTFSC 3F.6 0945: MOVLW 00 0946: MOVWF 77 0947: GOTO 149 0948: CLRF 3F 0949: MOVLW 30 094A: ADDWF 77,F 094B: MOVF 77,W 094C: BTFSS 0C.4 094D: GOTO 14C 094E: MOVWF 19 094F: MOVF 44,W 0950: MOVWF 48 0951: MOVF 43,W 0952: MOVWF 47 0953: MOVF 42,W 0954: MOVWF 46 0955: MOVF 41,W 0956: MOVWF 45 0957: CLRF 4C 0958: CLRF 4B 0959: CLRF 4A 095A: MOVLW 0A 095B: MOVWF 49 095C: CALL 0B7 095D: MOVF 7A,W 095E: MOVWF 44 095F: MOVF 79,W 0960: MOVWF 43 0961: MOVF 78,W 0962: MOVWF 42 0963: MOVF 77,W 0964: MOVWF 41 0965: DECFSZ 40,F 0966: GOTO 115 0967: RETLW 00 0968: CLRF 36 0969: MOVF 36,W 096A: BCF 0A.3 096B: CALL 19B 096C: BSF 0A.3 096D: INCF 36,F 096E: BTFSS 0C.4 096F: GOTO 16E 0970: MOVWF 19 0971: MOVLW 11 0972: SUBWF 36,W 0973: BTFSS 03.2 0974: GOTO 169 0975: MOVLW 41 0976: MOVWF 04 0977: MOVF 2C,W 0978: MOVWF 3E 0979: MOVF 2B,W 097A: MOVWF 3D 097B: MOVF 2A,W 097C: MOVWF 3C 097D: MOVF 29,W 097E: MOVWF 3B 097F: CALL 0F9 0980: MOVLW 0D 0981: BTFSS 0C.4 0982: GOTO 181 0983: MOVWF 19 0984: MOVLW 0A 0985: BTFSS 0C.4 0986: GOTO 185 0987: MOVWF 19 0988: BSF 0A.3 0989: BCF 0A.4 098A: GOTO 3A6 (RETURN) .................... } .................... .................... void encoder_pos() .................... { .................... printf("encoder position = %u\r\n", read_encoder()); * 01B6: BSF 0A.0 01B7: BCF 0A.1 01B8: BCF 0A.2 01B9: ADDWF 02,F 01BA: RETLW 65 01BB: RETLW 6E 01BC: RETLW 63 01BD: RETLW 6F 01BE: RETLW 64 01BF: RETLW 65 01C0: RETLW 72 01C1: RETLW 20 01C2: RETLW 70 01C3: RETLW 6F 01C4: RETLW 73 01C5: RETLW 69 01C6: RETLW 74 01C7: RETLW 69 01C8: RETLW 6F 01C9: RETLW 6E 01CA: RETLW 20 01CB: RETLW 3D 01CC: RETLW 20 01CD: RETLW 25 01CE: RETLW 75 01CF: RETLW 0D 01D0: RETLW 0A 01D1: RETLW 00 * 098B: BTFSC 39.0 098C: GOTO 1A8 098D: BTFSC 39.1 098E: GOTO 1BE 098F: MOVF 38,W 0990: MOVWF 3A 0991: MOVLW 64 0992: MOVWF 3B 0993: BCF 0A.3 0994: CALL 625 0995: BSF 0A.3 0996: MOVF 77,W 0997: MOVWF 38 0998: MOVF 78,W 0999: MOVLW 30 099A: BTFSS 03.2 099B: GOTO 1A1 099C: BTFSC 39.2 099D: GOTO 1A8 099E: BTFSC 39.3 099F: MOVLW 20 09A0: GOTO 1A3 09A1: BCF 39.2 09A2: BCF 39.3 09A3: ADDWF 78,F 09A4: MOVF 78,W 09A5: BTFSS 0C.4 09A6: GOTO 1A5 09A7: MOVWF 19 09A8: MOVF 38,W 09A9: MOVWF 3A 09AA: MOVLW 0A 09AB: MOVWF 3B 09AC: BCF 0A.3 09AD: CALL 625 09AE: BSF 0A.3 09AF: MOVF 77,W 09B0: MOVWF 38 09B1: MOVF 78,W 09B2: MOVLW 30 09B3: BTFSS 03.2 09B4: GOTO 1B9 09B5: BTFSC 39.2 09B6: GOTO 1BE 09B7: BTFSC 39.3 09B8: MOVLW 20 09B9: ADDWF 78,F 09BA: MOVF 78,W 09BB: BTFSS 0C.4 09BC: GOTO 1BB 09BD: MOVWF 19 09BE: MOVLW 30 09BF: ADDWF 38,F 09C0: MOVF 38,W 09C1: BTFSS 0C.4 09C2: GOTO 1C1 09C3: MOVWF 19 09C4: BSF 0A.3 09C5: BCF 0A.4 09C6: GOTO 1E4 (RETURN) 09C7: MOVF 0B,W 09C8: ANDWF 0B,W 09C9: BCF 0B.7 09CA: MOVWF 20 09CB: BCF 0A.3 09CC: CALL 404 09CD: BSF 0A.3 09CE: MOVF 20,W 09CF: IORWF 0B,F 09D0: MOVF 78,W 09D1: MOVWF 36 09D2: CLRF 37 09D3: MOVF 37,W 09D4: BCF 0A.3 09D5: CALL 1B6 09D6: BSF 0A.3 09D7: INCF 37,F 09D8: BTFSS 0C.4 09D9: GOTO 1D8 09DA: MOVWF 19 09DB: MOVLW 13 09DC: SUBWF 37,W 09DD: BTFSS 03.2 09DE: GOTO 1D3 09DF: MOVF 36,W 09E0: MOVWF 38 09E1: MOVLW 0C 09E2: MOVWF 39 09E3: GOTO 18B 09E4: MOVLW 0D 09E5: BTFSS 0C.4 09E6: GOTO 1E5 09E7: MOVWF 19 09E8: MOVLW 0A 09E9: BTFSS 0C.4 09EA: GOTO 1E9 09EB: MOVWF 19 09EC: BSF 0A.3 09ED: BCF 0A.4 09EE: GOTO 3A8 (RETURN) .................... } .................... .................... void clear_pos() .................... { .................... clear_encoder(); .................... motor_position = 0; * 046A: CLRF 2C 046B: CLRF 2B 046C: CLRF 2A 046D: CLRF 29 046E: RETLW 00 .................... } .................... .................... void loop_read_pos() .................... { .................... while ( !kbhit() ) * 0A12: BTFSC 0C.5 0A13: GOTO 23F .................... { .................... printf("motor_position = 0x%Lx\r", motor_position); * 01D2: BSF 0A.0 01D3: BCF 0A.1 01D4: BCF 0A.2 01D5: ADDWF 02,F 01D6: RETLW 6D 01D7: RETLW 6F 01D8: RETLW 74 01D9: RETLW 6F 01DA: RETLW 72 01DB: RETLW 5F 01DC: RETLW 70 01DD: RETLW 6F 01DE: RETLW 73 01DF: RETLW 69 01E0: RETLW 74 01E1: RETLW 69 01E2: RETLW 6F 01E3: RETLW 6E 01E4: RETLW 20 01E5: RETLW 3D 01E6: RETLW 20 01E7: RETLW 30 01E8: RETLW 78 01E9: RETLW 25 01EA: RETLW 4C 01EB: RETLW 78 01EC: RETLW 0D 01ED: RETLW 00 * 09EF: BTFSC 38.7 09F0: GOTO 202 09F1: MOVLW 0F 09F2: MOVWF 77 09F3: SWAPF 37,W 09F4: ANDWF 77,F 09F5: MOVLW 0A 09F6: SUBWF 77,W 09F7: BTFSC 03.0 09F8: GOTO 1FC 09F9: MOVLW 30 09FA: ADDWF 77,F 09FB: GOTO 1FE 09FC: MOVF 38,W 09FD: ADDWF 77,F 09FE: MOVF 77,W 09FF: BTFSS 0C.4 0A00: GOTO 1FF 0A01: MOVWF 19 0A02: MOVLW 0F 0A03: ANDWF 37,F 0A04: MOVLW 0A 0A05: SUBWF 37,W 0A06: BTFSC 03.0 0A07: GOTO 20A 0A08: MOVLW 30 0A09: GOTO 20C 0A0A: BCF 38.7 0A0B: MOVF 38,W 0A0C: ADDWF 37,F 0A0D: MOVF 37,W 0A0E: BTFSS 0C.4 0A0F: GOTO 20E 0A10: MOVWF 19 0A11: RETLW 00 * 0A14: CLRF 36 0A15: MOVF 36,W 0A16: BCF 0A.3 0A17: CALL 1D2 0A18: BSF 0A.3 0A19: INCF 36,F 0A1A: BTFSS 0C.4 0A1B: GOTO 21A 0A1C: MOVWF 19 0A1D: MOVLW 13 0A1E: SUBWF 36,W 0A1F: BTFSS 03.2 0A20: GOTO 215 0A21: MOVF 2C,W 0A22: MOVWF 37 0A23: MOVLW 57 0A24: MOVWF 38 0A25: CALL 1EF 0A26: MOVF 2B,W 0A27: MOVWF 37 0A28: MOVLW 57 0A29: MOVWF 38 0A2A: CALL 1EF 0A2B: MOVF 2A,W 0A2C: MOVWF 37 0A2D: MOVLW 57 0A2E: MOVWF 38 0A2F: CALL 1EF 0A30: MOVF 29,W 0A31: MOVWF 37 0A32: MOVLW 57 0A33: MOVWF 38 0A34: CALL 1EF 0A35: MOVLW 0D 0A36: BTFSS 0C.4 0A37: GOTO 236 0A38: MOVWF 19 .................... delay_ms(200); 0A39: MOVLW C8 0A3A: MOVWF 3B 0A3B: BCF 0A.3 0A3C: CALL 6EB 0A3D: BSF 0A.3 .................... } 0A3E: GOTO 212 0A3F: BSF 0A.3 0A40: BCF 0A.4 0A41: GOTO 3AE (RETURN) .................... } .................... .................... void calc_encoder_cps() .................... { .................... int32 encoder_cps; .................... .................... /* start motor */ .................... dir_state = 0; 0A42: CLRF 2E .................... run_state = 1; 0A43: MOVLW 01 0A44: MOVWF 30 .................... output_bit(PIN_B5, dir_state); 0A45: MOVF 2E,F 0A46: BTFSS 03.2 0A47: GOTO 24A 0A48: BCF 06.5 0A49: GOTO 24B 0A4A: BSF 06.5 0A4B: BSF 03.5 0A4C: BCF 06.5 .................... output_bit(PIN_B4, run_state); 0A4D: BCF 03.5 0A4E: MOVF 30,F 0A4F: BTFSS 03.2 0A50: GOTO 253 0A51: BCF 06.4 0A52: GOTO 254 0A53: BSF 06.4 0A54: BSF 03.5 0A55: BCF 06.4 .................... .................... /* delay for a bit to let motor reach slew */ .................... delay_ms(500); 0A56: MOVLW 02 0A57: BCF 03.5 0A58: MOVWF 3A 0A59: MOVLW FA 0A5A: MOVWF 3B 0A5B: BCF 0A.3 0A5C: CALL 6EB 0A5D: BSF 0A.3 0A5E: DECFSZ 3A,F 0A5F: GOTO 259 .................... .................... /* clear the encoder */ .................... clear_pos(); 0A60: BCF 0A.3 0A61: CALL 462 0A62: BSF 0A.3 .................... .................... /* sample for 1 sec */ .................... delay_ms(1000); 0A63: MOVLW 04 0A64: MOVWF 3A 0A65: MOVLW FA 0A66: MOVWF 3B 0A67: BCF 0A.3 0A68: CALL 6EB 0A69: BSF 0A.3 0A6A: DECFSZ 3A,F 0A6B: GOTO 265 .................... .................... /* read motor position */ .................... encoder_cps = motor_position; 0A6C: MOVF 2C,W 0A6D: MOVWF 39 0A6E: MOVF 2B,W 0A6F: MOVWF 38 0A70: MOVF 2A,W 0A71: MOVWF 37 0A72: MOVF 29,W 0A73: MOVWF 36 .................... .................... /* stop the motor */ .................... run_state = 0; 0A74: CLRF 30 .................... output_bit(PIN_B4, run_state); 0A75: MOVF 30,F 0A76: BTFSS 03.2 0A77: GOTO 27A 0A78: BCF 06.4 0A79: GOTO 27B 0A7A: BSF 06.4 0A7B: BSF 03.5 0A7C: BCF 06.4 .................... .................... /* display results */ .................... printf("encoder cps = %ld\r\n", encoder_cps); * 01EE: BSF 0A.0 01EF: BCF 0A.1 01F0: BCF 0A.2 01F1: ADDLW F5 01F2: BTFSC 03.0 01F3: INCF 0A,F 01F4: MOVWF 02 01F5: RETLW 65 01F6: RETLW 6E 01F7: RETLW 63 01F8: RETLW 6F 01F9: RETLW 64 01FA: RETLW 65 01FB: RETLW 72 01FC: RETLW 20 01FD: RETLW 63 01FE: RETLW 70 01FF: RETLW 73 0200: RETLW 20 0201: RETLW 3D 0202: RETLW 20 0203: RETLW 25 0204: RETLW 6C 0205: RETLW 64 0206: RETLW 0D 0207: RETLW 0A 0208: RETLW 00 * 0A7D: BCF 03.5 0A7E: CLRF 3A 0A7F: MOVF 3A,W 0A80: BCF 0A.3 0A81: CALL 1EE 0A82: BSF 0A.3 0A83: INCF 3A,F 0A84: BTFSS 0C.4 0A85: GOTO 284 0A86: MOVWF 19 0A87: MOVLW 0E 0A88: SUBWF 3A,W 0A89: BTFSS 03.2 0A8A: GOTO 27F 0A8B: MOVLW 41 0A8C: MOVWF 04 0A8D: MOVF 39,W 0A8E: MOVWF 3E 0A8F: MOVF 38,W 0A90: MOVWF 3D 0A91: MOVF 37,W 0A92: MOVWF 3C 0A93: MOVF 36,W 0A94: MOVWF 3B 0A95: CALL 0F9 0A96: MOVLW 0D 0A97: BTFSS 0C.4 0A98: GOTO 297 0A99: MOVWF 19 0A9A: MOVLW 0A 0A9B: BTFSS 0C.4 0A9C: GOTO 29B 0A9D: MOVWF 19 0A9E: BSF 0A.3 0A9F: BCF 0A.4 0AA0: GOTO 3B0 (RETURN) .................... .................... } .................... .................... void get_motor_moving() .................... { .................... if ( motor_moving ) 0AA1: MOVF 2D,F 0AA2: BTFSC 03.2 0AA3: GOTO 2BA .................... puts("motor moving : true"); * 0209: BCF 0A.0 020A: BSF 0A.1 020B: BCF 0A.2 020C: ADDWF 02,F 020D: RETLW 6D 020E: RETLW 6F 020F: RETLW 74 0210: RETLW 6F 0211: RETLW 72 0212: RETLW 20 0213: RETLW 6D 0214: RETLW 6F 0215: RETLW 76 0216: RETLW 69 0217: RETLW 6E 0218: RETLW 67 0219: RETLW 20 021A: RETLW 3A 021B: RETLW 20 021C: RETLW 74 021D: RETLW 72 021E: RETLW 75 021F: RETLW 65 0220: RETLW 00 * 0AA4: CLRF 36 0AA5: MOVF 36,W 0AA6: BCF 0A.3 0AA7: CALL 209 0AA8: BSF 0A.3 0AA9: IORLW 00 0AAA: BTFSC 03.2 0AAB: GOTO 2B1 0AAC: INCF 36,F 0AAD: BTFSS 0C.4 0AAE: GOTO 2AD 0AAF: MOVWF 19 0AB0: GOTO 2A5 0AB1: MOVLW 0D 0AB2: BTFSS 0C.4 0AB3: GOTO 2B2 0AB4: MOVWF 19 0AB5: MOVLW 0A 0AB6: BTFSS 0C.4 0AB7: GOTO 2B6 0AB8: MOVWF 19 .................... else 0AB9: GOTO 2CF .................... puts("motor moving : false"); * 0221: BCF 0A.0 0222: BSF 0A.1 0223: BCF 0A.2 0224: ADDWF 02,F 0225: RETLW 6D 0226: RETLW 6F 0227: RETLW 74 0228: RETLW 6F 0229: RETLW 72 022A: RETLW 20 022B: RETLW 6D 022C: RETLW 6F 022D: RETLW 76 022E: RETLW 69 022F: RETLW 6E 0230: RETLW 67 0231: RETLW 20 0232: RETLW 3A 0233: RETLW 20 0234: RETLW 66 0235: RETLW 61 0236: RETLW 6C 0237: RETLW 73 0238: RETLW 65 0239: RETLW 00 * 0ABA: CLRF 36 0ABB: MOVF 36,W 0ABC: BCF 0A.3 0ABD: CALL 221 0ABE: BSF 0A.3 0ABF: IORLW 00 0AC0: BTFSC 03.2 0AC1: GOTO 2C7 0AC2: INCF 36,F 0AC3: BTFSS 0C.4 0AC4: GOTO 2C3 0AC5: MOVWF 19 0AC6: GOTO 2BB 0AC7: MOVLW 0D 0AC8: BTFSS 0C.4 0AC9: GOTO 2C8 0ACA: MOVWF 19 0ACB: MOVLW 0A 0ACC: BTFSS 0C.4 0ACD: GOTO 2CC 0ACE: MOVWF 19 0ACF: BSF 0A.3 0AD0: BCF 0A.4 0AD1: GOTO 3B2 (RETURN) .................... } .................... .................... void show_help() .................... { .................... printf("1 - get the motor position\r\n"); * 023A: BCF 0A.0 023B: BSF 0A.1 023C: BCF 0A.2 023D: ADDWF 02,F 023E: RETLW 31 023F: RETLW 20 0240: RETLW 2D 0241: RETLW 20 0242: RETLW 67 0243: RETLW 65 0244: RETLW 74 0245: RETLW 20 0246: RETLW 74 0247: RETLW 68 0248: RETLW 65 0249: RETLW 20 024A: RETLW 6D 024B: RETLW 6F 024C: RETLW 74 024D: RETLW 6F 024E: RETLW 72 024F: RETLW 20 0250: RETLW 70 0251: RETLW 6F 0252: RETLW 73 0253: RETLW 69 0254: RETLW 74 0255: RETLW 69 0256: RETLW 6F 0257: RETLW 6E 0258: RETLW 0D 0259: RETLW 0A 025A: RETLW 00 * 049F: CLRF 36 04A0: MOVF 36,W 04A1: CALL 23A 04A2: INCF 36,F 04A3: BTFSS 0C.4 04A4: GOTO 4A3 04A5: MOVWF 19 04A6: MOVLW 1C 04A7: SUBWF 36,W 04A8: BTFSS 03.2 04A9: GOTO 4A0 .................... printf("2 - toggle pwm (RC2)\r\n"); * 025B: BCF 0A.0 025C: BSF 0A.1 025D: BCF 0A.2 025E: ADDWF 02,F 025F: RETLW 32 0260: RETLW 20 0261: RETLW 2D 0262: RETLW 20 0263: RETLW 74 0264: RETLW 6F 0265: RETLW 67 0266: RETLW 67 0267: RETLW 6C 0268: RETLW 65 0269: RETLW 20 026A: RETLW 70 026B: RETLW 77 026C: RETLW 6D 026D: RETLW 20 026E: RETLW 28 026F: RETLW 52 0270: RETLW 43 0271: RETLW 32 0272: RETLW 29 0273: RETLW 0D 0274: RETLW 0A 0275: RETLW 00 * 04AA: CLRF 36 04AB: MOVF 36,W 04AC: CALL 25B 04AD: INCF 36,F 04AE: BTFSS 0C.4 04AF: GOTO 4AE 04B0: MOVWF 19 04B1: MOVLW 16 04B2: SUBWF 36,W 04B3: BTFSS 03.2 04B4: GOTO 4AB .................... printf("3 - toggle direction (RB5)\r\n"); * 0276: BCF 0A.0 0277: BSF 0A.1 0278: BCF 0A.2 0279: ADDWF 02,F 027A: RETLW 33 027B: RETLW 20 027C: RETLW 2D 027D: RETLW 20 027E: RETLW 74 027F: RETLW 6F 0280: RETLW 67 0281: RETLW 67 0282: RETLW 6C 0283: RETLW 65 0284: RETLW 20 0285: RETLW 64 0286: RETLW 69 0287: RETLW 72 0288: RETLW 65 0289: RETLW 63 028A: RETLW 74 028B: RETLW 69 028C: RETLW 6F 028D: RETLW 6E 028E: RETLW 20 028F: RETLW 28 0290: RETLW 52 0291: RETLW 42 0292: RETLW 35 0293: RETLW 29 0294: RETLW 0D 0295: RETLW 0A 0296: RETLW 00 * 04B5: CLRF 36 04B6: MOVF 36,W 04B7: CALL 276 04B8: INCF 36,F 04B9: BTFSS 0C.4 04BA: GOTO 4B9 04BB: MOVWF 19 04BC: MOVLW 1C 04BD: SUBWF 36,W 04BE: BTFSS 03.2 04BF: GOTO 4B6 .................... printf("4 - toggle run/sense (RB4)\r\n"); * 0297: BCF 0A.0 0298: BSF 0A.1 0299: BCF 0A.2 029A: ADDWF 02,F 029B: RETLW 34 029C: RETLW 20 029D: RETLW 2D 029E: RETLW 20 029F: RETLW 74 02A0: RETLW 6F 02A1: RETLW 67 02A2: RETLW 67 02A3: RETLW 6C 02A4: RETLW 65 02A5: RETLW 20 02A6: RETLW 72 02A7: RETLW 75 02A8: RETLW 6E 02A9: RETLW 2F 02AA: RETLW 73 02AB: RETLW 65 02AC: RETLW 6E 02AD: RETLW 73 02AE: RETLW 65 02AF: RETLW 20 02B0: RETLW 28 02B1: RETLW 52 02B2: RETLW 42 02B3: RETLW 34 02B4: RETLW 29 02B5: RETLW 0D 02B6: RETLW 0A 02B7: RETLW 00 * 04C0: CLRF 36 04C1: MOVF 36,W 04C2: CALL 297 04C3: INCF 36,F 04C4: BTFSS 0C.4 04C5: GOTO 4C4 04C6: MOVWF 19 04C7: MOVLW 1C 04C8: SUBWF 36,W 04C9: BTFSS 03.2 04CA: GOTO 4C1 .................... printf("5 - show I/O state\r\n"); * 02B8: BCF 0A.0 02B9: BSF 0A.1 02BA: BCF 0A.2 02BB: ADDWF 02,F 02BC: RETLW 35 02BD: RETLW 20 02BE: RETLW 2D 02BF: RETLW 20 02C0: RETLW 73 02C1: RETLW 68 02C2: RETLW 6F 02C3: RETLW 77 02C4: RETLW 20 02C5: RETLW 49 02C6: RETLW 2F 02C7: RETLW 4F 02C8: RETLW 20 02C9: RETLW 73 02CA: RETLW 74 02CB: RETLW 61 02CC: RETLW 74 02CD: RETLW 65 02CE: RETLW 0D 02CF: RETLW 0A 02D0: RETLW 00 * 04CB: CLRF 36 04CC: MOVF 36,W 04CD: CALL 2B8 04CE: INCF 36,F 04CF: BTFSS 0C.4 04D0: GOTO 4CF 04D1: MOVWF 19 04D2: MOVLW 14 04D3: SUBWF 36,W 04D4: BTFSS 03.2 04D5: GOTO 4CC .................... printf("6 - open shutter\r\n"); * 02D1: BCF 0A.0 02D2: BSF 0A.1 02D3: BCF 0A.2 02D4: ADDWF 02,F 02D5: RETLW 36 02D6: RETLW 20 02D7: RETLW 2D 02D8: RETLW 20 02D9: RETLW 6F 02DA: RETLW 70 02DB: RETLW 65 02DC: RETLW 6E 02DD: RETLW 20 02DE: RETLW 73 02DF: RETLW 68 02E0: RETLW 75 02E1: RETLW 74 02E2: RETLW 74 02E3: RETLW 65 02E4: RETLW 72 02E5: RETLW 0D 02E6: RETLW 0A 02E7: RETLW 00 * 04D6: CLRF 36 04D7: MOVF 36,W 04D8: CALL 2D1 04D9: INCF 36,F 04DA: BTFSS 0C.4 04DB: GOTO 4DA 04DC: MOVWF 19 04DD: MOVLW 12 04DE: SUBWF 36,W 04DF: BTFSS 03.2 04E0: GOTO 4D7 .................... printf("7 - close shutter\r\n"); * 02E8: BCF 0A.0 02E9: BSF 0A.1 02EA: BCF 0A.2 02EB: ADDWF 02,F 02EC: RETLW 37 02ED: RETLW 20 02EE: RETLW 2D 02EF: RETLW 20 02F0: RETLW 63 02F1: RETLW 6C 02F2: RETLW 6F 02F3: RETLW 73 02F4: RETLW 65 02F5: RETLW 20 02F6: RETLW 73 02F7: RETLW 68 02F8: RETLW 75 02F9: RETLW 74 02FA: RETLW 74 02FB: RETLW 65 02FC: RETLW 72 02FD: RETLW 0D 02FE: RETLW 0A 02FF: RETLW 00 * 04E1: CLRF 36 04E2: MOVF 36,W 04E3: CALL 2E8 04E4: INCF 36,F 04E5: BTFSS 0C.4 04E6: GOTO 4E5 04E7: MOVWF 19 04E8: MOVLW 13 04E9: SUBWF 36,W 04EA: BTFSS 03.2 04EB: GOTO 4E2 .................... printf("8 - store position\r\n"); * 0300: BSF 0A.0 0301: BSF 0A.1 0302: BCF 0A.2 0303: ADDWF 02,F 0304: RETLW 38 0305: RETLW 20 0306: RETLW 2D 0307: RETLW 20 0308: RETLW 73 0309: RETLW 74 030A: RETLW 6F 030B: RETLW 72 030C: RETLW 65 030D: RETLW 20 030E: RETLW 70 030F: RETLW 6F 0310: RETLW 73 0311: RETLW 69 0312: RETLW 74 0313: RETLW 69 0314: RETLW 6F 0315: RETLW 6E 0316: RETLW 0D 0317: RETLW 0A 0318: RETLW 00 * 04EC: CLRF 36 04ED: MOVF 36,W 04EE: CALL 300 04EF: INCF 36,F 04F0: BTFSS 0C.4 04F1: GOTO 4F0 04F2: MOVWF 19 04F3: MOVLW 14 04F4: SUBWF 36,W 04F5: BTFSS 03.2 04F6: GOTO 4ED .................... printf("9 - read position\r\n"); * 0319: BSF 0A.0 031A: BSF 0A.1 031B: BCF 0A.2 031C: ADDWF 02,F 031D: RETLW 39 031E: RETLW 20 031F: RETLW 2D 0320: RETLW 20 0321: RETLW 72 0322: RETLW 65 0323: RETLW 61 0324: RETLW 64 0325: RETLW 20 0326: RETLW 70 0327: RETLW 6F 0328: RETLW 73 0329: RETLW 69 032A: RETLW 74 032B: RETLW 69 032C: RETLW 6F 032D: RETLW 6E 032E: RETLW 0D 032F: RETLW 0A 0330: RETLW 00 * 04F7: CLRF 36 04F8: MOVF 36,W 04F9: CALL 319 04FA: INCF 36,F 04FB: BTFSS 0C.4 04FC: GOTO 4FB 04FD: MOVWF 19 04FE: MOVLW 13 04FF: SUBWF 36,W 0500: BTFSS 03.2 0501: GOTO 4F8 .................... printf("0 - motor position\r\n"); * 0331: BSF 0A.0 0332: BSF 0A.1 0333: BCF 0A.2 0334: ADDWF 02,F 0335: RETLW 30 0336: RETLW 20 0337: RETLW 2D 0338: RETLW 20 0339: RETLW 6D 033A: RETLW 6F 033B: RETLW 74 033C: RETLW 6F 033D: RETLW 72 033E: RETLW 20 033F: RETLW 70 0340: RETLW 6F 0341: RETLW 73 0342: RETLW 69 0343: RETLW 74 0344: RETLW 69 0345: RETLW 6F 0346: RETLW 6E 0347: RETLW 0D 0348: RETLW 0A 0349: RETLW 00 * 0502: CLRF 36 0503: MOVF 36,W 0504: CALL 331 0505: INCF 36,F 0506: BTFSS 0C.4 0507: GOTO 506 0508: MOVWF 19 0509: MOVLW 14 050A: SUBWF 36,W 050B: BTFSS 03.2 050C: GOTO 503 .................... printf("a - encoder position\r\n"); * 034A: BSF 0A.0 034B: BSF 0A.1 034C: BCF 0A.2 034D: ADDWF 02,F 034E: RETLW 61 034F: RETLW 20 0350: RETLW 2D 0351: RETLW 20 0352: RETLW 65 0353: RETLW 6E 0354: RETLW 63 0355: RETLW 6F 0356: RETLW 64 0357: RETLW 65 0358: RETLW 72 0359: RETLW 20 035A: RETLW 70 035B: RETLW 6F 035C: RETLW 73 035D: RETLW 69 035E: RETLW 74 035F: RETLW 69 0360: RETLW 6F 0361: RETLW 6E 0362: RETLW 0D 0363: RETLW 0A 0364: RETLW 00 * 050D: CLRF 36 050E: MOVF 36,W 050F: CALL 34A 0510: INCF 36,F 0511: BTFSS 0C.4 0512: GOTO 511 0513: MOVWF 19 0514: MOVLW 16 0515: SUBWF 36,W 0516: BTFSS 03.2 0517: GOTO 50E .................... printf("b - clear encoder\r\n"); * 0365: BSF 0A.0 0366: BSF 0A.1 0367: BCF 0A.2 0368: ADDWF 02,F 0369: RETLW 62 036A: RETLW 20 036B: RETLW 2D 036C: RETLW 20 036D: RETLW 63 036E: RETLW 6C 036F: RETLW 65 0370: RETLW 61 0371: RETLW 72 0372: RETLW 20 0373: RETLW 65 0374: RETLW 6E 0375: RETLW 63 0376: RETLW 6F 0377: RETLW 64 0378: RETLW 65 0379: RETLW 72 037A: RETLW 0D 037B: RETLW 0A 037C: RETLW 00 * 0518: CLRF 36 0519: MOVF 36,W 051A: CALL 365 051B: INCF 36,F 051C: BTFSS 0C.4 051D: GOTO 51C 051E: MOVWF 19 051F: MOVLW 13 0520: SUBWF 36,W 0521: BTFSS 03.2 0522: GOTO 519 .................... printf("c - loopenzy read motor\r\n"); * 037D: BSF 0A.0 037E: BSF 0A.1 037F: BCF 0A.2 0380: ADDWF 02,F 0381: RETLW 63 0382: RETLW 20 0383: RETLW 2D 0384: RETLW 20 0385: RETLW 6C 0386: RETLW 6F 0387: RETLW 6F 0388: RETLW 70 0389: RETLW 65 038A: RETLW 6E 038B: RETLW 7A 038C: RETLW 79 038D: RETLW 20 038E: RETLW 72 038F: RETLW 65 0390: RETLW 61 0391: RETLW 64 0392: RETLW 20 0393: RETLW 6D 0394: RETLW 6F 0395: RETLW 74 0396: RETLW 6F 0397: RETLW 72 0398: RETLW 0D 0399: RETLW 0A 039A: RETLW 00 * 0523: CLRF 36 0524: MOVF 36,W 0525: CALL 37D 0526: INCF 36,F 0527: BTFSS 0C.4 0528: GOTO 527 0529: MOVWF 19 052A: MOVLW 19 052B: SUBWF 36,W 052C: BTFSS 03.2 052D: GOTO 524 .................... printf("d - calc encoder cps\r\n"); * 039B: BSF 0A.0 039C: BSF 0A.1 039D: BCF 0A.2 039E: ADDWF 02,F 039F: RETLW 64 03A0: RETLW 20 03A1: RETLW 2D 03A2: RETLW 20 03A3: RETLW 63 03A4: RETLW 61 03A5: RETLW 6C 03A6: RETLW 63 03A7: RETLW 20 03A8: RETLW 65 03A9: RETLW 6E 03AA: RETLW 63 03AB: RETLW 6F 03AC: RETLW 64 03AD: RETLW 65 03AE: RETLW 72 03AF: RETLW 20 03B0: RETLW 63 03B1: RETLW 70 03B2: RETLW 73 03B3: RETLW 0D 03B4: RETLW 0A 03B5: RETLW 00 * 052E: CLRF 36 052F: MOVF 36,W 0530: CALL 39B 0531: INCF 36,F 0532: BTFSS 0C.4 0533: GOTO 532 0534: MOVWF 19 0535: MOVLW 16 0536: SUBWF 36,W 0537: BTFSS 03.2 0538: GOTO 52F .................... printf("e - is motor moving\r\n"); * 03B6: BSF 0A.0 03B7: BSF 0A.1 03B8: BCF 0A.2 03B9: ADDWF 02,F 03BA: RETLW 65 03BB: RETLW 20 03BC: RETLW 2D 03BD: RETLW 20 03BE: RETLW 69 03BF: RETLW 73 03C0: RETLW 20 03C1: RETLW 6D 03C2: RETLW 6F 03C3: RETLW 74 03C4: RETLW 6F 03C5: RETLW 72 03C6: RETLW 20 03C7: RETLW 6D 03C8: RETLW 6F 03C9: RETLW 76 03CA: RETLW 69 03CB: RETLW 6E 03CC: RETLW 67 03CD: RETLW 0D 03CE: RETLW 0A 03CF: RETLW 00 * 0539: CLRF 36 053A: MOVF 36,W 053B: CALL 3B6 053C: INCF 36,F 053D: BTFSS 0C.4 053E: GOTO 53D 053F: MOVWF 19 0540: MOVLW 15 0541: SUBWF 36,W 0542: BTFSS 03.2 0543: GOTO 53A .................... printf("? - show this menu\r\n"); * 03D0: BSF 0A.0 03D1: BSF 0A.1 03D2: BCF 0A.2 03D3: ADDWF 02,F 03D4: RETLW 3F 03D5: RETLW 20 03D6: RETLW 2D 03D7: RETLW 20 03D8: RETLW 73 03D9: RETLW 68 03DA: RETLW 6F 03DB: RETLW 77 03DC: RETLW 20 03DD: RETLW 74 03DE: RETLW 68 03DF: RETLW 69 03E0: RETLW 73 03E1: RETLW 20 03E2: RETLW 6D 03E3: RETLW 65 03E4: RETLW 6E 03E5: RETLW 75 03E6: RETLW 0D 03E7: RETLW 0A 03E8: RETLW 00 * 0544: CLRF 36 0545: MOVF 36,W 0546: CALL 3D0 0547: INCF 36,F 0548: BTFSS 0C.4 0549: GOTO 548 054A: MOVWF 19 054B: MOVLW 14 054C: SUBWF 36,W 054D: BTFSS 03.2 054E: GOTO 545 054F: RETLW 00 .................... } .................... .................... main() .................... { .................... char c; * 0AD2: CLRF 04 0AD3: MOVLW 1F 0AD4: ANDWF 03,F 0AD5: MOVLW 9F 0AD6: MOVWF 04 0AD7: MOVLW 07 0AD8: MOVWF 00 0AD9: CLRF 28 0ADA: MOVLW 19 0ADB: BSF 03.5 0ADC: MOVWF 19 0ADD: MOVLW 26 0ADE: MOVWF 18 0ADF: MOVLW 90 0AE0: BCF 03.5 0AE1: MOVWF 18 0AE2: CLRF 2E 0AE3: CLRF 2F 0AE4: CLRF 30 0AE5: CLRF 31 0AE6: CLRF 32 0AE7: CLRF 33 0AE8: MOVLW FF 0AE9: MOVWF 34 .................... .................... /* initialize I/O */ .................... dir_state = 0; 0AEA: CLRF 2E .................... pwm_state = 0; 0AEB: CLRF 2F .................... run_state = 0; 0AEC: CLRF 30 .................... .................... /* clear the motor position */ .................... clear_pos(); 0AED: BCF 0A.3 0AEE: CALL 462 0AEF: BSF 0A.3 .................... .................... output_bit(PIN_B5, dir_state); 0AF0: MOVF 2E,F 0AF1: BTFSS 03.2 0AF2: GOTO 2F5 0AF3: BCF 06.5 0AF4: GOTO 2F6 0AF5: BSF 06.5 0AF6: BSF 03.5 0AF7: BCF 06.5 .................... output_bit(PIN_C2, pwm_state); 0AF8: BCF 03.5 0AF9: MOVF 2F,F 0AFA: BTFSS 03.2 0AFB: GOTO 2FE 0AFC: BCF 07.2 0AFD: GOTO 2FF 0AFE: BSF 07.2 0AFF: BCF 34.2 0B00: MOVF 34,W 0B01: BSF 03.5 0B02: MOVWF 07 .................... output_bit(PIN_B4, run_state); 0B03: BCF 03.5 0B04: MOVF 30,F 0B05: BTFSS 03.2 0B06: GOTO 309 0B07: BCF 06.4 0B08: GOTO 30A 0B09: BSF 06.4 0B0A: BSF 03.5 0B0B: BCF 06.4 .................... .................... /* initialize RTCC */ .................... clock_ticks = TICKS_PER_SEC; 0B0C: MOVLW F4 0B0D: BCF 03.5 0B0E: MOVWF 32 .................... set_rtcc(0); 0B0F: CLRF 01 .................... // setup_counters( RTCC_INTERNAL, RTCC_DIV_64); .................... setup_counters( RTCC_INTERNAL, RTCC_DIV_16); 0B10: MOVLW 03 0B11: MOVWF 77 0B12: BTFSS 77.3 0B13: GOTO 31C 0B14: MOVLW 07 0B15: CLRF 01 0B16: MOVLW 81 0B17: MOVWF 04 0B18: MOVF 00,W 0B19: ANDLW C0 0B1A: IORLW 0F 0B1B: MOVWF 00 0B1C: CLRWDT 0B1D: MOVLW 81 0B1E: MOVWF 04 0B1F: MOVF 00,W 0B20: ANDLW C0 0B21: IORWF 77,W 0B22: MOVWF 00 .................... enable_interrupts(INT_RTCC); 0B23: BSF 0B.5 .................... enable_interrupts(GLOBAL); 0B24: MOVLW C0 0B25: IORWF 0B,F .................... .................... /* initialize A2D */ .................... setup_port_a(RA0_RA1_RA3_ANALOG); 0B26: MOVLW 84 0B27: BSF 03.5 0B28: MOVWF 1F .................... setup_adc(ADC_CLOCK_INTERNAL); 0B29: BCF 03.5 0B2A: MOVF 1F,W 0B2B: ANDLW 38 0B2C: IORLW C1 0B2D: MOVWF 1F .................... set_adc_channel(0); 0B2E: MOVLW 00 0B2F: MOVWF 78 0B30: MOVF 1F,W 0B31: ANDLW C7 0B32: IORWF 78,W 0B33: MOVWF 1F .................... .................... /* show version and help menu */ .................... show_version(); 0B34: BCF 0A.3 0B35: GOTO 46F 0B36: BSF 0A.3 .................... show_help(); 0B37: BCF 0A.3 0B38: CALL 49F 0B39: BSF 0A.3 .................... /* main loop */ .................... while(TRUE) .................... { .................... c = getc(); 0B3A: BCF 0A.3 0B3B: GOTO 550 0B3C: BSF 0A.3 0B3D: MOVF 78,W 0B3E: MOVWF 35 .................... .................... switch (c) 0B3F: MOVF 35,W 0B40: MOVWF 77 0B41: MOVLW 31 0B42: SUBWF 35,W 0B43: BTFSC 03.2 0B44: GOTO 382 0B45: MOVLW 32 0B46: SUBWF 77,W 0B47: BTFSC 03.2 0B48: GOTO 386 0B49: MOVLW 33 0B4A: SUBWF 77,W 0B4B: BTFSC 03.2 0B4C: GOTO 38A 0B4D: MOVLW 34 0B4E: SUBWF 77,W 0B4F: BTFSC 03.2 0B50: GOTO 38E 0B51: MOVLW 35 0B52: SUBWF 77,W 0B53: BTFSC 03.2 0B54: GOTO 392 0B55: MOVLW 36 0B56: SUBWF 77,W 0B57: BTFSC 03.2 0B58: GOTO 396 0B59: MOVLW 37 0B5A: SUBWF 77,W 0B5B: BTFSC 03.2 0B5C: GOTO 39C 0B5D: MOVLW 38 0B5E: SUBWF 77,W 0B5F: BTFSC 03.2 0B60: GOTO 3A1 0B61: MOVLW 39 0B62: SUBWF 77,W 0B63: BTFSC 03.2 0B64: GOTO 3A3 0B65: MOVLW 30 0B66: SUBWF 77,W 0B67: BTFSC 03.2 0B68: GOTO 3A5 0B69: MOVLW 61 0B6A: SUBWF 77,W 0B6B: BTFSC 03.2 0B6C: GOTO 3A7 0B6D: MOVLW 62 0B6E: SUBWF 77,W 0B6F: BTFSC 03.2 0B70: GOTO 3A9 0B71: MOVLW 63 0B72: SUBWF 77,W 0B73: BTFSC 03.2 0B74: GOTO 3AD 0B75: MOVLW 64 0B76: SUBWF 77,W 0B77: BTFSC 03.2 0B78: GOTO 3AF 0B79: MOVLW 65 0B7A: SUBWF 77,W 0B7B: BTFSC 03.2 0B7C: GOTO 3B1 0B7D: MOVLW 3F 0B7E: SUBWF 77,W 0B7F: BTFSC 03.2 0B80: GOTO 3B3 0B81: GOTO 3B7 .................... { .................... case '1' : get_motor_pos(); break; 0B82: BCF 0A.3 0B83: GOTO 5C2 0B84: BSF 0A.3 0B85: GOTO 3C4 .................... case '2' : toggle_pwm(); break; 0B86: BCF 0A.3 0B87: GOTO 5EA 0B88: BSF 0A.3 0B89: GOTO 3C4 .................... case '3' : toggle_direction(); break; 0B8A: BCF 0A.3 0B8B: GOTO 5FF 0B8C: BSF 0A.3 0B8D: GOTO 3C4 .................... case '4' : toggle_run_sense(); break; 0B8E: BCF 0A.3 0B8F: GOTO 612 0B90: BSF 0A.3 0B91: GOTO 3C4 .................... case '5' : show_io_state(); break; 0B92: BCF 0A.3 0B93: GOTO 680 0B94: BSF 0A.3 0B95: GOTO 3C4 .................... case '6' : run_shutter(1); break; 0B96: MOVLW 01 0B97: MOVWF 36 0B98: BCF 0A.3 0B99: CALL 705 0B9A: BSF 0A.3 0B9B: GOTO 3C4 .................... case '7' : run_shutter(0); break; 0B9C: CLRF 36 0B9D: BCF 0A.3 0B9E: CALL 705 0B9F: BSF 0A.3 0BA0: GOTO 3C4 .................... case '8' : store_position(); break; 0BA1: GOTO 000 0BA2: GOTO 3C4 .................... case '9' : read_position(); break; 0BA3: GOTO 077 0BA4: GOTO 3C4 .................... case '0' : motor_pos(); break; 0BA5: GOTO 168 0BA6: GOTO 3C4 .................... case 'a' : encoder_pos(); break; 0BA7: GOTO 1C7 0BA8: GOTO 3C4 .................... case 'b' : clear_pos(); break; 0BA9: BCF 0A.3 0BAA: CALL 462 0BAB: BSF 0A.3 0BAC: GOTO 3C4 .................... case 'c' : loop_read_pos(); break; 0BAD: GOTO 212 0BAE: GOTO 3C4 .................... case 'd' : calc_encoder_cps(); break; 0BAF: GOTO 242 0BB0: GOTO 3C4 .................... case 'e' : get_motor_moving(); break; 0BB1: GOTO 2A1 0BB2: GOTO 3C4 .................... case '?' : show_help(); break; 0BB3: BCF 0A.3 0BB4: CALL 49F 0BB5: BSF 0A.3 0BB6: GOTO 3C4 .................... default: printf("invalid selection\r\n"); * 03E9: BSF 0A.0 03EA: BSF 0A.1 03EB: BCF 0A.2 03EC: ADDLW F0 03ED: BTFSC 03.0 03EE: INCF 0A,F 03EF: MOVWF 02 03F0: RETLW 69 03F1: RETLW 6E 03F2: RETLW 76 03F3: RETLW 61 03F4: RETLW 6C 03F5: RETLW 69 03F6: RETLW 64 03F7: RETLW 20 03F8: RETLW 73 03F9: RETLW 65 03FA: RETLW 6C 03FB: RETLW 65 03FC: RETLW 63 03FD: RETLW 74 03FE: RETLW 69 03FF: RETLW 6F 0400: RETLW 6E 0401: RETLW 0D 0402: RETLW 0A 0403: RETLW 00 * 0BB7: CLRF 36 0BB8: MOVF 36,W 0BB9: BCF 0A.3 0BBA: CALL 3E9 0BBB: BSF 0A.3 0BBC: INCF 36,F 0BBD: BTFSS 0C.4 0BBE: GOTO 3BD 0BBF: MOVWF 19 0BC0: MOVLW 13 0BC1: SUBWF 36,W 0BC2: BTFSS 03.2 0BC3: GOTO 3B8 .................... } .................... } 0BC4: GOTO 33A .................... } .................... 0BC5: SLEEP