CCS PCM C Compiler, Version 3.249, 32337 29-Dec-06 09:03 Filename: windmon2.lst ROM used: 1800 words (88%) Largest free fragment is 248 RAM used: 28 (16%) at main() level 42 (24%) worst case Stack: 5 worst case (3 in main + 2 for interrupts) * 0000: MOVLW 00 0001: MOVWF 0A 0002: GOTO 658 0003: NOP 0004: MOVWF 7F 0005: SWAPF 03,W 0006: CLRF 03 0007: MOVWF 21 0008: MOVF 7F,W 0009: MOVWF 20 000A: MOVF 0A,W 000B: MOVWF 28 000C: CLRF 0A 000D: SWAPF 20,F 000E: MOVF 04,W 000F: MOVWF 22 0010: MOVF 77,W 0011: MOVWF 23 0012: MOVF 78,W 0013: MOVWF 24 0014: MOVF 79,W 0015: MOVWF 25 0016: MOVF 7A,W 0017: MOVWF 26 0018: MOVF 7B,W 0019: MOVWF 27 001A: BCF 03.7 001B: BCF 03.5 001C: BTFSS 0B.5 001D: GOTO 020 001E: BTFSC 0B.2 001F: GOTO 18B 0020: BTFSS 0B.4 0021: GOTO 024 0022: BTFSC 0B.1 0023: GOTO 0B9 0024: MOVF 22,W 0025: MOVWF 04 0026: MOVF 23,W 0027: MOVWF 77 0028: MOVF 24,W 0029: MOVWF 78 002A: MOVF 25,W 002B: MOVWF 79 002C: MOVF 26,W 002D: MOVWF 7A 002E: MOVF 27,W 002F: MOVWF 7B 0030: MOVF 28,W 0031: MOVWF 0A 0032: SWAPF 21,W 0033: MOVWF 03 0034: SWAPF 7F,F 0035: SWAPF 7F,W 0036: RETFIE .................... /* .................... Wind Speed Display and Data Logger .................... Copyright (C) 2007 APRS World, LLC .................... .................... This program is free software; you can redistribute it and/or modify .................... it under the terms of the GNU General Public License as published by .................... the Free Software Foundation; either version 2 of the License, or .................... (at your option) any later version. .................... .................... This program is distributed in the hope that it will be useful, .................... but WITHOUT ANY WARRANTY; without even the implied warranty of .................... MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .................... GNU General Public License for more details. .................... .................... You should have received a copy of the GNU General Public License .................... along with this program; if not, write to the Free Software .................... Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. .................... .................... Author: .................... APRS World, LLC .................... .................... PO Box 1264 .................... Winona, MN 55987 .................... .................... Project website: .................... http://www.aprsworld.com/windmonitor2/ .................... */ .................... .................... #include "windmon2.h" .................... .................... #include <16F628A.h> .................... //////// Standard Header file for the PIC16F628A device //////////////// .................... #device PIC16F628A .................... #list .................... .................... #FUSES INTRC_IO,NOPROTECT,NOWDT,PUT,NOLVP,NOBROWNOUT, NOMCLR .................... #use delay(clock=4000000) * 01FF: MOVLW 3E 0200: MOVWF 04 0201: MOVF 00,W 0202: BTFSC 03.2 0203: GOTO 213 0204: MOVLW 01 0205: MOVWF 78 0206: CLRF 77 0207: DECFSZ 77,F 0208: GOTO 207 0209: DECFSZ 78,F 020A: GOTO 206 020B: MOVLW 4A 020C: MOVWF 77 020D: DECFSZ 77,F 020E: GOTO 20D 020F: NOP 0210: NOP 0211: DECFSZ 00,F 0212: GOTO 204 0213: RETLW 00 .................... #use rs232(baud=9600,xmit=PIN_B2,rcv=PIN_B1) .................... #id CHECKSUM .................... .................... #use standard_io(A) .................... #use fast_io(B) .................... .................... #define LEFT_CA PIN_A2 .................... #define RIGHT_CA PIN_A1 .................... #define LED_A PIN_A0 .................... #define LED_B PIN_B7 .................... #define LED_C PIN_B6 .................... #define LED_D PIN_B5 .................... #define LED_E PIN_B4 .................... #define LED_F PIN_B3 .................... #define LED_G PIN_A3 .................... .................... #define EEPROM_SDA PIN_A6 .................... #define EEPROM_SCL PIN_A7 .................... .................... #define TEN_LED LEFT_CA .................... #define ONE_LED RIGHT_CA .................... .................... #ifndef hi .................... #define hi(x) (*(&x+1)) .................... #endif .................... .................... #define crnl() putchar('\r'); putchar('\n'); .................... .................... .................... /* EEPROM offsets */ .................... #define E_CAL 0x00 .................... #define E_SPEED_OFFSET 0x01 .................... #define E_FEATURES 0x02 .................... #define E_DELAY 0x03 .................... .................... .................... /* bit mask fields for features */ .................... #define F_DISP 0 .................... #define F_SLEEP 1 .................... #define F_LOG 2 .................... #define F_LOG_DISP 3 .................... .................... /* standard values */ .................... #define FEATURES_LOG 0b00001101 // should be 0100 for no disp .................... #define FEATURES_DOWNLOAD 0b00001001 .................... #define FEATURES_DISPLAY 0b00001011 .................... .................... /* anemometer calibration */ .................... #rom (0x2100 + E_CAL) = { 0xCC } .................... #rom (0x2100 + E_SPEED_OFFSET) ={ 2 } .................... /* default to download features */ .................... #rom (0x2100 + E_FEATURES) = { FEATURES_DOWNLOAD } .................... /* 30 second log interval */ .................... #rom (0x2100 + E_DELAY ) = { 0, 60 } .................... .................... .................... .................... .................... .................... /* global variables */ .................... int8 features; .................... int8 clicks; .................... /* the wind speed is determined by counting the number of pulses in a window of time. cal determines .................... how long the window is. If the speed (number of pulses) is greater than 0 then the speed_offset is .................... added .................... .................... cal is a magic number .................... speed_offset is in the units displayed. Example: speed_offset=2 will make a speed of 8 display 10 .................... */ .................... int8 cal; .................... int8 speed_offset; .................... .................... int8 window; .................... int8 speed; // speed to show on screen .................... int8 gust; .................... short current; // which digit we are on .................... short update; // update flag .................... .................... int8 tensdigit=0; * 0666: CLRF 32 .................... int8 onesdigit=0; 0667: CLRF 33 .................... .................... #define BEFORESLEEP 255 .................... .................... #include <24256.c> .................... /////////////////////////////////////////////////////////////////////////// .................... //// Library for a 24LC256 serial EEPROM //// .................... //// //// .................... //// init_ext_eeprom(); Call before the other functions are used //// .................... //// //// .................... //// write_ext_eeprom(a, d); Write the byte d to the address a //// .................... //// //// .................... //// d = read_ext_eeprom(a); Read the byte d from the address a //// .................... //// //// .................... //// The main program may define eeprom_sda //// .................... //// and eeprom_scl to override the defaults below. //// .................... //// //// .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 Custom Computer Services //// .................... //// This source code may only be used by licensed users of the CCS C //// .................... //// compiler. This source code may only be distributed to other //// .................... //// licensed users of the CCS C compiler. No other use, reproduction //// .................... //// or distribution is permitted without written permission. //// .................... //// Derivative programs created using this software in object code //// .................... //// form are not restricted in any way. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... .................... #ifndef EEPROM_SDA .................... .................... #define EEPROM_SDA PIN_B1 .................... #define EEPROM_SCL PIN_B0 .................... .................... #endif .................... .................... #use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL) * 02D0: MOVLW 08 02D1: MOVWF 78 02D2: NOP 02D3: NOP 02D4: BCF 05.7 02D5: BSF 03.5 02D6: BCF 05.7 02D7: NOP 02D8: BCF 03.5 02D9: RLF 43,F 02DA: BCF 05.6 02DB: BTFSS 03.0 02DC: GOTO 2E0 02DD: BSF 03.5 02DE: BSF 05.6 02DF: BCF 03.5 02E0: BTFSC 03.0 02E1: GOTO 2E5 02E2: BSF 03.5 02E3: BCF 05.6 02E4: BCF 03.5 02E5: BSF 03.5 02E6: BSF 05.7 02E7: BCF 03.5 02E8: BTFSC 05.7 02E9: GOTO 2EC 02EA: BSF 03.5 02EB: GOTO 2E7 02EC: DECFSZ 78,F 02ED: GOTO 2D2 02EE: NOP 02EF: BCF 05.7 02F0: BSF 03.5 02F1: BCF 05.7 02F2: NOP 02F3: BSF 05.6 02F4: NOP 02F5: NOP 02F6: BSF 05.7 02F7: BCF 03.5 02F8: BTFSC 05.7 02F9: GOTO 2FC 02FA: BSF 03.5 02FB: GOTO 2F7 02FC: CLRF 78 02FD: NOP 02FE: BTFSC 05.6 02FF: BSF 78.0 0300: BCF 05.7 0301: BSF 03.5 0302: BCF 05.7 0303: BCF 03.5 0304: BCF 05.6 0305: BSF 03.5 0306: BCF 05.6 0307: BCF 03.5 0308: RETLW 00 * 04CF: MOVLW 08 04D0: MOVWF 3D 04D1: MOVF 77,W 04D2: MOVWF 3E 04D3: BSF 03.5 04D4: BSF 05.6 04D5: NOP 04D6: BSF 05.7 04D7: BCF 03.5 04D8: BTFSC 05.7 04D9: GOTO 4DC 04DA: BSF 03.5 04DB: GOTO 4D7 04DC: BTFSC 05.6 04DD: BSF 03.0 04DE: BTFSS 05.6 04DF: BCF 03.0 04E0: RLF 78,F 04E1: NOP 04E2: BSF 03.5 04E3: BCF 05.7 04E4: BCF 03.5 04E5: BCF 05.7 04E6: DECFSZ 3D,F 04E7: GOTO 4D3 04E8: BSF 03.5 04E9: BSF 05.6 04EA: NOP 04EB: BCF 03.5 04EC: BCF 05.6 04ED: MOVF 3E,W 04EE: BTFSC 03.2 04EF: GOTO 4F3 04F0: BSF 03.5 04F1: BCF 05.6 04F2: BCF 03.5 04F3: NOP 04F4: BSF 03.5 04F5: BSF 05.7 04F6: BCF 03.5 04F7: BTFSC 05.7 04F8: GOTO 4FB 04F9: BSF 03.5 04FA: GOTO 4F6 04FB: NOP 04FC: BCF 05.7 04FD: BSF 03.5 04FE: BCF 05.7 04FF: NOP 0500: BCF 03.5 0501: BCF 05.6 0502: BSF 03.5 0503: BCF 05.6 0504: BCF 03.5 0505: GOTO 54E (RETURN) .................... .................... #define EEPROM_ADDRESS long int .................... #define EEPROM_SIZE 32768 .................... .................... void init_ext_eeprom() .................... { .................... output_float(EEPROM_SCL); * 03B3: BSF 03.5 03B4: BSF 05.7 .................... output_float(EEPROM_SDA); 03B5: BSF 05.6 .................... .................... } .................... .................... .................... void write_ext_eeprom(long int address, BYTE data) .................... { .................... short int status; .................... i2c_start(); * 0309: BSF 03.5 030A: BSF 05.6 030B: NOP 030C: BSF 05.7 030D: NOP 030E: BCF 03.5 030F: BCF 05.6 0310: BSF 03.5 0311: BCF 05.6 0312: NOP 0313: BCF 03.5 0314: BCF 05.7 0315: BSF 03.5 0316: BCF 05.7 .................... i2c_write(0xa0); 0317: MOVLW A0 0318: BCF 03.5 0319: MOVWF 43 031A: CALL 2D0 .................... i2c_write(address>>8); 031B: MOVF 3E,W 031C: MOVWF 41 031D: CLRF 42 031E: MOVF 3E,W 031F: MOVWF 43 0320: CALL 2D0 .................... i2c_write(address); 0321: MOVF 3D,W 0322: MOVWF 43 0323: CALL 2D0 .................... i2c_write(data); 0324: MOVF 3F,W 0325: MOVWF 43 0326: CALL 2D0 .................... i2c_stop(); 0327: BSF 03.5 0328: BCF 05.6 0329: NOP 032A: BSF 05.7 032B: BCF 03.5 032C: BTFSC 05.7 032D: GOTO 330 032E: BSF 03.5 032F: GOTO 32B 0330: NOP 0331: NOP 0332: NOP 0333: NOP 0334: BSF 03.5 0335: BSF 05.6 0336: NOP .................... i2c_start(); 0337: BSF 05.6 0338: NOP 0339: BSF 05.7 033A: NOP 033B: BCF 03.5 033C: BCF 05.6 033D: BSF 03.5 033E: BCF 05.6 033F: NOP 0340: BCF 03.5 0341: BCF 05.7 0342: BSF 03.5 0343: BCF 05.7 .................... status=i2c_write(0xa0); 0344: MOVLW A0 0345: BCF 03.5 0346: MOVWF 43 0347: CALL 2D0 0348: MOVF 78,W 0349: BTFSC 78.0 034A: GOTO 34D 034B: BCF 40.0 034C: GOTO 34E 034D: BSF 40.0 .................... while(status==1) .................... { 034E: BTFSS 40.0 034F: GOTO 36D .................... i2c_start(); 0350: BSF 03.5 0351: BSF 05.6 0352: NOP 0353: BSF 05.7 0354: NOP 0355: BCF 03.5 0356: BTFSC 05.7 0357: GOTO 35A 0358: BSF 03.5 0359: GOTO 355 035A: BCF 05.6 035B: BSF 03.5 035C: BCF 05.6 035D: NOP 035E: BCF 03.5 035F: BCF 05.7 0360: BSF 03.5 0361: BCF 05.7 .................... status=i2c_write(0xa0); 0362: MOVLW A0 0363: BCF 03.5 0364: MOVWF 43 0365: CALL 2D0 0366: MOVF 78,W 0367: BTFSC 78.0 0368: GOTO 36B 0369: BCF 40.0 036A: GOTO 36C 036B: BSF 40.0 .................... } 036C: GOTO 34E .................... } 036D: RETLW 00 .................... .................... .................... BYTE read_ext_eeprom(long int address) { .................... BYTE data; .................... i2c_start(); * 0517: BSF 03.5 0518: BSF 05.6 0519: NOP 051A: BSF 05.7 051B: NOP 051C: BCF 03.5 051D: BTFSC 05.7 051E: GOTO 521 051F: BSF 03.5 0520: GOTO 51C 0521: BCF 05.6 0522: BSF 03.5 0523: BCF 05.6 0524: NOP 0525: BCF 03.5 0526: BCF 05.7 0527: BSF 03.5 0528: BCF 05.7 .................... i2c_write(0xa0); 0529: MOVLW A0 052A: BCF 03.5 052B: MOVWF 43 052C: CALL 2D0 .................... i2c_write(address>>8); 052D: MOVF 3A,W 052E: MOVWF 3C 052F: CLRF 3D 0530: MOVF 3A,W 0531: MOVWF 43 0532: CALL 2D0 .................... i2c_write(address); 0533: MOVF 39,W 0534: MOVWF 43 0535: CALL 2D0 .................... i2c_start(); 0536: BSF 03.5 0537: BSF 05.6 0538: NOP 0539: BSF 05.7 053A: NOP 053B: BCF 03.5 053C: BTFSC 05.7 053D: GOTO 540 053E: BSF 03.5 053F: GOTO 53B 0540: BCF 05.6 0541: BSF 03.5 0542: BCF 05.6 0543: NOP 0544: BCF 03.5 0545: BCF 05.7 0546: BSF 03.5 0547: BCF 05.7 .................... i2c_write(0xa1); 0548: MOVLW A1 0549: BCF 03.5 054A: MOVWF 43 054B: CALL 2D0 .................... data=i2c_read(0); 054C: CLRF 77 054D: GOTO 4CF 054E: MOVF 78,W 054F: MOVWF 3B .................... i2c_stop(); 0550: BSF 03.5 0551: BCF 05.6 0552: NOP 0553: BSF 05.7 0554: BCF 03.5 0555: BTFSC 05.7 0556: GOTO 559 0557: BSF 03.5 0558: GOTO 554 0559: NOP 055A: NOP 055B: NOP 055C: NOP 055D: BSF 03.5 055E: BSF 05.6 055F: NOP .................... return(data); 0560: BCF 03.5 0561: MOVF 3B,W 0562: MOVWF 78 .................... } .................... .................... #include "printd.c" .................... void print_hex(int8 value) { // should be byte for pic .................... int8 count; .................... .................... count=0; * 057A: CLRF 39 .................... while ( value >= 16 ) { 057B: MOVF 38,W 057C: SUBLW 0F 057D: BTFSC 03.0 057E: GOTO 583 .................... value -= 16; 057F: MOVLW 10 0580: SUBWF 38,F .................... count++; 0581: INCF 39,F .................... } 0582: GOTO 57B .................... if ( count < 10 ) 0583: MOVF 39,W 0584: SUBLW 09 0585: BTFSS 03.0 0586: GOTO 58F .................... putchar('0' + count); 0587: MOVLW 30 0588: ADDWF 39,W 0589: MOVWF 3A 058A: MOVF 3A,W 058B: BTFSS 0C.4 058C: GOTO 58B 058D: MOVWF 19 .................... else 058E: GOTO 597 .................... putchar('A' + count-10); 058F: MOVLW 41 0590: ADDWF 39,W 0591: ADDLW F6 0592: MOVWF 3B 0593: MOVF 3B,W 0594: BTFSS 0C.4 0595: GOTO 594 0596: MOVWF 19 .................... .................... if ( value < 10 ) 0597: MOVF 38,W 0598: SUBLW 09 0599: BTFSS 03.0 059A: GOTO 5A3 .................... putchar('0' + value); 059B: MOVLW 30 059C: ADDWF 38,W 059D: MOVWF 3A 059E: MOVF 3A,W 059F: BTFSS 0C.4 05A0: GOTO 59F 05A1: MOVWF 19 .................... else 05A2: GOTO 5AB .................... putchar('A' + value-10); 05A3: MOVLW 41 05A4: ADDWF 38,W 05A5: ADDLW F6 05A6: MOVWF 3B 05A7: MOVF 3B,W 05A8: BTFSS 0C.4 05A9: GOTO 5A8 05AA: MOVWF 19 .................... } 05AB: RETLW 00 .................... .................... void print_int(int8 value, short zeros) { .................... int count; .................... .................... count=0; * 0292: CLRF 41 .................... while ( value >= 100 ) { 0293: MOVF 3F,W 0294: SUBLW 63 0295: BTFSC 03.0 0296: GOTO 29B .................... value -= 100; 0297: MOVLW 64 0298: SUBWF 3F,F .................... count++; 0299: INCF 41,F .................... } 029A: GOTO 293 .................... if ( count || zeros ) 029B: MOVF 41,F 029C: BTFSS 03.2 029D: GOTO 2A1 029E: MOVF 40,F 029F: BTFSC 03.2 02A0: GOTO 2A8 .................... putchar('0' + count); 02A1: MOVLW 30 02A2: ADDWF 41,W 02A3: MOVWF 42 02A4: MOVF 42,W 02A5: BTFSS 0C.4 02A6: GOTO 2A5 02A7: MOVWF 19 .................... .................... count=0; 02A8: CLRF 41 .................... while ( value >= 10 ) { 02A9: MOVF 3F,W 02AA: SUBLW 09 02AB: BTFSC 03.0 02AC: GOTO 2B1 .................... value -= 10; 02AD: MOVLW 0A 02AE: SUBWF 3F,F .................... count++; 02AF: INCF 41,F .................... } 02B0: GOTO 2A9 .................... if ( count || zeros ) 02B1: MOVF 41,F 02B2: BTFSS 03.2 02B3: GOTO 2B7 02B4: MOVF 40,F 02B5: BTFSC 03.2 02B6: GOTO 2BE .................... putchar('0' + count); /* tens */ 02B7: MOVLW 30 02B8: ADDWF 41,W 02B9: MOVWF 42 02BA: MOVF 42,W 02BB: BTFSS 0C.4 02BC: GOTO 2BB 02BD: MOVWF 19 .................... .................... putchar('0' + value); /* ones */ 02BE: MOVLW 30 02BF: ADDWF 3F,W 02C0: MOVWF 42 02C1: MOVF 42,W 02C2: BTFSS 0C.4 02C3: GOTO 2C2 02C4: MOVWF 19 .................... } 02C5: RETLW 00 .................... .................... void print_lint(int16 value, short zeros) { // should be unsigned long for pic .................... print_int(hi(value),zeros); * 03A4: MOVLW 3C 03A5: MOVWF 04 03A6: MOVF 00,W 03A7: MOVWF 3E 03A8: MOVWF 3F 03A9: MOVF 3D,W 03AA: MOVWF 40 03AB: CALL 292 .................... print_int(value,zeros); 03AC: MOVF 3B,W 03AD: MOVWF 3F 03AE: MOVF 3D,W 03AF: MOVWF 40 03B0: CALL 292 .................... } .................... .................... .................... #include "hw_i.c" .................... /* Put the datalogger into lowest possible power consumption */ .................... #inline .................... void shutdown() { .................... /* go to sleep */ .................... sleep(); * 01AF: SLEEP .................... } .................... .................... int16 read_int_ulong(int8 address) { .................... int16 value; .................... .................... value = read_eeprom(address); * 0373: MOVF 3B,W 0374: BSF 03.5 0375: MOVWF 1B 0376: BCF 1C.7 0377: BSF 1C.0 0378: MOVF 1A,W 0379: BCF 03.5 037A: CLRF 3D 037B: MOVWF 3C .................... value = value << 8; 037C: MOVF 3C,W 037D: MOVWF 3D 037E: CLRF 3C .................... value += read_eeprom(address+1); 037F: MOVLW 01 0380: ADDWF 3B,W 0381: MOVWF 3E 0382: BSF 03.5 0383: MOVWF 1B 0384: BCF 1C.7 0385: BSF 1C.0 0386: MOVF 1A,W 0387: BCF 03.5 0388: ADDWF 3C,F 0389: BTFSC 03.0 038A: INCF 3D,F .................... .................... return value; 038B: MOVF 3C,W 038C: MOVWF 78 038D: MOVF 3D,W 038E: MOVWF 79 .................... } .................... .................... #define BLANK 10 .................... #define DIGIT_L 11 .................... .................... void displayDigit(int8 num) { .................... switch (num) { * 00BF: MOVF 44,W 00C0: XORLW 00 00C1: BTFSC 03.2 00C2: GOTO 0E2 00C3: XORLW 01 00C4: BTFSC 03.2 00C5: GOTO 0F0 00C6: XORLW 03 00C7: BTFSC 03.2 00C8: GOTO 0FE 00C9: XORLW 01 00CA: BTFSC 03.2 00CB: GOTO 10C 00CC: XORLW 07 00CD: BTFSC 03.2 00CE: GOTO 11A 00CF: XORLW 01 00D0: BTFSC 03.2 00D1: GOTO 128 00D2: XORLW 03 00D3: BTFSC 03.2 00D4: GOTO 136 00D5: XORLW 01 00D6: BTFSC 03.2 00D7: GOTO 144 00D8: XORLW 0F 00D9: BTFSC 03.2 00DA: GOTO 152 00DB: XORLW 01 00DC: BTFSC 03.2 00DD: GOTO 160 00DE: XORLW 03 00DF: BTFSC 03.2 00E0: GOTO 16E 00E1: GOTO 17C .................... case 0: .................... output_low(LED_A); 00E2: BSF 03.5 00E3: BCF 05.0 00E4: BCF 03.5 00E5: BCF 05.0 .................... output_low(LED_B); 00E6: BCF 06.7 .................... output_low(LED_C); 00E7: BCF 06.6 .................... output_low(LED_D); 00E8: BCF 06.5 .................... output_low(LED_E); 00E9: BCF 06.4 .................... output_low(LED_F); 00EA: BCF 06.3 .................... output_high(LED_G); 00EB: BSF 03.5 00EC: BCF 05.3 00ED: BCF 03.5 00EE: BSF 05.3 .................... break; 00EF: GOTO 18A .................... case 1: .................... output_high(LED_A); 00F0: BSF 03.5 00F1: BCF 05.0 00F2: BCF 03.5 00F3: BSF 05.0 .................... output_low(LED_B); 00F4: BCF 06.7 .................... output_low(LED_C); 00F5: BCF 06.6 .................... output_high(LED_D); 00F6: BSF 06.5 .................... output_high(LED_E); 00F7: BSF 06.4 .................... output_high(LED_F); 00F8: BSF 06.3 .................... output_high(LED_G); 00F9: BSF 03.5 00FA: BCF 05.3 00FB: BCF 03.5 00FC: BSF 05.3 .................... break; 00FD: GOTO 18A .................... case 2: .................... output_low(LED_A); 00FE: BSF 03.5 00FF: BCF 05.0 0100: BCF 03.5 0101: BCF 05.0 .................... output_low(LED_B); 0102: BCF 06.7 .................... output_high(LED_C); 0103: BSF 06.6 .................... output_low(LED_D); 0104: BCF 06.5 .................... output_low(LED_E); 0105: BCF 06.4 .................... output_high(LED_F); 0106: BSF 06.3 .................... output_low(LED_G); 0107: BSF 03.5 0108: BCF 05.3 0109: BCF 03.5 010A: BCF 05.3 .................... break; 010B: GOTO 18A .................... case 3: .................... output_low(LED_A); 010C: BSF 03.5 010D: BCF 05.0 010E: BCF 03.5 010F: BCF 05.0 .................... output_low(LED_B); 0110: BCF 06.7 .................... output_low(LED_C); 0111: BCF 06.6 .................... output_low(LED_D); 0112: BCF 06.5 .................... output_high(LED_E); 0113: BSF 06.4 .................... output_high(LED_F); 0114: BSF 06.3 .................... output_low(LED_G); 0115: BSF 03.5 0116: BCF 05.3 0117: BCF 03.5 0118: BCF 05.3 .................... break; 0119: GOTO 18A .................... case 4: .................... output_high(LED_A); 011A: BSF 03.5 011B: BCF 05.0 011C: BCF 03.5 011D: BSF 05.0 .................... output_low(LED_B); 011E: BCF 06.7 .................... output_low(LED_C); 011F: BCF 06.6 .................... output_high(LED_D); 0120: BSF 06.5 .................... output_high(LED_E); 0121: BSF 06.4 .................... output_low(LED_F); 0122: BCF 06.3 .................... output_low(LED_G); 0123: BSF 03.5 0124: BCF 05.3 0125: BCF 03.5 0126: BCF 05.3 .................... break; 0127: GOTO 18A .................... case 5: .................... output_low(LED_A); 0128: BSF 03.5 0129: BCF 05.0 012A: BCF 03.5 012B: BCF 05.0 .................... output_high(LED_B); 012C: BSF 06.7 .................... output_low(LED_C); 012D: BCF 06.6 .................... output_low(LED_D); 012E: BCF 06.5 .................... output_high(LED_E); 012F: BSF 06.4 .................... output_low(LED_F); 0130: BCF 06.3 .................... output_low(LED_G); 0131: BSF 03.5 0132: BCF 05.3 0133: BCF 03.5 0134: BCF 05.3 .................... break; 0135: GOTO 18A .................... case 6: .................... output_low(LED_A); 0136: BSF 03.5 0137: BCF 05.0 0138: BCF 03.5 0139: BCF 05.0 .................... output_high(LED_B); 013A: BSF 06.7 .................... output_low(LED_C); 013B: BCF 06.6 .................... output_low(LED_D); 013C: BCF 06.5 .................... output_low(LED_E); 013D: BCF 06.4 .................... output_low(LED_F); 013E: BCF 06.3 .................... output_low(LED_G); 013F: BSF 03.5 0140: BCF 05.3 0141: BCF 03.5 0142: BCF 05.3 .................... break; 0143: GOTO 18A .................... case 7: .................... output_low(LED_A); 0144: BSF 03.5 0145: BCF 05.0 0146: BCF 03.5 0147: BCF 05.0 .................... output_low(LED_B); 0148: BCF 06.7 .................... output_low(LED_C); 0149: BCF 06.6 .................... output_high(LED_D); 014A: BSF 06.5 .................... output_high(LED_E); 014B: BSF 06.4 .................... output_high(LED_F); 014C: BSF 06.3 .................... output_high(LED_G); 014D: BSF 03.5 014E: BCF 05.3 014F: BCF 03.5 0150: BSF 05.3 .................... break; 0151: GOTO 18A .................... case 8: .................... output_low(LED_A); 0152: BSF 03.5 0153: BCF 05.0 0154: BCF 03.5 0155: BCF 05.0 .................... output_low(LED_B); 0156: BCF 06.7 .................... output_low(LED_C); 0157: BCF 06.6 .................... output_low(LED_D); 0158: BCF 06.5 .................... output_low(LED_E); 0159: BCF 06.4 .................... output_low(LED_F); 015A: BCF 06.3 .................... output_low(LED_G); 015B: BSF 03.5 015C: BCF 05.3 015D: BCF 03.5 015E: BCF 05.3 .................... break; 015F: GOTO 18A .................... case 9: .................... output_low(LED_A); 0160: BSF 03.5 0161: BCF 05.0 0162: BCF 03.5 0163: BCF 05.0 .................... output_low(LED_B); 0164: BCF 06.7 .................... output_low(LED_C); 0165: BCF 06.6 .................... output_high(LED_D); 0166: BSF 06.5 .................... output_high(LED_E); 0167: BSF 06.4 .................... output_low(LED_F); 0168: BCF 06.3 .................... output_low(LED_G); 0169: BSF 03.5 016A: BCF 05.3 016B: BCF 03.5 016C: BCF 05.3 .................... break; 016D: GOTO 18A .................... case BLANK: .................... output_high(LED_A); 016E: BSF 03.5 016F: BCF 05.0 0170: BCF 03.5 0171: BSF 05.0 .................... output_high(LED_B); 0172: BSF 06.7 .................... output_high(LED_C); 0173: BSF 06.6 .................... output_high(LED_D); 0174: BSF 06.5 .................... output_high(LED_E); 0175: BSF 06.4 .................... output_high(LED_F); 0176: BSF 06.3 .................... output_high(LED_G); 0177: BSF 03.5 0178: BCF 05.3 0179: BCF 03.5 017A: BSF 05.3 .................... break; 017B: GOTO 18A .................... default: .................... //case DIGIT_L: .................... output_high(LED_A); 017C: BSF 03.5 017D: BCF 05.0 017E: BCF 03.5 017F: BSF 05.0 .................... output_high(LED_B); 0180: BSF 06.7 .................... output_high(LED_C); 0181: BSF 06.6 .................... output_low(LED_D); 0182: BCF 06.5 .................... output_low(LED_E); 0183: BCF 06.4 .................... output_low(LED_F); 0184: BCF 06.3 .................... output_high(LED_G); 0185: BSF 03.5 0186: BCF 05.3 0187: BCF 03.5 0188: BSF 05.3 .................... break; 0189: GOTO 18A .................... } .................... } 018A: RETLW 00 .................... .................... .................... void update_digits(int8 val) { .................... tensdigit=0; * 01B7: CLRF 32 .................... .................... while ( val >= 10 ) { 01B8: MOVF 44,W 01B9: SUBLW 09 01BA: BTFSC 03.0 01BB: GOTO 1C0 .................... val -= 10; 01BC: MOVLW 0A 01BD: SUBWF 44,F .................... tensdigit++; 01BE: INCF 32,F .................... } 01BF: GOTO 1B8 .................... .................... onesdigit=val; 01C0: MOVF 44,W 01C1: MOVWF 33 .................... } .................... .................... .................... void printCal(void) { .................... // printf("cal = "); .................... print_hex(cal); * 05AC: MOVF 2C,W 05AD: MOVWF 38 05AE: CALL 57A .................... crnl(); 05AF: MOVLW 0D 05B0: BTFSS 0C.4 05B1: GOTO 5B0 05B2: MOVWF 19 05B3: MOVLW 0A 05B4: BTFSS 0C.4 05B5: GOTO 5B4 05B6: MOVWF 19 .................... write_eeprom(E_CAL,cal); 05B7: BSF 03.5 05B8: CLRF 1B 05B9: BCF 03.5 05BA: MOVF 2C,W 05BB: BSF 03.5 05BC: MOVWF 1A 05BD: BSF 1C.2 05BE: BCF 03.5 05BF: MOVF 0B,W 05C0: MOVWF 77 05C1: BCF 0B.7 05C2: BSF 03.5 05C3: MOVLW 55 05C4: MOVWF 1D 05C5: MOVLW AA 05C6: MOVWF 1D 05C7: BSF 1C.1 05C8: BTFSC 1C.1 05C9: GOTO 5C8 05CA: BCF 1C.2 05CB: MOVF 77,W 05CC: BCF 03.5 05CD: IORWF 0B,F .................... } 05CE: RETLW 00 .................... .................... void printSpeedOffset(void) { .................... print_hex(speed_offset); 05CF: MOVF 2D,W 05D0: MOVWF 38 05D1: CALL 57A .................... crnl(); 05D2: MOVLW 0D 05D3: BTFSS 0C.4 05D4: GOTO 5D3 05D5: MOVWF 19 05D6: MOVLW 0A 05D7: BTFSS 0C.4 05D8: GOTO 5D7 05D9: MOVWF 19 .................... write_eeprom(E_SPEED_OFFSET,speed_offset); 05DA: MOVLW 01 05DB: BSF 03.5 05DC: MOVWF 1B 05DD: BCF 03.5 05DE: MOVF 2D,W 05DF: BSF 03.5 05E0: MOVWF 1A 05E1: BSF 1C.2 05E2: BCF 03.5 05E3: MOVF 0B,W 05E4: MOVWF 77 05E5: BCF 0B.7 05E6: BSF 03.5 05E7: MOVLW 55 05E8: MOVWF 1D 05E9: MOVLW AA 05EA: MOVWF 1D 05EB: BSF 1C.1 05EC: BTFSC 1C.1 05ED: GOTO 5EC 05EE: BCF 1C.2 05EF: MOVF 77,W 05F0: BCF 03.5 05F1: IORWF 0B,F .................... } 05F2: RETLW 00 .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 Custom Computer Services //// .................... //// This source code may only be used by licensed users of the CCS C //// .................... //// compiler. This source code may only be distributed to other //// .................... //// licensed users of the CCS C compiler. No other use, reproduction //// .................... //// or distribution is permitted without written permission. //// .................... //// Derivative programs created using this software in object code //// .................... //// form are not restricted in any way. //// .................... //////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _CTYPE .................... #define _CTYPE .................... .................... #define islower(x) isamong(x,"abcdefghijklmnopqrstuvwxyz") .................... #define isupper(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ") .................... #define isalnum(x) isamong(x,"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") .................... #define isalpha(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") .................... #define isdigit(x) isamong(x,"0123456789") .................... #define isspace(x) (x==' ') .................... #define isxdigit(x) isamong(x,"0123456789ABCDEFabcdef") .................... #define iscntrl(x) (x<' ') .................... #define isprint(x) (x>=' ') .................... #define isgraph(x) (x>' ') .................... #define ispunct(x) ((x>' ')&&!isalnum(x)) .................... .................... #endif .................... .................... .................... .................... byte gethex1() { .................... int8 digit; .................... .................... digit = getchar(); 05F3: BTFSS 0C.5 05F4: GOTO 5F3 05F5: MOVF 1A,W 05F6: MOVWF 39 .................... .................... putchar(digit); 05F7: MOVF 39,W 05F8: BTFSS 0C.4 05F9: GOTO 5F8 05FA: MOVWF 19 .................... .................... if(digit<='9') 05FB: MOVF 39,W 05FC: SUBLW 39 05FD: BTFSS 03.0 05FE: GOTO 604 .................... return(digit-'0'); 05FF: MOVLW 30 0600: SUBWF 39,W 0601: MOVWF 78 0602: GOTO 614 .................... else 0603: GOTO 614 .................... return((toupper(digit)-'A')+10); 0604: MOVF 39,W 0605: SUBLW 60 0606: BTFSC 03.0 0607: GOTO 60F 0608: MOVF 39,W 0609: SUBLW 7A 060A: BTFSS 03.0 060B: GOTO 60F 060C: MOVF 39,W 060D: ANDLW DF 060E: GOTO 610 060F: MOVF 39,W 0610: ADDLW BF 0611: ADDLW 0A 0612: MOVWF 78 0613: GOTO 614 .................... } 0614: RETLW 00 .................... .................... byte gethex() { .................... int8 lo; .................... int8 high; .................... .................... high = gethex1(); 0615: CALL 5F3 0616: MOVF 78,W 0617: MOVWF 38 .................... lo = gethex1(); 0618: CALL 5F3 0619: MOVF 78,W 061A: MOVWF 37 .................... if( 0xDD == lo ) 061B: MOVF 37,W 061C: SUBLW DD 061D: BTFSS 03.2 061E: GOTO 623 .................... return(high); 061F: MOVF 38,W 0620: MOVWF 78 0621: GOTO 62B .................... else 0622: GOTO 62B .................... return( high*16+lo ); 0623: SWAPF 38,W 0624: MOVWF 77 0625: MOVLW F0 0626: ANDWF 77,F 0627: MOVF 77,W 0628: ADDWF 37,W 0629: MOVWF 78 062A: GOTO 62B .................... } 062B: RETLW 00 .................... .................... void delay_half_seconds(int16 n) { .................... for ( ; n != 0 ; n-- ) * 03C1: MOVF 3B,F 03C2: BTFSS 03.2 03C3: GOTO 3C7 03C4: MOVF 3C,F 03C5: BTFSC 03.2 03C6: GOTO 3D3 .................... delay_ms( 490 ); 03C7: MOVLW 02 03C8: MOVWF 3D 03C9: MOVLW F5 03CA: MOVWF 3E 03CB: CALL 1FF 03CC: DECFSZ 3D,F 03CD: GOTO 3C9 03CE: MOVF 3B,W 03CF: BTFSC 03.2 03D0: DECF 3C,F 03D1: DECF 3B,F 03D2: GOTO 3C1 .................... } .................... .................... .................... .................... /* This is the interrupt handler for the anemometer */ .................... #int_ext .................... void anemometer_tick(void) { .................... disable_interrupts(INT_RTCC); * 00B9: BCF 0B.5 .................... clicks++; 00BA: INCF 2B,F .................... enable_interrupts(INT_RTCC); 00BB: BSF 0B.5 .................... } .................... .................... .................... /* every time the real-time clock overflows we go here */ 00BC: BCF 0B.1 00BD: BCF 0A.3 00BE: GOTO 024 .................... #int_rtcc .................... void tick(void) { .................... static int8 sleepcount=BEFORESLEEP; * 0668: MOVLW FF 0669: MOVWF 34 .................... .................... /* turn off this interrupt so we don't get interrupted, .................... probably not nescessary unless this ISR takes longer than .................... it should */ .................... disable_interrupts(INT_TIMER0); * 018B: BCF 0B.5 .................... .................... window--; 018C: DECFSZ 2E,F .................... if ( 0 == window ) { 018D: GOTO 1A1 .................... disable_interrupts(INT_EXT); 018E: BCF 0B.4 .................... window = cal; 018F: MOVF 2C,W 0190: MOVWF 2E .................... speed = clicks; 0191: MOVF 2B,W 0192: MOVWF 2F .................... /* it takes some wind to make the anemometer start spinning */ .................... if ( speed > 0 ) { 0193: MOVF 2F,F 0194: BTFSC 03.2 0195: GOTO 198 .................... speed=speed+speed_offset; 0196: MOVF 2D,W 0197: ADDWF 2F,F .................... } .................... if ( speed > gust ) { 0198: MOVF 2F,W 0199: SUBWF 30,W 019A: BTFSC 03.0 019B: GOTO 19E .................... gust = speed; 019C: MOVF 2F,W 019D: MOVWF 30 .................... } .................... clicks = 0; 019E: CLRF 2B .................... update = true; 019F: BSF 31.1 .................... enable_interrupts(INT_EXT); 01A0: BSF 0B.4 .................... } .................... .................... /* if sleep has been zero for the last BEFORESLEEP interations, .................... then we put the processor into sleep mode to save power. The next .................... external interrupt (anemometer click) will wake it up */ .................... if ( bit_test(features,F_SLEEP) ) { 01A1: BTFSS 2A.1 01A2: GOTO 1B0 .................... if ( 0 == speed ) 01A3: MOVF 2F,F 01A4: BTFSS 03.2 01A5: GOTO 1A8 .................... sleepcount--; 01A6: DECF 34,F .................... else 01A7: GOTO 1AA .................... sleepcount=BEFORESLEEP; 01A8: MOVLW FF 01A9: MOVWF 34 .................... .................... if ( 0 == sleepcount ) { 01AA: MOVF 34,F 01AB: BTFSS 03.2 01AC: GOTO 1B0 .................... sleepcount=BEFORESLEEP; 01AD: MOVLW FF 01AE: MOVWF 34 .................... shutdown(); .................... } .................... } .................... .................... if ( bit_test(features,F_DISP) ) { * 01B0: BTFSS 2A.0 01B1: GOTO 1E8 .................... .................... if ( update ) { 01B2: BTFSS 31.1 01B3: GOTO 1C2 .................... update=false; 01B4: BCF 31.1 .................... /* default case we just show speed */ .................... update_digits(speed); 01B5: MOVF 2F,W 01B6: MOVWF 44 .................... } .................... .................... .................... /* alternate between left and right digit */ .................... if ( 0 == current ) { * 01C2: MOVLW 00 01C3: BTFSC 31.0 01C4: MOVLW 01 01C5: XORLW 00 01C6: BTFSS 03.2 01C7: GOTO 1D5 .................... current=1; 01C8: BSF 31.0 .................... output_high(TEN_LED); 01C9: BSF 03.5 01CA: BCF 05.2 01CB: BCF 03.5 01CC: BSF 05.2 .................... displayDigit(onesdigit); 01CD: MOVF 33,W 01CE: MOVWF 44 01CF: CALL 0BF .................... output_low(ONE_LED); 01D0: BSF 03.5 01D1: BCF 05.1 01D2: BCF 03.5 01D3: BCF 05.1 .................... } else { 01D4: GOTO 1E8 .................... current=0; 01D5: BCF 31.0 .................... output_high(ONE_LED); 01D6: BSF 03.5 01D7: BCF 05.1 01D8: BCF 03.5 01D9: BSF 05.1 .................... /* don't zero pad */ .................... if ( 0 == tensdigit ) 01DA: MOVF 32,F 01DB: BTFSS 03.2 01DC: GOTO 1E1 .................... displayDigit(BLANK); 01DD: MOVLW 0A 01DE: MOVWF 44 01DF: CALL 0BF .................... else 01E0: GOTO 1E4 .................... displayDigit(tensdigit); 01E1: MOVF 32,W 01E2: MOVWF 44 01E3: CALL 0BF .................... output_low(TEN_LED); 01E4: BSF 03.5 01E5: BCF 05.2 01E6: BCF 03.5 01E7: BCF 05.2 .................... } .................... } .................... .................... enable_interrupts(INT_TIMER0); // turn back on this interrupt 01E8: BSF 0B.5 .................... } .................... 01E9: BCF 0B.2 01EA: BCF 0A.3 01EB: GOTO 024 .................... void init_628() { .................... /* PIC16F628 stuff to make port_a digital instead of analog */ .................... setup_comparator(NC_NC_NC_NC); 01EC: MOVLW 07 01ED: MOVWF 1F 01EE: BSF 03.5 01EF: MOVF 05,W 01F0: MOVLW 03 01F1: MOVWF 77 01F2: DECFSZ 77,F 01F3: GOTO 1F2 01F4: BCF 03.5 01F5: MOVF 1F,W 01F6: BCF 0C.6 .................... setup_vref(FALSE); 01F7: BSF 03.5 01F8: CLRF 1F .................... .................... set_tris_a(0b00010000); 01F9: MOVLW 10 01FA: TRIS 5 .................... set_tris_b(0b00000011); 01FB: MOVLW 03 01FC: TRIS 6 .................... } 01FD: BCF 03.5 01FE: GOTO 66E (RETURN) .................... .................... void init_interrupts() { .................... set_rtcc(0); * 0279: CLRF 01 .................... setup_counters( RTCC_INTERNAL, RTCC_DIV_32); 027A: MOVLW 04 027B: MOVWF 77 027C: BTFSS 77.3 027D: GOTO 286 027E: MOVLW 07 027F: CLRF 01 0280: MOVLW 81 0281: MOVWF 04 0282: MOVF 00,W 0283: ANDLW C0 0284: IORLW 0F 0285: MOVWF 00 0286: CLRWDT 0287: MOVLW 81 0288: MOVWF 04 0289: MOVF 00,W 028A: ANDLW C0 028B: IORWF 77,W 028C: MOVWF 00 .................... enable_interrupts(INT_RTCC); 028D: BSF 0B.5 .................... enable_interrupts(INT_EXT); 028E: BSF 0B.4 .................... enable_interrupts(H_TO_L); // interrupt on high to low transition .................... .................... enable_interrupts(GLOBAL); 028F: MOVLW C0 0290: IORWF 0B,F .................... } 0291: GOTO 688 (RETURN) .................... .................... .................... void startup_msg() { .................... printf("# windmon2 "); * 0214: CLRF 36 0215: MOVF 36,W 0216: CALL 037 0217: IORLW 00 0218: BTFSC 03.2 0219: GOTO 21F 021A: INCF 36,F 021B: BTFSS 0C.4 021C: GOTO 21B 021D: MOVWF 19 021E: GOTO 215 .................... puts(__DATE__); 021F: CLRF 36 0220: MOVF 36,W 0221: CALL 047 0222: IORLW 00 0223: BTFSC 03.2 0224: GOTO 22A 0225: INCF 36,F 0226: BTFSS 0C.4 0227: GOTO 226 0228: MOVWF 19 0229: GOTO 220 022A: MOVLW 0D 022B: BTFSS 0C.4 022C: GOTO 22B 022D: MOVWF 19 022E: MOVLW 0A 022F: BTFSS 0C.4 0230: GOTO 22F 0231: MOVWF 19 .................... .................... if ( FEATURES_DOWNLOAD == features ) 0232: MOVF 2A,W 0233: SUBLW 09 0234: BTFSS 03.2 0235: GOTO 23F 0236: CLRF 29 0237: BTFSC 0B.7 0238: BSF 29.7 0239: BCF 0B.7 .................... displayDigit(0); 023A: CLRF 44 023B: CALL 0BF 023C: BTFSC 29.7 023D: BSF 0B.7 .................... else if ( FEATURES_DISPLAY == features ) 023E: GOTO 25A 023F: MOVF 2A,W 0240: SUBLW 0B 0241: BTFSS 03.2 0242: GOTO 24D 0243: CLRF 29 0244: BTFSC 0B.7 0245: BSF 29.7 0246: BCF 0B.7 .................... displayDigit(1); 0247: MOVLW 01 0248: MOVWF 44 0249: CALL 0BF 024A: BTFSC 29.7 024B: BSF 0B.7 .................... else if ( FEATURES_LOG == features ) 024C: GOTO 25A 024D: MOVF 2A,W 024E: SUBLW 0D 024F: BTFSS 03.2 0250: GOTO 25A 0251: CLRF 29 0252: BTFSC 0B.7 0253: BSF 29.7 0254: BCF 0B.7 .................... displayDigit(DIGIT_L); 0255: MOVLW 0B 0256: MOVWF 44 0257: CALL 0BF 0258: BTFSC 29.7 0259: BSF 0B.7 .................... .................... output_low(TEN_LED); 025A: BSF 03.5 025B: BCF 05.2 025C: BCF 03.5 025D: BCF 05.2 .................... delay_ms(600); 025E: MOVLW 03 025F: MOVWF 36 0260: MOVLW C8 0261: MOVWF 3E 0262: CALL 1FF 0263: DECFSZ 36,F 0264: GOTO 260 .................... output_high(TEN_LED); 0265: BSF 03.5 0266: BCF 05.2 0267: BCF 03.5 0268: BSF 05.2 .................... output_low(ONE_LED); 0269: BSF 03.5 026A: BCF 05.1 026B: BCF 03.5 026C: BCF 05.1 .................... delay_ms(600); 026D: MOVLW 03 026E: MOVWF 36 026F: MOVLW C8 0270: MOVWF 3E 0271: CALL 1FF 0272: DECFSZ 36,F 0273: GOTO 26F .................... output_high(ONE_LED); 0274: BSF 03.5 0275: BCF 05.1 0276: BCF 03.5 0277: BSF 05.1 .................... .................... } 0278: GOTO 687 (RETURN) .................... .................... void disp_off() { .................... output_high(ONE_LED); * 02C6: BSF 03.5 02C7: BCF 05.1 02C8: BCF 03.5 02C9: BSF 05.1 .................... output_high(TEN_LED); 02CA: BSF 03.5 02CB: BCF 05.2 02CC: BCF 03.5 02CD: BSF 05.2 .................... bit_clear(features,F_DISP); 02CE: BCF 2A.0 .................... } 02CF: RETLW 00 .................... .................... void disp_on() { .................... bit_set(features,F_DISP); * 036E: BSF 2A.0 .................... } 036F: RETLW 00 .................... .................... .................... void startLog() { .................... int16 l; .................... .................... int16 delay; .................... int8 lspeed; // local speed, otherwise it might change .................... .................... bit_clear(features,F_SLEEP); // no sleeping while logging 0370: BCF 2A.1 .................... .................... delay = read_int_ulong(E_DELAY); 0371: MOVLW 03 0372: MOVWF 3B * 038F: MOVF 79,W 0390: MOVWF 39 0391: MOVF 78,W 0392: MOVWF 38 .................... .................... printf("# log "); 0393: CLRF 3B 0394: MOVF 3B,W 0395: CALL 055 0396: IORLW 00 0397: BTFSC 03.2 0398: GOTO 39E 0399: INCF 3B,F 039A: BTFSS 0C.4 039B: GOTO 39A 039C: MOVWF 19 039D: GOTO 394 .................... print_lint(delay,1); 039E: MOVF 39,W 039F: MOVWF 3C 03A0: MOVF 38,W 03A1: MOVWF 3B 03A2: MOVLW 01 03A3: MOVWF 3D .................... // puts(" sec"); .................... .................... /* turn off display if requested */ .................... if ( ! bit_test(features,F_LOG_DISP) ) * 03B1: BTFSS 2A.3 .................... disp_off(); 03B2: CALL 2C6 .................... .................... init_ext_eeprom(); .................... .................... for ( l=0 ; l<32768 ; l++ ) { * 03B6: BCF 03.5 03B7: CLRF 37 03B8: CLRF 36 03B9: MOVF 37,W 03BA: SUBLW 7F 03BB: BTFSS 03.0 03BC: GOTO 402 .................... delay_half_seconds(delay); 03BD: MOVF 39,W 03BE: MOVWF 3C 03BF: MOVF 38,W 03C0: MOVWF 3B .................... .................... lspeed = speed; * 03D3: MOVF 2F,W 03D4: MOVWF 3A .................... .................... disable_interrupts(GLOBAL); 03D5: BCF 0B.6 03D6: BCF 0B.7 03D7: BTFSC 0B.7 03D8: GOTO 3D6 .................... /* make the next location 0xFF so we know where we left off */ .................... if ( l < 32767 ) { 03D9: MOVF 37,W 03DA: SUBLW 7F 03DB: BTFSS 03.0 03DC: GOTO 3F1 03DD: BTFSS 03.2 03DE: GOTO 3E3 03DF: MOVF 36,W 03E0: SUBLW FE 03E1: BTFSS 03.0 03E2: GOTO 3F1 .................... write_ext_eeprom(l+1,0xff); 03E3: MOVLW 01 03E4: ADDWF 36,W 03E5: MOVWF 3B 03E6: MOVF 37,W 03E7: MOVWF 3C 03E8: BTFSC 03.0 03E9: INCF 3C,F 03EA: MOVF 3C,W 03EB: MOVWF 3E 03EC: MOVF 3B,W 03ED: MOVWF 3D 03EE: MOVLW FF 03EF: MOVWF 3F 03F0: CALL 309 .................... } .................... .................... /* then write out current value, in case we power off .................... while writting */ .................... write_ext_eeprom(l,lspeed); 03F1: MOVF 37,W 03F2: MOVWF 3E 03F3: MOVF 36,W 03F4: MOVWF 3D 03F5: MOVF 3A,W 03F6: MOVWF 3F 03F7: CALL 309 .................... enable_interrupts(GLOBAL); 03F8: MOVLW C0 03F9: IORWF 0B,F .................... .................... putchar('.'); 03FA: MOVLW 2E 03FB: BTFSS 0C.4 03FC: GOTO 3FB 03FD: MOVWF 19 .................... } 03FE: INCF 36,F 03FF: BTFSC 03.2 0400: INCF 37,F 0401: GOTO 3B9 .................... .................... disp_on(); 0402: CALL 36E .................... } 0403: RETLW 00 .................... .................... void playLog() { .................... int16 l; .................... int8 value; .................... .................... /* turn off display */ .................... disp_off(); * 0506: CALL 2C6 .................... .................... for ( l=0 ; l<32767 ; l++ ) { 0507: CLRF 37 0508: CLRF 36 0509: MOVF 37,W 050A: SUBLW 7F 050B: BTFSS 03.0 050C: GOTO 578 050D: BTFSS 03.2 050E: GOTO 513 050F: MOVF 36,W 0510: SUBLW FE 0511: BTFSS 03.0 0512: GOTO 578 .................... value=read_ext_eeprom(l); 0513: MOVF 37,W 0514: MOVWF 3A 0515: MOVF 36,W 0516: MOVWF 39 * 0563: MOVF 78,W 0564: MOVWF 38 .................... .................... /* terminate when we get 0xff end of data marker */ .................... if ( 0xff == value ) { 0565: INCFSZ 38,W 0566: GOTO 568 .................... break; 0567: GOTO 578 .................... } .................... .................... print_int(value,false); 0568: MOVF 38,W 0569: MOVWF 3F 056A: CLRF 40 056B: CALL 292 .................... crnl(); 056C: MOVLW 0D 056D: BTFSS 0C.4 056E: GOTO 56D 056F: MOVWF 19 0570: MOVLW 0A 0571: BTFSS 0C.4 0572: GOTO 571 0573: MOVWF 19 .................... } 0574: INCF 36,F 0575: BTFSC 03.2 0576: INCF 37,F 0577: GOTO 509 .................... .................... disp_on(); 0578: CALL 36E .................... } 0579: GOTO 706 (RETURN) .................... .................... .................... short set_mode(char c) { .................... .................... /* if we don't get the mode, then we get it ourselves */ .................... if ( 0 == c ) { * 041C: MOVF 36,F 041D: BTFSS 03.2 041E: GOTO 437 .................... c = getchar(); 041F: BTFSS 0C.5 0420: GOTO 41F 0421: MOVF 1A,W 0422: MOVWF 36 .................... delay_ms(10); 0423: MOVLW 0A 0424: MOVWF 3E 0425: CALL 1FF .................... putchar(c); 0426: MOVF 36,W 0427: BTFSS 0C.4 0428: GOTO 427 0429: MOVWF 19 .................... c = tolower(c); 042A: MOVF 36,W 042B: SUBLW 40 042C: BTFSC 03.0 042D: GOTO 435 042E: MOVF 36,W 042F: SUBLW 5A 0430: BTFSS 03.0 0431: GOTO 435 0432: MOVF 36,W 0433: IORLW 20 0434: GOTO 436 0435: MOVF 36,W 0436: MOVWF 36 .................... } .................... .................... crnl(); 0437: MOVLW 0D 0438: BTFSS 0C.4 0439: GOTO 438 043A: MOVWF 19 043B: MOVLW 0A 043C: BTFSS 0C.4 043D: GOTO 43C 043E: MOVWF 19 .................... .................... .................... if ( 'd' == c ) { 043F: MOVF 36,W 0440: SUBLW 64 0441: BTFSS 03.2 0442: GOTO 451 .................... printf("# dlog"); 0443: CLRF 37 0444: MOVF 37,W 0445: CALL 060 0446: IORLW 00 0447: BTFSC 03.2 0448: GOTO 44E 0449: INCF 37,F 044A: BTFSS 0C.4 044B: GOTO 44A 044C: MOVWF 19 044D: GOTO 444 .................... features = FEATURES_LOG; 044E: MOVLW 0D 044F: MOVWF 2A .................... } else if ( 'o' == c ) { 0450: GOTO 48B 0451: MOVF 36,W 0452: SUBLW 6F 0453: BTFSS 03.2 0454: GOTO 463 .................... printf("# dload"); 0455: CLRF 37 0456: MOVF 37,W 0457: CALL 06B 0458: IORLW 00 0459: BTFSC 03.2 045A: GOTO 460 045B: INCF 37,F 045C: BTFSS 0C.4 045D: GOTO 45C 045E: MOVWF 19 045F: GOTO 456 .................... features = FEATURES_DOWNLOAD; 0460: MOVLW 09 0461: MOVWF 2A .................... } else if ( 'i' == c ) { 0462: GOTO 48B 0463: MOVF 36,W 0464: SUBLW 69 0465: BTFSS 03.2 0466: GOTO 475 .................... printf("# Disp"); 0467: CLRF 37 0468: MOVF 37,W 0469: CALL 077 046A: IORLW 00 046B: BTFSC 03.2 046C: GOTO 472 046D: INCF 37,F 046E: BTFSS 0C.4 046F: GOTO 46E 0470: MOVWF 19 0471: GOTO 468 .................... features = FEATURES_DISPLAY; 0472: MOVLW 0B 0473: MOVWF 2A .................... } else { 0474: GOTO 48B .................... puts("# Invalid"); 0475: CLRF 37 0476: MOVF 37,W 0477: CALL 082 0478: IORLW 00 0479: BTFSC 03.2 047A: GOTO 480 047B: INCF 37,F 047C: BTFSS 0C.4 047D: GOTO 47C 047E: MOVWF 19 047F: GOTO 476 0480: MOVLW 0D 0481: BTFSS 0C.4 0482: GOTO 481 0483: MOVWF 19 0484: MOVLW 0A 0485: BTFSS 0C.4 0486: GOTO 485 0487: MOVWF 19 .................... return 1; 0488: MOVLW 01 0489: MOVWF 78 048A: GOTO 4AD .................... } .................... crnl(); 048B: MOVLW 0D 048C: BTFSS 0C.4 048D: GOTO 48C 048E: MOVWF 19 048F: MOVLW 0A 0490: BTFSS 0C.4 0491: GOTO 490 0492: MOVWF 19 .................... .................... /* save our new mode */ .................... write_eeprom(E_FEATURES,features); 0493: MOVLW 02 0494: BSF 03.5 0495: MOVWF 1B 0496: BCF 03.5 0497: MOVF 2A,W 0498: BSF 03.5 0499: MOVWF 1A 049A: BSF 1C.2 049B: BCF 03.5 049C: MOVF 0B,W 049D: MOVWF 77 049E: BCF 0B.7 049F: BSF 03.5 04A0: MOVLW 55 04A1: MOVWF 1D 04A2: MOVLW AA 04A3: MOVWF 1D 04A4: BSF 1C.1 04A5: BTFSC 1C.1 04A6: GOTO 4A5 04A7: BCF 1C.2 04A8: MOVF 77,W 04A9: BCF 03.5 04AA: IORWF 0B,F .................... .................... return 0; 04AB: MOVLW 00 04AC: MOVWF 78 .................... } .................... .................... void getMode(void) { .................... disable_interrupts(GLOBAL); * 0404: BCF 0B.6 0405: BCF 0B.7 0406: BTFSC 0B.7 0407: GOTO 405 .................... .................... do { .................... puts("(d)log, d(o)wnload, d(i)sp"); 0408: CLRF 36 0409: MOVF 36,W 040A: CALL 090 040B: IORLW 00 040C: BTFSC 03.2 040D: GOTO 413 040E: INCF 36,F 040F: BTFSS 0C.4 0410: GOTO 40F 0411: MOVWF 19 0412: GOTO 409 0413: MOVLW 0D 0414: BTFSS 0C.4 0415: GOTO 414 0416: MOVWF 19 0417: MOVLW 0A 0418: BTFSS 0C.4 0419: GOTO 418 041A: MOVWF 19 .................... } while ( set_mode(0) ); 041B: CLRF 36 * 04AD: MOVF 78,F 04AE: BTFSS 03.2 04AF: GOTO 408 .................... .................... delay_ms(500); 04B0: MOVLW 02 04B1: MOVWF 36 04B2: MOVLW FA 04B3: MOVWF 3E 04B4: CALL 1FF 04B5: DECFSZ 36,F 04B6: GOTO 4B2 .................... #if 1 .................... reset_cpu(); 04B7: CLRF 0A 04B8: GOTO 000 .................... #else .................... /* don't reset, just hang */ .................... while (1) delay_cycles(1); .................... #endif .................... } 04B9: GOTO 706 (RETURN) .................... .................... .................... void write_int_eeprom_hex(void) { .................... write_eeprom(gethex(),gethex()); * 0639: CALL 615 063A: MOVF 78,W 063B: MOVWF 36 063C: CALL 615 063D: MOVF 78,W 063E: MOVWF 37 063F: MOVF 36,W 0640: BSF 03.5 0641: MOVWF 1B 0642: BCF 03.5 0643: MOVF 78,W 0644: BSF 03.5 0645: MOVWF 1A 0646: BSF 1C.2 0647: BCF 03.5 0648: MOVF 0B,W 0649: MOVWF 77 064A: BCF 0B.7 064B: BSF 03.5 064C: MOVLW 55 064D: MOVWF 1D 064E: MOVLW AA 064F: MOVWF 1D 0650: BSF 1C.1 0651: BTFSC 1C.1 0652: GOTO 651 0653: BCF 1C.2 0654: MOVF 77,W 0655: BCF 03.5 0656: IORWF 0B,F .................... } 0657: GOTO 706 (RETURN) .................... .................... void read_int_eeprom_hex(void) { .................... print_hex(read_eeprom(gethex())); * 062C: CALL 615 062D: MOVF 78,W 062E: MOVWF 36 062F: BSF 03.5 0630: MOVWF 1B 0631: BCF 1C.7 0632: BSF 1C.0 0633: MOVF 1A,W 0634: BCF 03.5 0635: MOVWF 37 0636: MOVWF 38 0637: CALL 57A .................... } 0638: GOTO 706 (RETURN) .................... .................... void printSpeed(void) { .................... int8 s; .................... .................... disable_interrupts(GLOBAL); * 04BA: BCF 0B.6 04BB: BCF 0B.7 04BC: BTFSC 0B.7 04BD: GOTO 4BB .................... s=speed; 04BE: MOVF 2F,W 04BF: MOVWF 36 .................... enable_interrupts(GLOBAL); 04C0: MOVLW C0 04C1: IORWF 0B,F .................... .................... print_int(s,false); 04C2: MOVF 36,W 04C3: MOVWF 3F 04C4: CLRF 40 04C5: CALL 292 .................... crnl(); 04C6: MOVLW 0D 04C7: BTFSS 0C.4 04C8: GOTO 4C7 04C9: MOVWF 19 04CA: MOVLW 0A 04CB: BTFSS 0C.4 04CC: GOTO 4CB 04CD: MOVWF 19 .................... } 04CE: GOTO 706 (RETURN) .................... .................... void main(void) { * 0658: CLRF 04 0659: MOVLW 1F 065A: ANDWF 03,F 065B: BSF 03.5 065C: BSF 0E.3 065D: MOVLW 19 065E: MOVWF 19 065F: MOVLW 26 0660: MOVWF 18 0661: MOVLW 90 0662: BCF 03.5 0663: MOVWF 18 0664: MOVLW 07 0665: MOVWF 1F .................... int8 c; .................... .................... /* initialize globals */ .................... speed=0; * 066A: CLRF 2F .................... gust=0; 066B: CLRF 30 .................... clicks=0; 066C: CLRF 2B .................... .................... init_628(); 066D: GOTO 1EC .................... .................... features=read_eeprom(E_FEATURES); 066E: MOVLW 02 066F: BSF 03.5 0670: MOVWF 1B 0671: BCF 1C.7 0672: BSF 1C.0 0673: MOVF 1A,W 0674: BCF 03.5 0675: MOVWF 2A .................... window=cal=read_eeprom(E_CAL); 0676: BSF 03.5 0677: CLRF 1B 0678: BCF 1C.7 0679: BSF 1C.0 067A: MOVF 1A,W 067B: BCF 03.5 067C: MOVWF 2C 067D: MOVWF 2E .................... speed_offset=read_eeprom(E_SPEED_OFFSET); 067E: MOVLW 01 067F: BSF 03.5 0680: MOVWF 1B 0681: BCF 1C.7 0682: BSF 1C.0 0683: MOVF 1A,W 0684: BCF 03.5 0685: MOVWF 2D .................... .................... startup_msg(); 0686: GOTO 214 .................... .................... init_interrupts(); 0687: GOTO 279 .................... .................... /* immediately start logging, but next time come up in download mode */ .................... if ( bit_test(features,F_LOG) ) { 0688: BTFSS 2A.2 0689: GOTO 6A1 .................... write_eeprom(E_FEATURES, 0b00001001); 068A: MOVLW 02 068B: BSF 03.5 068C: MOVWF 1B 068D: MOVLW 09 068E: MOVWF 1A 068F: BSF 1C.2 0690: BCF 03.5 0691: MOVF 0B,W 0692: MOVWF 77 0693: BCF 0B.7 0694: BSF 03.5 0695: MOVLW 55 0696: MOVWF 1D 0697: MOVLW AA 0698: MOVWF 1D 0699: BSF 1C.1 069A: BTFSC 1C.1 069B: GOTO 69A 069C: BCF 1C.2 069D: MOVF 77,W 069E: BCF 03.5 069F: IORWF 0B,F .................... startLog(); 06A0: CALL 370 .................... } .................... .................... #IGNORE_WARNINGS 203 .................... while ( true ) { .................... #IGNORE_WARNINGS NONE .................... printf("cmd: "); 06A1: CLRF 36 06A2: MOVF 36,W 06A3: CALL 0AF 06A4: IORLW 00 06A5: BTFSC 03.2 06A6: GOTO 6AC 06A7: INCF 36,F 06A8: BTFSS 0C.4 06A9: GOTO 6A8 06AA: MOVWF 19 06AB: GOTO 6A2 .................... c = getchar(); 06AC: BTFSS 0C.5 06AD: GOTO 6AC 06AE: MOVF 1A,W 06AF: MOVWF 35 .................... putchar(c); 06B0: MOVF 35,W 06B1: BTFSS 0C.4 06B2: GOTO 6B1 06B3: MOVWF 19 .................... crnl(); 06B4: MOVLW 0D 06B5: BTFSS 0C.4 06B6: GOTO 6B5 06B7: MOVWF 19 06B8: MOVLW 0A 06B9: BTFSS 0C.4 06BA: GOTO 6B9 06BB: MOVWF 19 .................... switch (tolower(c)) { 06BC: MOVF 35,W 06BD: SUBLW 40 06BE: BTFSC 03.0 06BF: GOTO 6C7 06C0: MOVF 35,W 06C1: SUBLW 5A 06C2: BTFSS 03.0 06C3: GOTO 6C7 06C4: MOVF 35,W 06C5: IORLW 20 06C6: GOTO 6C8 06C7: MOVF 35,W 06C8: XORLW 6D 06C9: BTFSC 03.2 06CA: GOTO 6E7 06CB: XORLW 1E 06CC: BTFSC 03.2 06CD: GOTO 6E8 06CE: XORLW 14 06CF: BTFSC 03.2 06D0: GOTO 6E9 06D1: XORLW 17 06D2: BTFSC 03.2 06D3: GOTO 6EB 06D4: XORLW 5D 06D5: BTFSC 03.2 06D6: GOTO 6EC 06D7: XORLW 06 06D8: BTFSC 03.2 06D9: GOTO 6EF 06DA: XORLW 70 06DB: BTFSC 03.2 06DC: GOTO 6F2 06DD: XORLW 06 06DE: BTFSC 03.2 06DF: GOTO 6F5 06E0: XORLW 2F 06E1: BTFSC 03.2 06E2: GOTO 6F8 06E3: XORLW 05 06E4: BTFSC 03.2 06E5: GOTO 6F9 06E6: GOTO 6FA .................... /* Mode of operation */ .................... case 'm': getMode(); 06E7: GOTO 404 .................... break; .................... case 's': printSpeed(); 06E8: GOTO 4BA .................... break; .................... .................... /* Logging */ .................... case 'g': startLog(); 06E9: CALL 370 .................... break; 06EA: GOTO 706 .................... case 'p': playLog(); 06EB: GOTO 506 .................... break; .................... .................... /* Set anemometer calibration */ .................... case '-': cal--; 06EC: DECF 2C,F .................... printCal(); 06ED: CALL 5AC .................... break; 06EE: GOTO 706 .................... case '+': cal++; 06EF: INCF 2C,F .................... printCal(); 06F0: CALL 5AC .................... break; 06F1: GOTO 706 .................... case '[': speed_offset--; 06F2: DECF 2D,F .................... printSpeedOffset(); 06F3: CALL 5CF .................... break; 06F4: GOTO 706 .................... case ']': speed_offset++; 06F5: INCF 2D,F .................... printSpeedOffset(); 06F6: CALL 5CF .................... break; 06F7: GOTO 706 .................... .................... /* computer setup */ .................... case 'r': read_int_eeprom_hex(); 06F8: GOTO 62C .................... break; .................... case 'w': write_int_eeprom_hex(); 06F9: GOTO 639 .................... break; .................... .................... /* unknown command */ .................... default: putchar('?'); crnl(); 06FA: MOVLW 3F 06FB: BTFSS 0C.4 06FC: GOTO 6FB 06FD: MOVWF 19 06FE: MOVLW 0D 06FF: BTFSS 0C.4 0700: GOTO 6FF 0701: MOVWF 19 0702: MOVLW 0A 0703: BTFSS 0C.4 0704: GOTO 703 0705: MOVWF 19 .................... } .................... .................... } 0706: GOTO 6A1 .................... } .................... .................... 0707: SLEEP Configuration Fuses: Word 1: 3F10 NOWDT PUT NOPROTECT NOBROWNOUT NOMCLR NOLVP INTRC_IO NOCPD