Datalogger
;--------------------------------------------------------------------------------------------------------------------------------------
;
; MOTORCYCLE DATA LOGGER - ASSEMBLY SOURCE CODE FOR THE MICROCHIP PIC 16F877
;
;
; Author : Andries C. Tip
; andries.tip@planet.nl
;
; Start of programming : May 2002
; Last Revision Date : December 29, 2006
;
; Program code written with MPLAB IDE v7.00 from Microchip
;
;--------------------------------------------------------------------------------------------------------------------------------------
;
; Define firmware version, this number can be read by computer
;
#define fwv0 a'1' ; version number
#define fwv1 a'7' ; build number, most significant
#define fwv2 a'9' ; build number, least significant
;
;--------------------------------------------------------------------------------------------------------------------------------------
;
; History:
;
; logger179.asm Bugfix: in the interrupt routine the movwf status_temp came after clrf status !!
; logger178.asm Bugfix: bank23 and bank32 macro's were faulty (rp1 instead of rp0) but were not used in the program
; logger177.asm First Public Release in datalogger
;
;--------------------------------------------------------------------------------------------------------------------------------------
;
; Font: Bitstream Vera Sans Mono (size 8 for screen display, size 6 for printing)
;
; Tabsize: 8 characters
;
;--------------------------------------------------------------------------------------------------------------------------------------
;
; Functional description of this firmware:
;
; This firmware is used in a datalogger that will record relevant data from sensors of a motorcycle and
; consists of a Microchip PIC 16F877, IIC EEPROM chips, IIC clock chip etc. After recording, the data can be
; read by using a computer with RS232 communication. The computer is also used for configuring the datalogger
; with settings such as logging rate, wheel diameter, input channels and so forth.
;
; The logging rate (measurements/second) can be given seperately for each channel.
;
; The rotary switch is used to start and stop the data logging. Multiple records can be taken before data readout
; by the computer is needed. Each record will have its own time and date recorded. The mark button can be
; pressed at any time during the logging and can be used to indicate periods in the computer graphs.
;
; Note: For reasons of clarity the external eeprom pages (64 bytes each) are called blocks instead of pages to avoid confusion
; with the memory pages which are used within the Microchip PIC chip.
;
;--------------------------------------------------------------------------------------------------------------------------------------
;
; Pinout:
;
; Port A0 = Analog input 0 Lambda sensor [0..1 V]
; Port A1 = Analog input 1 Voltage [0..5 V]
; Port A2 = Analog input 2 K-Type Thermocouple [0..1024? Celcius ?]
; Port A3 = Analog input 3 Air Temperature (NTC)
; Port A4 = Digital input Clock input 32768 Hz from Clock/Timer chip, used as interrupt
; Port A5 = Analog input 4 Water Temperature (NTC)
;
; Port B0 = Digital input Run
; Port B1 = Digital input _Mark_
; Port B2 = Digital input Brake
; Port B3 = Digital input Laptime
; Port B4 = Digital input _TC disconnected_
; Port B5 = Digital input BoardsupplyOn
; Port B6 = Digital output Status DuoLed Red
; Port B7 = Digital output Status DuoLed Green
;
; Port C0 = Digital output Computer CTS
; Port C1 = Digital input Speed [0..255 km/hr]
; Port C2 = Digital input RPM [0..16383 RPM]
; Port C3 = Digital in/output IIC SDA, clock chip, serial eeproms
; Port C4 = Digital output IIC SCL, clock chip, serial eeproms
; Port C5 = Digital input Computer RTS
; Port C6 = Digital output Computer RX (configure as input so the usart can use this pin !)
; Port C7 = Digital input Computer TX
;
; Port D0 = Digital output Led0, leds are rpm indicator/shift light
; Port D1 = Digital output Led1
; Port D2 = Digital output Led2
; Port D3 = Digital output Led3
; Port D4 = Digital output Led4
; Port D5 = Digital output Led5
; Port D6 = Digital output Led6
; Port D7 = Digital output Led7
;
; Port E0 = Analog input 5 Throttle [0..100 %]
; Port E1 = Analog input 6 Longitudinal acceleration from G-sensor chip
; Port E2 = Analog input 7 Lateral acceleration from G-sensor chip
;
;--------------------------------------------------------------------------------------------------------------------------------------
; Format of data file as composed by computer from datalogger settings and record data
;--------------------------------------------------------------------------------------------------------------------------------------
;Datalogger data file
;
;[Information]
;Serial number=2743
;Start of logging=12/12/04 15:33:57
;Original filename=D:\Datalogger\Data\Track_0018.dat
;Record size=2093104 << record size in bits
;
;[Errors]
;Log event overflow=1
;Thermocouple disconnected=0
;Memory full=1
;
;[Settings]
;Wheel circumference=1967
;Wheel radius=313.1
;RPM maximum=5000
;
;[Channels]
;RPM=32
;Speed=32
;Throttle=32
;Thermocouple=32
;Lambda=32
;Voltage=32
;Airtemp=32
;Watertemp=32
;LongAccel=32
;LatAccel=32
;Mark=32
;Brake=32
;
;[Data]
;0 PC 0 PC 0 L..... << raw data
;
; End of file. << just to inform user
;
;--------------------------------------------------------------------------------------------------------------------------------------
; PIC 14-bit core instruction set
;--------------------------------------------------------------------------------------------------------------------------------------
;
; Mnemonic Description Function Status affected Instr.Cycles
;
; ADDLW k Add literal to W k + W > W C, DC, Z 1
; ADDWF f,d Add W and f W + f >d C, DC, Z 1
; SUBLW k Subtract W from literal k - W > W C, DC, Z 1
; SUBWF f,d Subtract W from f f - W > d C, DC, Z 1
; BCF f, b Bit clear f 0 > f ( b ) 1
; BSF f, b Bit set f 1 > f ( b ) 1
; BTFSC f, b Bit test, skip if clear skip if f ( b ) = 0 1(2)*
; BTFSS f, b Bit test, skip if set skip if f ( b ) = 1 1(2)*
; CLRF f Clear f 0 >f Z 1
; CLRW Clear W 0 >W Z 1
; INCF f,d Increment f f + 1 > d Z 1
; INCFSZ f,d Increment f, skip if zero f + 1 > d, skip if 0 1(2)*
; DECF f,d Decrement f f - 1 > d Z 1
; DECFSZ f,d Decrement f, skip if zero f - 1 > d, skip if 0 1(2)*
; GOTO k Goto address (k is nine bits) k > PC (9 bits) 1
; CALL k Call subroutine PC + 1 > TOS, k >PC 2
; RETURN Return from subroutine TOS > PC 2
; RETLW k Return with literal in W k > W, TOS > PC 2
; RETFIE Return from interrupt TOS > PC, 1 > GIE 2
; MOVLW k Move literal to W k > W 1
; MOVF f,d Move f f > d Z 1
; MOVWF f Move W to f W > f 1
; SWAPF f,d Swap halves f f ( 0:3 ) > f ( 4:7) > d 1
; RLF f,d Rotate left through carry C < 76543210 < C 1
; RRF f,d Rotate right through carry C > 76543210 > C 1
; COMF f,d Complement f .NOT. F > d Z 1
; ANDLW k AND literal and W k .AND. W > W Z 1
; ANDWF f,d AND W and f W .AND. F >d Z 1
; IORLW k Inclusive OR literal and W k .OR. W > W Z 1
; IORWF f,d Inclusive OR W and f W .OR. F >d Z 1
; XORLW k Exclusive OR literal and W k .XOR. W > W Z 1
; XORWF f,d Exclusive OR W and f W .XOR. F >d Z 1
; NOP No operation 1
; OPTION Load OPTION register W > OPTION Register 1
; CLRWDT T Clear watchdog timer 0 > WDT (and prescaler) _TO , _PD 1
; SLEEP Go into standby Mode 0 > WDT, stop oscillator _TO , _PD 1
; TRIS f Tristate port f (only A,B,C!) W > I/O control register f 1
;
;
; * = If the program counter (PC) is modified, or a conditional test is true, the instruction requires two cycles. The second
; cycle is executed as a NOP
;
;
; Field description:
;
; f register file address (0x00 to 0x7F)
; w working register (accumulator)
; b bit address within an 8-bit file register
; k literal field, constant data or label
; d destination select, d = 0 means store result in w, d = 1 means store result in file register f (default is d = 1)
; PC program counter
; TO time-out bit
; PD power-down bit
;
;
; Subtraction: Carry = 1 result is positive or zero
; Carry = 0 result is negative (borrow)
; Addition: Carry = 1 result is > 255 (overflow)
; Carry = 0 result is <=255
;
;--------------------------------------------------------------------------------------------------------------------------------------
; Configuration
;--------------------------------------------------------------------------------------------------------------------------------------
list p=16f877 ; directive to define processor
radix dec ; all numbers are decimal unless stated otherwise
errorlevel -219 ; suppress 'Invalid RAM location specified' warnings (editor warns unneededly about these
; addresses because of unused registers at the same locations in bank1
errorlevel -302 ; suppress 'not in register bank' warnings
errorlevel -305 ; suppress 'default destination' warnings
errorlevel -306 ; suppress 'crossing page boundary' warnings
;--------------------------------------------------------------------------------------------------------------------------------------
; Version
;--------------------------------------------------------------------------------------------------------------------------------------
__IDLOCS h'0000' ; store the firmware version number in the pic identification memory locations
;--------------------------------------------------------------------------------------------------------------------------------------
; Name registers
;--------------------------------------------------------------------------------------------------------------------------------------
w EQU H'0000' ; used in instructions like decsfz
f EQU H'0001' ; to indicate destination
;----- Register Files--------------------------------------------------
; BANK 0 :
indf EQU H'0000' ; indirect file register
tmr0 EQU H'0001' ; timer 0 module register
pcl EQU H'0002' ; program counter (low byte)
status EQU H'0003' ; status register
fsr EQU H'0004' ; indirect data memory address pointer
porta EQU H'0005' ; port A
portb EQU H'0006' ; port B
portc EQU H'0007' ; port C
portd EQU H'0008' ; port D
porte EQU H'0009' ; port E
pclath EQU H'000A' ; write buffer for program counter (upper 5 bits)
intcon EQU H'000B' ; interrupt control register
pir1 EQU H'000C' ; peripheral interrupt flags
pir2 EQU H'000D' ; CCP 2/SSP bus collision/eeprom write operation interrupt flags
tmr1l EQU H'000E' ; timer 1 register low byte
tmr1h EQU H'000F' ; timer 1 register high byte
t1con EQU H'0010' ; timer 1 control register
tmr2 EQU H'0011' ; timer 2
t2con EQU H'0012' ; timer 2 control register
sspbuf EQU H'0013' ; SSP receive/xmit register
sspcon EQU H'0014' ; SSP control register 1
ccpr1l EQU H'0015' ; CCP 1 low byte
ccpr1h EQU H'0016' ; CCP 1 high byte
ccp1con EQU H'0017' ; CCP 1 control register
rcsta EQU H'0018' ; UART receive status and control register
txreg EQU H'0019' ; UART xmit data register
rcreg EQU H'001A' ; UART receive register
ccpr2l EQU H'001B' ; CCP 2 low byte
ccpr2h EQU H'001C' ; CCP 2 high byte
ccp2con EQU H'001D' ; CCP 2 control register
adresh EQU H'001E' ; A/D result register high byte
adcon0 EQU H'001F' ; A/D operation control register
; BANK 1 :
optionreg EQU H'0081' ; option register
trisa EQU H'0085' ; Port A data direction control register
trisb EQU H'0086' ; Port B data direction control register
trisc EQU H'0087' ; Port C data direction control register
trisd EQU H'0088' ; Port D data direction control register
trise EQU H'0089' ; Port E data direction control register
pie1 EQU H'008C' ; peripheral interrupt enable
pie2 EQU H'008D' ; CCP 2/SSP bus collision/eeprom write operation interrupt enable
pcon EQU H'008E' ; power control register
sspcon2 EQU H'0091' ; SSP control register 2
pr2 EQU H'0092' ; timer 2 period register
sspadd EQU H'0093' ; SSP (I2C mode) address register
sspstat EQU H'0094' ; SSP status register
txsta EQU H'0098' ; UART xmit status and control register
spbrg EQU H'0099' ; UART baud rate generator speed control value
adresl EQU H'009E' ; A/D result register low byte
adcon1 EQU H'009F' ; A/D pin control register
; BANK 2 :
eedata EQU H'010C' ; eeprom data register low byte
eeadr EQU H'010D' ; eeprom address register low byte
eedath EQU H'010E' ; eeprom data register high byte
eeadrh EQU H'010F' ; eeprom address register high byte
; BANK 3 :
eecon1 EQU H'018C' ; eeprom control register 1
eecon2 EQU H'018D' ; eeprom control register 2
;----- STATUS Bits ----------------------------------------------------
irp EQU 7
rp1 EQU 6
rp0 EQU 5
not_to EQU 4
not_pd EQU 3
z EQU 2
dc EQU 1
c EQU 0
;----- INTCON Bits ----------------------------------------------------
gie EQU 7
peie EQU 6
t0ie EQU 5
inte EQU 4
rbie EQU 3
t0if EQU 2
intf EQU 1
rbif EQU 0
;----- PIR1 Bits ------------------------------------------------------
pspif EQU 7
adif EQU 6
rcif EQU 5
txif EQU 4
sspif EQU 3
ccp1if EQU 2
tmr2if EQU 1
tmr1if EQU 0
;----- PIR2 Bits ------------------------------------------------------
eeif EQU 4
bclif EQU 3
ccp2if EQU 0
;----- T1CON Bits -----------------------------------------------------
t1ckps1 EQU 5
t1ckps0 EQU 4
t1oscen EQU 3
t1sync EQU 2
tmr1cs EQU 1
tmr1on EQU 0
;----- T2CON Bits -----------------------------------------------------
toutps3 EQU 6
toutps2 EQU 5
toutps1 EQU 4
toutps0 EQU 3
tmr2on EQU 2
t2ckps1 EQU 1
t2ckps0 EQU 0
;----- SSPCON Bits -----------------------------------------------------
wcol EQU 7
sspov EQU 6
sspen EQU 5
ckp EQU 4
sspm3 EQU 3
sspm2 EQU 2
sspm1 EQU 1
sspm0 EQU 0
;----- CCP1CON Bits ----------------------------------------------------
ccp1x EQU 5
ccp1y EQU 4
ccp1m3 EQU 3
ccp1m2 EQU 2
ccp1m1 EQU 1
ccp1m0 EQU 0
;----- RCSTA Bits ----------------------------------------------------
spen EQU 7
rx9 EQU 6
sren EQU 5
cren EQU 4
adden EQU 3
ferr EQU 2
oerr EQU 1
rx9d EQU 0
;----- CCP2CON Bits ----------------------------------------------------
ccp2x EQU 5
ccp2y EQU 4
ccp2m3 EQU 3
ccp2m2 EQU 2
ccp2m1 EQU 1
ccp2m0 EQU 0
;----- ADCON0 Bits ----------------------------------------------------
adcs1 EQU 7
adcs0 EQU 6
chs2 EQU 5
chs1 EQU 4
chs0 EQU 3
go_notdone EQU 2
adon EQU 0
;----- OPTION Register Bits ------------------------------------------
not_rbpu EQU 7
intedg EQU 6
t0cs EQU 5
t0se EQU 4
psa EQU 3
ps2 EQU 2
ps1 EQU 1
ps0 EQU 0
;----- TRISE Bits ----------------------------------------------------
ibf EQU 7
obf EQU 6
ibov EQU 5
pspmode EQU 4
dirpe2 EQU 2
dirpe1 EQU 1
dirpe0 EQU 0
;----- PIE1 Bits ------------------------------------------------------
pspie EQU 7
adie EQU 6
rcie EQU 5
txie EQU 4
sspie EQU 3
ccp1ie EQU 2
tmr2ie EQU 1
tmr1ie EQU 0
;----- PIE2 Bits ------------------------------------------------------
eeie EQU 4
bclie EQU 3
ccp2ie EQU 0
;----- PCON Bits ------------------------------------------------------
not_por EQU 1
not_bor EQU 0
;----- SSPCON2 Bits ----------------------------------------------------
gcen EQU 7
ackstat EQU 6
ackdt EQU 5
acken EQU 4
rcen EQU 3
pen EQU 2
rsen EQU 1
sen EQU 0
;----- SSPSTAT Bits ---------------------------------------------------
smp EQU 7
cke EQU 6
d_nota EQU 5
p EQU 4
s EQU 3
r_notw EQU 2
ua EQU 1
bf EQU 0
;----- TXSTA Bits ----------------------------------------------------
csrc EQU 7
tx9 EQU 6
txen EQU 5
sync EQU 4
brgh EQU 2
trmt EQU 1
tx9d EQU 0
;----- ADCON1 Bits ----------------------------------------------------
adfm EQU 7
pcfg3 EQU 3
pcfg2 EQU 2
pcfg1 EQU 1
pcfg0 EQU 0
;----- EECON1 Bits ----------------------------------------------------
eepgd EQU 7
wrerr EQU 3
wren EQU 2
wr EQU 1
rd EQU 0
;--------------------------------------------------------------------------------------------------------------------------------------
; RAM definition
;--------------------------------------------------------------------------------------------------------------------------------------
__MAXRAM H'1FF'
__BADRAM H'8F'-H'90', H'95'-H'97', H'9A'-H'9D', H'105', H'107'-H'109', H'185', H'187'-H'189', H'18E'-H'18F'
;--------------------------------------------------------------------------------------------------------------------------------------
; Configuration directive
;--------------------------------------------------------------------------------------------------------------------------------------
; '__CONFIG' directive is used to embed configuration data within .asm file.
_CP_ALL EQU H'0FCF'
_CP_HALF EQU H'1FDF'
_CP_UPPER_256 EQU H'2FEF'
_CP_OFF EQU H'3FFF'
_DEBUG_ON EQU H'37FF'
_DEBUG_OFF EQU H'3FFF'
_WRT_ENABLE_ON EQU H'3FFF'
_WRT_ENABLE_OFF EQU H'3DFF'
_CPD_ON EQU H'3EFF'
_CPD_OFF EQU H'3FFF'
_LVP_ON EQU H'3FFF'
_LVP_OFF EQU H'3F7F'
_BODEN_ON EQU H'3FFF'
_BODEN_OFF EQU H'3FBF'
_PWRTE_OFF EQU H'3FFF'
_PWRTE_ON EQU H'3FF7'
_WDT_ON EQU H'3FFF'
_WDT_OFF EQU H'3FFB'
_LP_OSC EQU H'3FFC'
_XT_OSC EQU H'3FFD'
_HS_OSC EQU H'3FFE'
_RC_OSC EQU H'3FFF'
__CONFIG _CP_OFF & _WDT_OFF & _BODEN_ON & _PWRTE_ON & _XT_OSC &_WRT_ENABLE_ON & _LVP_OFF & _DEBUG_OFF & _CPD_OFF
;--------------------------------------------------------------------------------------------------------------------------------------
; Register bank macro's
;--------------------------------------------------------------------------------------------------------------------------------------
bank0 MACRO ; select register bank 0
bcf status,rp0
bcf status,rp1
ENDM
bank1 MACRO ; select register bank 1
bsf status,rp0
bcf status,rp1
ENDM
bank2 MACRO ; select register bank 2
bcf status,rp0
bsf status,rp1
ENDM
bank3 MACRO ; select register bank 3
bsf status,rp0
bsf status,rp1
ENDM
bank02 MACRO ; change from bank 0 to bank 2
bsf status,rp1
ENDM
bank20 MACRO ; change from bank 2 to bank 0
bcf status,rp1
ENDM
bank01 MACRO ; change from bank 0 to bank 1
bsf status,rp0
ENDM
bank10 MACRO ; change from bank 1 to bank 0
bcf status,rp0
ENDM
bank23 MACRO ; change from bank 2 to bank 3
bsf status,rp0
ENDM
bank32 MACRO ; change from bank 3 to bank 2
bcf status,rp0
ENDM
;--------------------------------------------------------------------------------------------------------------------------------------
; Program memory page macro's
;--------------------------------------------------------------------------------------------------------------------------------------
page0 MACRO ; select program memory page 0 (hex 0000 up to hex 07FF)
bcf pclath,3
bcf pclath,4
ENDM
page1 MACRO ; select program memory page 0 (hex 0800 up to hex 0FFF)
bsf pclath,3
bcf pclath,4
ENDM
page2 MACRO ; select program memory page 0 (hex 1000 up to hex 17FF)
bcf pclath,3
bsf pclath,4
ENDM
page3 MACRO ; select program memory page 0 (hex 17FF up to hex 1FFF)
bsf pclath,3
bsf pclath,4
ENDM
;--------------------------------------------------------------------------------------------------------------------------------------
; Constants definitions
;--------------------------------------------------------------------------------------------------------------------------------------
switch EQU 0 ; port B, rotary switch on datalogger (low=on/high=log)
not_mark EQU 1 ; port B, marking switch at vehicle handlebar/steer (low=pressed)
brake EQU 2 ; port B, switch connected to brake handle/pedal (high=pressed)
laptime EQU 3 ; port B, extra laptime circuit to receive infrared beam from light along race track **** to do
not_tcd EQU 4 ; port B, thermocouple disconnected (low=disconnected)
boardsuppl EQU 5 ; port B, external power supply to datalogger (low=battery power only,high=exteral power on)
led_red EQU 6 ; port B, red status led (see below)
led_green EQU 7 ; port B, green status led (see below)
; status led:
; red = datalogger switched on
; green = logging
; yellow = logging, but memory almost full
; flashing red = one of the following errors:
; - logging stopped because memory is full
; - no channels enabled for logging
; - the table of contents (toc) is full, there is a maximum of 20 records
rts_in EQU 5 ; Port C Pin 5 is input for uart flow control
cts_out EQU 0 ; Port C Pin 0 is output for uart flow control
@tocstart EQU d'56' ; start of table of contents in internal eeprom, runs up to and includes address 255
;--------------------------------------------------------------------------------------------------------------------------------------
; Variable definitions
;--------------------------------------------------------------------------------------------------------------------------------------
; variables used at top of bank 0,1,2,3, available from any bank: (Hex 70-7F)
w_temp EQU 0x70 ; variable used for context saving during interrupts
status_temp EQU 0x71 ; variable used for context saving during interrupts
pclath_temp EQU 0x72 ; variable used for context saving during interrupts
fsr_temp EQU 0x73 ; variable used for context saving during interrupts
numlow EQU 0x74 ; least significant or lower byte of 16 bit number (least significant byte of 24 bit number)
nummiddle EQU 0x75 ; most significant or upper byte of 16 bit number (middle byte of 24 bit number)
numhigh EQU 0x76 ; extended byte (most significant byte of 24 bit number)
adtemp EQU 0x77 ; used in a/d conversion for channel selection and as delay counter
adchannel EQU 0x78 ; channel number used in a/d conversion
templow EQU 0x7A ; used in 8, 16 and 24 bit number read from buffer and transmission
tempmiddle EQU 0x7B ; used in 16 and 24 bit number read from buffer and transmission
temphigh EQU 0x7C ; used in 24 bit number transmission
errors EQU 0x7D ; errors flags, bits will be when errors occur during logging (see below)
flags1 EQU 0x7E ; status flag bits (see below)
flags2 EQU 0x7F ; status flag bits (see below)
; bits of 'errors' register:
logoflow EQU 0 ; previous log event was not finished when next event was started, logdata will be corrupted
tcdiscon EQU 1 ; the thermocouple wire has been disconnected during logging, tc-logdata will be corrupted
err_mf EQU 2 ; the external eeprom memory got full during logging
; bits of 'flags1' register:
stx EQU 0 ; stx (start of text) byte received
etx EQU 1 ; etx (end of text) byte received
withdata EQU 2 ; command has data bytes
command EQU 3 ; all bytes of command have been received, now ready for execution of command
changese EQU 7 ; backdoor to change device serial number
; bits of 'flags2' register:
lognow EQU 0 ; timer0 interrupt just occured which means data should be logged instantly
tocfull EQU 1 ; table of contents in pic internal eeprom is full
memfull EQU 2 ; external eeproms are all full
rpmbusy EQU 3 ; do not disturb rpm calculation
spdbusy EQU 4 ; do not disturb speed calculation
shlight EQU 5 ; this flag is set when shift light should be on, used in timer interrupt to flash light
norpm EQU 6 ; indicate we did not get a rpm pulse so calculate a dropping rpm rate
nospeed EQU 7 ; indicate we did not get a speed pulse so calculate a dropping speed value
; variables used in bank 0 (Hex 20-6F)
rx_byte EQU 0x20 ; byte received from UART
rx_parity EQU 0x21 ; byte used in parity checking
rx_checksum EQU 0x22 ; byte used in receive checksum calculation
rx_pointer EQU 0x23 ; pointer for command input buffer
rx_maxpos EQU 0x24 ; maximum location of received command bytes
tx_byte EQU 0x25 ; byte ready to be sent
tx_checksum EQU 0x26 ; used in transmission checksum calculation
tx_parity EQU 0x27 ; used in parity calculation
tx_numberl EQU 0x28 ; used in 8, 16 and 24 bit number transmission
tx_numberm EQU 0x29 ; used in 16 and 24 bit number transmission
tx_numberh EQU 0x2A ; used in 24 bit number transmission
tx_counter EQU 0x2B ; used in 8 and 16 bit number transmission
rx_buffer00 EQU 0x2D ; start of serial communications command receive buffer:
rx_buffer01 EQU 0x2E ; register addresses 2D and 2E are used for two command bytes,
rx_buffer02 EQU 0x2F ; addresses from 2F - 6F are used for a maximum of 64 data bytes
rx_buffer03 EQU 0x30 ;
rx_buffer04 EQU 0x31 ;
rx_buffer05 EQU 0x32 ;
rx_buffer06 EQU 0x33 ;
rx_buffer07 EQU 0x34 ;
rx_buffer08 EQU 0x35 ;
rx_buffer09 EQU 0x36 ;
rx_buffer10 EQU 0x37 ;
rx_buffer11 EQU 0x38 ;
rx_buffer12 EQU 0x39 ;
rx_buffer13 EQU 0x3A ;
rx_buffer14 EQU 0x3B ;
rx_buffer15 EQU 0x3C ;
rx_buffer16 EQU 0x3D ;
rx_buffer17 EQU 0x3E ;
rx_buffer18 EQU 0x3F ;
rx_buffer65 EQU 0x6E ;
rx_buffer66 EQU 0x6F ; plus one checksum byte (note: same locations as blockbuffer in bank1 !)
; variables used in bank 1 (Hex A0-EF)
iicdata EQU 0xA0 ; data byte
iicalow EQU 0xA1 ; address low byte (8 bits)
iicahigh EQU 0xA2 ; address high byte (7 bits)
iicchip EQU 0xA3 ; number of external eeprom chip (0..7)
mem_alow EQU 0xA4 ; address select, low byte
mem_ahigh EQU 0xA5 ; address select, high byte
mem_chip EQU 0xA6 ; chip select for (block) write operations to external eeprom
regpointer EQU 0xA7 ; register pointer in block buffer
bitpointer EQU 0xA8 ; bit pointer in block buffer
bitcounter EQU 0xA9 ; temporary counter used in shift operations for block buffer storage
bitmask EQU 0xAA ; mask for one bit add operation in block buffer
databyte0 EQU 0xAB ; used in copy and shift operations for storing data in the block buffer
databyte1 EQU 0xAC ; used in copy and shift operations for storing data in the block buffer
databyte2 EQU 0xAD ; used in copy and shift operations for storing data in the block buffer
toc_pointer EQU 0xAE ; pointer for table of contents in internal eepromm
blockbuff00 EQU 0xAF ; location of first byte in 64 byte block buffer for writes to external eeprom
blockbuff63 EQU 0xEE ; location of last byte in block buffer (same locations as rx_buffer in bank0 !)
toc_test EQU 0xEF ; testing for free location in table of contents in internal eeprom
; variables used in bank 2 (Hex 10-6F)
iee_address EQU 0x10 ; pointer for write operations to pic internal eeprom
timer1y EQU 0x11 ; extend range of timer1 with one byte to three bytes
timer1z EQU 0x12 ; extend range of timer1 with one byte to four bytes
new1cap0 EQU 0x13 ; captures byte 0 of timer 1
new1cap1 EQU 0x14 ; captures byte 1 of timer 1
new1cap2 EQU 0x15 ; captures byte 2 of timer 1
new1cap3 EQU 0x16 ; captures byte 3 of timer 1
old1cap0 EQU 0x17 ; holds previous value of captured byte 0 of timer 1
old1cap1 EQU 0x18 ; holds previous value of captured byte 1 of timer 1
old1cap2 EQU 0x19 ; holds previous value of captured byte 2 of timer 1
old1cap3 EQU 0x1A ; holds previous value of captured byte 3 of timer 1
new2cap0 EQU 0x1B ; captures byte 0 of timer 1
new2cap1 EQU 0x1C ; captures byte 1 of timer 1
new2cap2 EQU 0x1D ; captures byte 2 of timer 1
new2cap3 EQU 0x1E ; captures byte 3 of timer 1
old2cap0 EQU 0x1F ; holds previous value of captured byte 0 of timer 1
old2cap1 EQU 0x20 ; holds previous value of captured byte 1 of timer 1
old2cap2 EQU 0x21 ; holds previous value of captured byte 2 of timer 1
old2cap3 EQU 0x22 ; holds previous value of captured byte 3 of timer 1
divcounter EQU 0x23 ; used in division routine
nrator0 EQU 0x24 ; used in division routine
nrator1 EQU 0x25 ; used in division routine
nrator2 EQU 0x26 ; used in division routine
nrator3 EQU 0x27 ; used in division routine
denom_r0 EQU 0x28 ; used in division routine of ccp1 (RPM)
denom_r1 EQU 0x29 ; used in division routine
denom_r2 EQU 0x2A ; used in division routine
denom_r3 EQU 0x2B ; used in division routine
denom_s0 EQU 0x2C ; used in division routine of ccp2 (Speed)
denom_s1 EQU 0x2D ; used in division routine
denom_s2 EQU 0x2E ; used in division routine
denom_s3 EQU 0x2F ; used in division routine
remain0 EQU 0x30 ; used in division routine
remain1 EQU 0x31 ; used in division routine
remain2 EQU 0x32 ; used in division routine
remain3 EQU 0x33 ; used in division routine
rpm_low EQU 0x34 ; engine rpm, result low byte of division
rpm_high EQU 0x35 ; engine rpm, result high byte of division
speed EQU 0x36 ; vehicle speed, result byte of division
mult_a0 EQU 0x37 ; used in 16 bit multiplication routine
mult_a1 EQU 0x38 ; used in 16 bit multiplication routine
mult_b0 EQU 0x39 ; used in 16 bit multiplication routine
mult_b1 EQU 0x3A ; used in 16 bit multiplication routine
speed_const0 EQU 0x3B ; used in 16 bit multiplication routine
speed_const1 EQU 0x3C ; used in 16 bit multiplication routine, 32 bit result
speed_const2 EQU 0x3D ; used in 16 bit multiplication routine, 32 bit result
speed_const3 EQU 0x3E ; used in 16 bit multiplication routine, 32 bit result
multcounter EQU 0x3F ; used in 16 bit multiplication routine, 32 bit result
rpmmax_low EQU 0x40 ; maximum rpm rate, low byte, copied from eeprom
rpmmax_high EQU 0x41 ; maximum rpm rate, high byte, copied from eeprom
rpmmax_0 EQU 0x42 ; maximum rpm rate time interval, least significant byte, used in comparison for shift light
rpmmax_1 EQU 0x43 ; maximum rpm rate time interval, more significant byte 1, used in comparison for shift light
rpmmax_2 EQU 0x44 ; maximum rpm rate time interval, more significant byte 2, used in comparison for shift light
rpmmax_3 EQU 0x45 ; maximum rpm rate time interval, most significant byte, used in comparison for shift light
ccp1interval0 EQU 0x46 ; temporary rpm interval storage
ccp1interval1 EQU 0x47 ; temporary rpm interval storage
ccp1interval2 EQU 0x48 ; temporary rpm interval storage
ccp1interval3 EQU 0x49 ; temporary rpm interval storage
ccp2interval0 EQU 0x4A ; temporary speed interval storage
ccp2interval1 EQU 0x4B ; temporary speed interval storage
ccp2interval2 EQU 0x4C ; temporary speed interval storage
ccp2interval3 EQU 0x4D ; temporary speed interval storage
intervalr0 EQU 0x4E ; present timer1 value
intervalr1 EQU 0x4F ; present timer1 value
intervalr2 EQU 0x50 ; present timer1 value
intervalr3 EQU 0x51 ; present timer1 value
intervals0 EQU 0x52 ; present timer1 value
intervals1 EQU 0x53 ; present timer1 value
intervals2 EQU 0x54 ; present timer1 value
intervals3 EQU 0x55 ; present timer1 value
lastintr0 EQU 0x56 ; interval between last two rpm pulses
lastintr1 EQU 0x57 ; interval between last two rpm pulses
lastintr2 EQU 0x58 ; interval between last two rpm pulses
lastintr3 EQU 0x59 ; interval between last two rpm pulses
lastints0 EQU 0x5A ; interval between last two speed pulses
lastints1 EQU 0x5B ; interval between last two speed pulses
lastints2 EQU 0x5C ; interval between last two speed pulses
lastints3 EQU 0x5D ; interval between last two speed pulses
pulses EQU 0x5E ; number of pulses per crankshaft revolution
; not used
; not used
; not used
clockaddr EQU 0x66 ; holds address for static ram and control byte operations in IIC clock chip
clockdata EQU 0x67 ; temporary storage for data for static ram operations
seconds EQU 0x68 ; buffer for IIC clock chip settings
minutes EQU 0x69 ;
hours EQU 0x6A ;
day EQU 0x6B ;
date EQU 0x6C ;
month EQU 0x6D ;
year EQU 0x6E ;
clockctrl EQU 0x6F ; settings byte in clock chip
; variables used in bank 3 (Hex 90-EF)
tablepointer EQU 0x90 ; used in table lookups
logcounter EQU 0x91 ; counter used during logger, increased every 1/32 of a second
freq_rpm EQU 0x92 ; setting for log frequency of rpm channel
freq_speed EQU 0x93 ;
freq_lambda EQU 0x94 ;
freq_voltage EQU 0x95 ;
freq_tc EQU 0x96 ;
freq_air EQU 0x97 ;
freq_water EQU 0x98 ;
freq_throttle EQU 0x99 ;
freq_long EQU 0x9A ;
freq_lat EQU 0x9B ;
freq_mark EQU 0x9C ;
freq_brake EQU 0x9D ;
num_records EQU 0x9E ; counter for number of records
current_rec EQU 0x9F ; select record for downloading
rec_loopcntr EQU 0xA0 ; byte used in addition loop
pointer_low EQU 0xA1 ; pointer to record data in external memory
pointer_high EQU 0xA2 ;
pointer_chip EQU 0xA3 ;
endpoint_low EQU 0xA4 ; pointer to end of record data in external memory
endpoint_high EQU 0xA5 ;
endpoint_chip EQU 0xA6 ;
recsizea0 EQU 0xA7 ; registers used in record size calculation
recsizea1 EQU 0xA8 ;
recsizea2 EQU 0xA9 ;
recsizeb0 EQU 0xAA ;
recsizeb1 EQU 0xAB ;
recsizeb2 EQU 0xAC ;
;---------------------------------------------------------------------------------------------------------------------------
;---------------------------------------------------------------------------------------------------------------------------
; Data EEPROM Contents (PIC16F877: 256 bytes)
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
org h'2100' ; start of eeprom data memory
de d'175' ; 000 vehicle outer wheel circumference in millimeters (default 1967 mm), low byte
de d'7' ; 001 vehicle outer wheel circumference in millimeters, high byte
de d'255' ; 002 maximum rpm rate (default 10000 rpm) [0..16383], low byte
de d'63' ; 003 maximum rpm rate high byte
de d'2' ; 004 pulses per revolution
de d'0' ; 005
de d'0' ; 006
de d'0' ; 007
de d'0' ; 008
de d'0' ; 009
de d'0' ; 010
de d'0' ; 011
de d'0' ; 012
de d'0' ; 013
de d'0' ; 014
de d'0' ; 015 error flags bits, any errors during logging are stored here
de b'11111111' ; 016 rpm, channel logging frequency values
de b'11111111' ; 017 speed logrates (see also 'logdata' routine):
de b'11111111' ; 018 lambda
de b'11111111' ; 019 voltage 00000000 32 Hz
de b'11111111' ; 020 thermocouple 00000001 16 Hz
de b'11111111' ; 021 air temperature 00000011 8 Hz
de b'11111111' ; 022 water temperature 00000111 4 Hz
de b'11111111' ; 023 throttle 00001111 2 Hz
de b'11111111' ; 024 long acceleration 00011111 1 Hz or every second
de b'11111111' ; 025 lat acceleration 00111111 1/2 Hz or every 2 seconds
de b'11111111' ; 026 mark switch 01111111 1/4 Hz or every 4 seconds
de b'11111111' ; 027 brake switch 11111111 never
de d'0' ; 028
de d'0' ; 029
de d'0' ; 030
de d'0' ; 031
de d'0' ; 032
de d'0' ; 033
de d'0' ; 034
de d'0' ; 035
de d'0' ; 036
de d'0' ; 037
de d'0' ; 038
de d'0' ; 039
de d'0' ; 040
de d'0' ; 041
de d'0' ; 042
de d'0' ; 043
de d'0' ; 044
de d'0' ; 045
de d'0' ; 046
de d'0' ; 047
de d'0' ; 048
de d'0' ; 049
de d'0' ; 050
de d'0' ; 051
de d'0' ; 052
de d'0' ; 053
de b'1' ; 054 record incremental number
de b'0' ; 055 record incremental number
de d'0' ; 1, 056 start location of table of contents for data records
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; all bytes clear because nothing been recorded yet
de d'0' ; 2
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 3
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 4
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 5
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 6
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 7
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 8
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 9
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 10
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 11
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 12
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 13
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 14
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 15
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 16
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 17
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 18
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 19
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ; 20
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
de d'0' ;
;######################################################################################################################################
; Start of program code
;######################################################################################################################################
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
org h'0000' ; tell the assembler to place following program code at the processor reset vector,
; which is the start of program memory page 0
; this code executes when a reset occurs
; Note: The contents of the PCLATH register are unchanged after a RETURN or RETFIE instruction
; is executed ! The user must rewrite the contents of the PCLATH register for any subsequent
; subroutine calls or goto instructions (meaning: make sure page bits are set properly !)
RESET bcf pclath,3 ; select program memory page 0 (hex 0000 up to hex 07FF)
bcf pclath,4 ; select program memory page 0 (hex 0000 up to hex 07FF)
clrf status ; ensure bank bits are clear
goto INITIALIZE ; skip interrupt routine and subroutines and go to beginning of program
;--------------------------------------------------------------------------------------------------------------------------------------
org h'0004' ; tell the assembler to place following program code at interrupt vector location
; this code executes when an interrupt occurs
INTERRUPT movwf w_temp ; save off current w register contents (will be stored in any bank !)
swapf status,w ; swap status to be saved into w
movwf status_temp ; save status register to status_temp register in bank 0
clrf status ; bank 0, regardless of current bank, clears irp,rp1,rp0 (for other than 16F877)
movf fsr,w ; save fsr register
movwf fsr_temp ;
movf pclath,w ; only required if using pages 1,2 and/or 3
movwf pclath_temp ; save pclath
clrf pclath ; select page zero, regardless of current page
; see what caused the interrupt and act upon it:
; page selection should not change in interrupt routines
bsf flags2,norpm ; assume we will not get rpm or speed pulses
bsf flags2,nospeed ; flag will be reset in ccp1 and ccp2 interrupt code
bank0 ; test if the CCP1 module did a capture, if so, go calculate engine rpm pulse interval, but
btfsc pir1,ccp1if ; only if we can use the present timer 1 values as we may get ccp and timer 1 irq's
call INT_CCP1 ; at the same time ! else we wait until the timer 1 value has been increased, bank0 return
bank0 ; test if the CCP2 module did a capture, if so, go calculate speed pulse interval, but
btfsc pir2,ccp2if ; only if we can use the present timer 1 values as we may get ccp and timer 1 irq's
call INT_CCP2 ; at the same time ! else we wait until the timer 1 value has been increased
bank0
btfsc pir1,tmr1if ; test if timer 1 (which has 16 bits) has overflowed from 65535 to 0
call INT_TIMER1 ; if so, go increase the two extra counter bytes we use to extend the range, bank0 return
bank0 ;
btfsc pir1,rcif ; test if UART has received a byte from a connected computer through the RS232
call INT_RX ; if so, store valid bytes in buffer until command is complete, then set command flag
call INT_SHIFT ; when calculated rpm rate is more than the given maximum turn on shift light, bank0 return
; done handling interrupts
INT_RESTORE bank0 ; make sure we are in the right bank (for other than 16F877)
movf pclath_temp,w ; restore the register contents to their values from before the interrupt
movwf pclath ; restore pclath
movf fsr_temp,w ;
movwf fsr ; restore fsr
swapf status_temp,w ; swap status_temp register into w (sets bank to original state)
movwf status ; restore pre-isr status register contents
swapf w_temp,f ;
swapf w_temp,w ; restore pre-isr w register contents
retfie ; return from interrupt, re-enable interrupts
;--------------------------------------------------------------------------------------------------------------------------------------
; Handle Timer1 overflow interrupt
;--------------------------------------------------------------------------------------------------------------------------------------
INT_TIMER1 bank2 ;
incf timer1y,f ; increase the lower of two bytes which are used to extend the range of timer 1 to a
skpnz ; total of four bytes, did this byte roll over from 255 to 0 ?
incf timer1z,f ; yes, also increase the upper of the two bytes
btfsc flags2,norpm ; did we get a rpm pulse ?
call INT_DROP_RPM ; no, calculate a dropping rpm rate, bank2 return
btfsc flags2,nospeed ; did we get a speed pulse ?
call INT_DROP_SPEED ; no, calculate a dropping speed value, bank2 return
INT_TIMER1_SL movlw b'11111111' ; now see about the shift light, this is value for all leds on
btfsc timer1y,0 ; we use this timer bit to flash the shift light as a stroboscope, is this bit high ?
btfss flags2,shlight ; yes, so should we turn on the shift light ?
clrw ; no, value for all leds off
bank20 ;
movwf portd ; yes, turn shift light on
bcf pir1,tmr1if ; clear timer 1 receive interrupt flag bit
return ; done, return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
; Handle CCP1 capture interrupt
;--------------------------------------------------------------------------------------------------------------------------------------
INT_CCP1 ; since we can have both timer 1 overflow and ccp interrupt request at the same
; time it is important to update the timer 1 extension bytes at the right time,
; now see if we can use the present timer 1 values to calculate the engine RPM rate
; from CCP module 1 using the time (t) between two captures, otherwise we exit this
; routine and come back later when timer 1 has been incremented
; here we calculate the interval given by the rpm rate and use it to turn on or off the
; the so called 'shift light' to let the driver know it is time to shift gears,
; we do not want to calculate the actual RPM value on every interrupt since the division
; routine takes up too much processor time, the actual rpm calculation in done during logging
; or command execution
; engine RPM rate calculation:
; F [Hz] = 1 / t [s]
; RPM = 60 / t [s]
; RPM = 60 * timer1clockrate / interval [timer cycles]
; RPM = (60 * 3686400/4) Mhz / interval [instruction cycles]
; RPM = 55,296,000 / interval [instruction cycles]
; RPM = 55,296,000 / (capturevalue - previouscapturevalue)
; RPM = 55,296,000 / (new1cap - old1cap)
; quotient = numerator / denominator
; calculate interval (32 bits) and store result in denom:
; current = timer1z timer1y ccpr1h ccpr1l
; new = new1cap3 new1cap2 new1cap1 new1cap0
; old = old1cap3 old1cap2 old1cap1 old1cap0
; interval = denom_r3 denom_r2 denom_r1 denom_r0
; see also CALC_RPM and COPY_RPM routines
bcf flags2,norpm ; we did get a rpm pulse
INT_CCP1_STORE bank02 ; yes, continue and handle CCP1 interrupt request
movf new1cap0,w ; store previous captured values
movwf old1cap0 ;
movf new1cap1,w ;
movwf old1cap1 ;
movf new1cap2,w ;
movwf old1cap2 ;
movf new1cap3,w ;
movwf old1cap3 ;
INT_CCP1_CAPT bank20 ; get capture moment
movf ccpr1l,w ; get first captured byte
bank02 ;
movwf new1cap0 ;
movwf ccp1interval0 ;
bank20 ;
movf ccpr1h,w ; get second captured byte
bank02 ;
movwf new1cap1 ;
movwf ccp1interval1 ;
movf timer1y,w ; get third timer byte
movwf new1cap2 ;
movwf ccp1interval2 ;
movf timer1z,w ; get newly capture values, first get the fourth timer byte
movwf new1cap3 ;
movwf ccp1interval3 ;
INT_CCP1_CHECK bank20
btfss pir1,tmr1if ; do we also have a timer 1 overflow interrupt request ?
goto INT_CCP1_SUB ; no, so it is ok to handle the CCP1 interrupt request
movlw d'128' ; yes, now see if we can use the current timer 1 value (use halfway value)
subwf ccpr1h,w ; any capture from (long) before the timer 1 overflow must use old timer values
skpnc ; was the capture from before the timer 1 overflow ?
goto INT_CCP1_SUB ; yes,
bank02 ;
incf ccp1interval2,f ; no, increase timer 1 bytes 3 and 4
incf new1cap2,f ;
skpnz ;
incf ccp1interval3,f ;
movf ccp1interval3,w ;
movwf new1cap3 ;
INT_CCP1_SUB bank02 ;
movf old1cap0,w ; subtraction, calculate the actual interval
subwf ccp1interval0,f ; store interval byte 0
movf old1cap1,w ;
skpc ;
incfsz old1cap1,w ;
subwf ccp1interval1,f ;
movf old1cap2,w ;
skpc ;
incfsz old1cap2,w ;
subwf ccp1interval2,f ;
movf old1cap3,w ;
skpc ;
incfsz old1cap3,w ;
subwf ccp1interval3,f ;
INT_CCP1_LAST movf ccp1interval0,w ; copy time interval between last two pulses
movwf lastintr0 ;
movf ccp1interval1,w ;
movwf lastintr1 ;
movf ccp1interval2,w ;
movwf lastintr2 ;
movf ccp1interval3,w ;
movwf lastintr3 ;
INT_CCP1_DONE bank20 ;
bcf pir1,ccp1if ; clear capture 1 interrupt flag
return ; we're done here, return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
; Handle CCP2 capture interrupt
;--------------------------------------------------------------------------------------------------------------------------------------
INT_CCP2 ; since we can have both timer 1 overflow and ccp interrupt request at the same
; time it is important to update the timer 1 extension bytes at the right time,
; now see if we can use the present timer 1 values to calculate the vehicle speed
; from CCP module 2 using the time (t) between two captures, otherwise we exit this
; routine and come back later when timer 1 has been incremented
bcf flags2,nospeed ; we did get a speed pulse
INT_CCP2_STORE bank02 ; yes,
movf new2cap0,w ; store previous captured values
movwf old2cap0 ;
movf new2cap1,w ;
movwf old2cap1 ;
movf new2cap2,w ;
movwf old2cap2 ;
movf new2cap3,w ;
movwf old2cap3 ;
INT_CCP2_CAPT bank20 ; get capture moment
movf ccpr2l,w ; get first captured byte
bank02 ;
movwf new2cap0 ;
movwf ccp2interval0 ;
bank20 ;
movf ccpr2h,w ; get second captured byte
bank02 ;
movwf new2cap1 ;
movwf ccp2interval1 ;
movf timer1y,w ; get third timer byte
movwf new2cap2 ;
movwf ccp2interval2 ;
movf timer1z,w ; get newly capture values, first get the fourth timer byte
movwf new2cap3 ;
movwf ccp2interval3 ;
INT_CCP2_CHECK bank20
btfss pir1,tmr1if ; do we also have a timer 1 overflow interrupt request ?
goto INT_CCP2_SUB ; no, so it is ok to handle the CCP2 interrupt request
movlw d'128' ; yes, now see if we can use the current timer 1 value (use halfway value)
subwf ccpr2h,w ; any capture from (long) before the timer 1 overflow must use old timer values
skpnc ; was the capture from before the timer 1 overflow ?
goto INT_CCP2_SUB ; yes,
bank02 ;
incf ccp2interval2,f ; no, increase timer 1 bytes 3 and 4
incf new2cap2,f ;
skpnz ;
incf ccp2interval3,f ;
movf ccp2interval3,w ;
movwf new2cap3 ;
INT_CCP2_SUB bank02 ;
movf old2cap0,w ; subtraction, the resulting interval is put in denominator
subwf ccp2interval0,f ; store interval byte 0 for use in division routine
movf old2cap1,w ;
skpc ; is capture0 - hold0 < 0 ?
incfsz old2cap1,w ; yes, 'borrow' from more significant byte
subwf ccp2interval1,f ; no, borrow has been skipped, do subtraction and store for use in division
movf old2cap2,w ;
skpc ;
incfsz old2cap2,w ;
subwf ccp2interval2,f ;
movf old2cap3,w ;
skpc ;
incfsz old2cap3,w ;
subwf ccp2interval3,f ;
INT_CCP2_LAST movf ccp2interval0,w ; copy time interval between last two pulses
movwf lastints0 ;
movf ccp2interval1,w ;
movwf lastints1 ;
movf ccp2interval2,w ;
movwf lastints2 ;
movf ccp2interval3,w ;
movwf lastints3 ;
INT_CCP2_DONE bank20 ;
bcf pir2,ccp2if ; clear capture 2 interrupt flag
return ; done, return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
INT_DROP_RPM ; Drop the speed value (calculate pulse interval) in case we do not get speed pulses anymore
INT_DROP_R_NOW bank2 ;
clrf intervalr0 ; get present timer1 value (now)
clrf intervalr1 ; at the moment of overflow these values became zero
movf timer1y,w ; get third timer byte
movwf intervalr2 ;
movf timer1z,w ;
movwf intervalr3 ; store in rpm interval
INT_DROP_R_SUB movf new1cap0,w ; calculate rpm value when we do not have any rpm pulses on the input
subwf intervalr0,f ; subtraction, calculate the time interval between the last pulse and now
movf new1cap1,w ; store the result in intervalr0-3
skpc ;
incfsz new1cap1,w ;
subwf intervalr1,f ;
movf new1cap2,w ;
skpc ;
incfsz new1cap2,w ;
subwf intervalr2,f ;
movf new1cap3,w ;
skpc ;
incfsz new1cap3,w ;
subwf intervalr3,f ;
INT_DROP_R_TEST movf intervalr0,w ; is the time interval between the last pulse and now larger than the time between
subwf lastintr0,w ; the last two pulses ?
movf intervalr1,w ;
skpc ;
incfsz intervalr1,w ;
subwf lastintr1,w ;
movf intervalr2,w ;
skpc ;
incfsz intervalr2,w ;
subwf lastintr2,w ;
movf intervalr3,w ;
skpc ;
incfsz intervalr3,w ;
subwf lastintr3,w ;
skpnc ;
return ; no, do nothing
INT_DROP_R_YES movf intervalr0,w ; copy the new (longer) interval value so we drop the rpm rate
movwf ccp1interval0 ;
movf intervalr1,w ;
movwf ccp1interval1 ;
movf intervalr2,w ;
movwf ccp1interval2 ;
movf intervalr3,w ;
movwf ccp1interval3 ;
INT_DROP_R_OVR movlw d'255' ; timer1 and the extra bytes will overflow, this will affect the interval value indirectly
subwf ccp1interval3,w ; since the new1cap values will stay the same, so we have to adjust the new1cap values
skpz ; is the value of the interval about to overflow ?
return ; no, done
rlf new1cap3,f ; yes, get the most significant bit of new1cap
skpc ; toggle it's value
setc ; this will move the new1cap value in time
skpnc ; so the interval value will be decreased but still very long to show zero rpm
clrc ;
rrf new1cap3,f ;
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
; See if we are getting input pulses of rpm and speed, otherwise calculate dropping rpm and speed values
;--------------------------------------------------------------------------------------------------------------------------------------
INT_DROP_SPEED ; calculate dropping rpm and speed values
; Drop the rpm rate (calculate new rpm pulse interval) in case we do not get rpm pulses anymore
INT_DROP_S_NOW bank2 ;
clrf intervals0 ; get present timer1 value (now)
clrf intervals1 ; at the moment of overflow these values became zero
movf timer1y,w ; get third timer byte
movwf intervals2 ;
movf timer1z,w ;
movwf intervals3 ; store in speed interval
INT_DROP_S_SUB movf new2cap0,w ; subtraction, calculate the time interval between the last pulse and now
subwf intervals0,f ; store the result in intervals0-3
movf new2cap1,w ;
skpc ;
incfsz new2cap1,w ;
subwf intervals1,f ;
movf new2cap2,w ;
skpc ;
incfsz new2cap2,w ;
subwf intervals2,f ;
movf new2cap3,w ;
skpc ;
incfsz new2cap3,w ;
subwf intervals3,f ;
INT_DROP_S_TEST movf intervals0,w ; is the time interval between the last pulse and now larger than the time between
subwf lastints0,w ; the last two pulses ?
movf intervals1,w ;
skpc ;
incfsz intervals1,w ;
subwf lastints1,w ;
movf intervals2,w ;
skpc ;
incfsz intervals2,w ;
subwf lastints2,w ;
movf intervals3,w ;
skpc ;
incfsz intervals3,w ;
subwf lastints3,w ;
skpnc ;
return ; no, do nothing
INT_DROP_S_YES movf intervals0,w ; yes, copy the new (longer) interval value so we drop the speed value
movwf ccp2interval0 ;
movf intervals1,w ;
movwf ccp2interval1 ;
movf intervals2,w ;
movwf ccp2interval2 ;
movf intervals3,w ;
movwf ccp2interval3 ;
INT_DROP_S_OVR movlw d'255' ; timer1 and the extra bytes will overflow, this will affect the interval value indirectly
subwf ccp2interval3,w ; since the new2cap values will stay the same, so we have to adjust the new2cap values
skpz ; is the value of the interval about to overflow ?
return ; no, done
rlf new2cap3,f ; yes, get the most significant bit of new1cap
skpc ; toggle it's value
setc ; this will move the new2cap value in time
skpnc ; so the interval value will be decreased but still very long to show zero speed value
clrc ;
rrf new2cap3,f ;
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
INT_SHIFT ; when the calculated rpm value is more than the given maximum turn on the shift light
; t [s] = 1 / F [Hz]
; t [s] = 60 / RPM
; interval [timer cycles] = 60 * timer1clockrate / RPM
; interval [instruction cycles] = (60 * 3686400/4) MHz / RPM
; interval [instruction cycles] = 55,296,000 / RPM
; (capturevalue - previouscapturevalue) = 55,296,000 / RPM
; (new1cap - old1cap) = 55,296,000 / RPM
; denominator1 (from ccp1 routine) = 55,296,000 / RPM
; so we want to compare the denominator1 value with the four interval bytes:
; interval : rpmmax_3 rpmmax_2 rpmmax_1 rpmmax_0
; which we have calculated at initialization from the two maximum rpm bytes
; rpm max : rpmmax_high rpmmax_low
bank2 ;
movf ccp1interval0,w ; subtraction, when the measured rpm value is more than the set maximum we should turn on the
subwf rpmmax_0,w ; so called 'shift light' to let the driver know it is time to shift gears
movf ccp1interval1,w ; so turn on if: rpmmax - denominator (=interval) > 0
skpc ; is capture0 - hold0 < 0 ?
incfsz ccp1interval1,w ; yes, 'borrow' from more significant byte
subwf rpmmax_1,w ; no, borrow has been skipped, do subtraction
movf ccp1interval2,w ;
skpc ;
incfsz ccp1interval2,w ;
subwf rpmmax_2,w ;
movf ccp1interval3,w ;
skpc ;
incfsz ccp1interval3,w ;
subwf rpmmax_3,w ;
bank20 ;
skpc ; should we turn off the shift light ?
INT_SHIFT_OFF bcf flags2,shlight ; yes, rpm rate is smaller than given maximum, turn shift light (flag) off, flag used in timer
skpc ; again, should we turn off the shift light ?
clrf portd ; yes, turn shift light off
skpnc ; should we turn on the shift light ?
INT_SHIFT_ON bsf flags2,shlight ; yes, with this high rpm rate, turn shift light flag on, used in timer interrupt to flash light
return ; done, return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
; Handle UART receive interrupt
;--------------------------------------------------------------------------------------------------------------------------------------
; input bytes are stored in buffer for later use when the received command is going to be
; interpreted and executed
; check for command byte sequence, if all bytes of a command have been received set the flag
; bit that allows the command execute routine
; a valid command byte sequence is (in ascii):
; <STX> 1 byte indicator for start of command, value hex 02
; <c1> 1 byte, first letter of command
; <c2> 1 byte, second letter of command
; <data bytes> 0-64 data bytes, all values accepted except ascii codes STX and ETX
; <ETX> 1 byte indicator for end of command, value hex 03
; <checksum> 1 byte checksum, any hex value 00-FF (incl.hex 03 !), last byte of command
; the checksum byte value makes the sum of all bytes from <STX> up to and including <ETX> zero
; used bits for uart in flags register:
; bit 0 = high : STX received, started reception of rest of command
; bit 1 = high : ETX received, now wait for checksum
; bit 2 = high : command has data bytes
; bit 3 = high : all bytes received, now ready for execution of command
INT_RX bank0
bsf portc,cts_out ; clear CTS to hold data stream from computer
btfsc rcsta,oerr ; overrun error ?
goto OVERFLOW_ERR ; yes, we cannot keep up with the input, go discard input
btfsc rcsta,ferr ; no, framing error ?
goto FRAMING_ERR ; yes, go discard input
movlw b'00000001' ; no, select rx9d/parity bit (we use odd parity)
andwf rcsta,w ; store only the parity bit in w register
movwf rx_parity ; copy the value to rx_parity
movf rcreg,w ; deque received byte
movwf rx_byte ; store byte for later use
CHECK_PARITY xorwf rx_parity,f ; use parity bit in calculation
swapf rx_parity,w ; use w and rx_parity register for the calculation
xorwf rx_parity,f ; calculate nibbles
rrf rx_parity,w ;
xorwf rx_parity,f ; at this point the parity values of the nibbles are in bit 2 and bit 0
btfss rx_parity,2 ; if parity one nibble is 1 then whole byte parity equals that of other nibble, skip ahead
incf rx_parity,f ; otherwise, invert bit 0
btfsc rx_parity,0 ; parity error ?
goto PARITY_ERR ; yes
btfsc flags1,command ; no, did we already receive a command or are we busy executing one ?
return ; yes, discard input,seems handshaking is ignored, but we cannot accept a new command right now
VALID_BYTE movf rx_byte,w ; if we get here we have received valid input
sublw h'02' ; ascii code for 'start of text' (STX)
skpnz ; check if byte matches
goto COMMAND_START ; match, go set flags to allow reception of rest of command
STX? btfss flags1,stx ; no match, but did we already receive the STX byte ?
goto NO_ERR ; no, do not use any received byte until STX has been received first
ADD_TO_CS movf rx_byte,w ; yes, received byte is in rx_byte, what was it again ?
addwf rx_checksum,f ; use all bytes including the checksum byte in the checksum calculation
CHECKSUM? btfsc flags1,etx ; did we already receive all bytes of the command and is this the checksum byte ?
goto CHECK_SUM ; yes, go test checksum
ETX? sublw h'03' ; ascii code for 'end of text' (ETX)
skpnz ; did we receive (ETX) and therefore all command and data bytes ?
goto GOT_ETX ; yes, go set flag and exit
OVERFLOW? movlw rx_buffer66 + 1 ; no, check if pointer has passed the maximum allowed address
subwf rx_pointer,w ; see where the pointer is
skpnz ; already there ?
goto ABORT_COMMAND ; yes, too many data bytes: abort receiving this command
STORE movf rx_pointer,w ; get the available address for storage of the newly received data byte
movwf rx_maxpos ; store the pointer, keep the position of the last data byte
movwf fsr ; use value to set the indirect file address
bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
movf rx_byte,w ; what was the received byte again ?
movwf indf ; store it in the command input buffer
INC_POINTER incf rx_pointer,f ; go point to next position for any following byte
goto NO_ERR ; done handling the received byte, return in bank0
COMMAND_START movlw h'02' ; the value of STX should be
movwf rx_checksum ; the initial checksum value
movlw rx_buffer00 ; first position in the input buffer for command bytes
movwf rx_pointer ; use this value to reset pointer
movwf rx_maxpos ; reset the pointer to the last received data byte
bsf flags1,stx ; set flag 'STX has been received, wait for the rest of the command bytes'
bcf flags1,withdata ; clear flag for data bytes
goto NO_ERR ; done handling the received byte, return in bank0
CHECK_SUM movf rx_checksum,w ; the checksum is the sum of all bytes added together and should be zero
skpz ; is checksum ok ?
goto ABORT_COMMAND ; no, go abort the reception of the command
CHECK_SIZE movlw rx_buffer01 ; yes, second position in buffer
subwf rx_maxpos,w ; test if the last command byte has been placed at the second place or further,
skpc ; so did we get at least two command bytes ?
goto ABORT_COMMAND ; no, go abort the reception of the command
skpz ; did we get more than three bytes ?
bsf flags1,withdata ; yes, set flag 'this is a command with data'
bsf flags1,command ; set flag to get command executed
bcf flags1,stx ; now ok to reset stx flag for a next command
bcf flags1,etx ; now ok to reset etx flag for a next command
return ; bytes have been handled, return without setting CTS to keep data stream blocked, bank0 return
GOT_ETX bsf flags1,etx ; we have received all command and data bytes, now wait for the checksum byte
bcf portc,cts_out ; set CTS to allow computer to send data
return ; done
ABORT_COMMAND bcf flags1,stx ; abort receiving command,
bcf flags1,etx ; clear any command bytes received up to now
movlw h'15' ; negative acknowledgement (NAK)
pagesel TX_BYTE ; make right page selection before call
call TX_BYTE ; send 'command has NOT been accepted', return in bank0
pagesel NO_ERR ; make right page selection before call
goto NO_ERR ; done handling the received byte, return in bank0
OVERFLOW_ERR movf rcreg,w ; deque byte (discard input byte)
movf rcreg,w ; deque byte (discard input byte)
bcf rcsta,cren ; clear overrun error bit
bsf rcsta,cren ; re-enable receive
bcf flags1,stx ; clear any command bytes received up to now
bcf flags1,etx ; clear any command bytes received up to now
bcf portc,cts_out ; set CTS to allow computer to send data
return ; done
FRAMING_ERR movf rcreg,w ; we did not deque received byte yet, do so now (discard input byte), update receive flags
PARITY_ERR bcf flags1,stx ; clear any command bytes received up to now
bcf flags1,etx ; clear any command bytes received up to now
NO_ERR bcf portc,cts_out ; set CTS to allow computer to send data
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
; Start of main program
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
INITIALIZE
INIT_INT_OFF clrf intcon ; ensure there are no interrupt requests
bank1 ;
clrf pie1 ; disable all pheripheral interrupts
clrf pie2 ;
INIT_CHECKPIC ; ******* check pic integrity: checksum pic program memory, set/reset sram bits
INIT_PORTA bank0 ; port A will have five analog inputs (note: port A is set as ANALOG i/o as default)
clrf porta ; clear output data latches
bank1 ;
movlw b'00111111' ;
movwf trisa ; make all six pins of port A inputs
; Port A0 = Input, Lambda sensor
; Port A1 = Input, Voltage In
; Port A2 = Input, Thermocouple
; Port A3 = Input, Air Temperature
; Port A4 = Input, clock input 32768 Hz from clock timer chip
; Port A5 = Input, Water Temperature
INIT_PORTB bank0 ; port B
clrf portb ; clear output data latches, make all outputs low
bank1 ;
movlw b'00111111' ;
movwf trisb ; make port B input & outputs
; Port B0 = Input Run
; Port B1 = Input _Mark_
; Port B2 = Input Brake
; Port B3 = Input Laptime
; Port B4 = Input _TC disconnected_
; Port B5 = Input BoardsupplyOn
; Port B6 = Output Status Led Red
; Port B7 = Output Status Led Green
INIT_PORTC bank0 ; inputs, communications port to computer (RS232) realtime clock and serial eeprom (IIC)
clrf portc ; clear output data latches
bank1 ;
movlw b'11111110' ;
movwf trisc ; set port C configuration
; Port C0 = Output computer CTS
; Port C1 = Input Speed
; Port C2 = Input RPM
; Port C3 = Input* SDA for MSSP IIC, configure as input
; Port C4 = Input* SCL for MSSP IIC, configure as input
; Port C5 = Input computer RTS
; Port C6 = Output* computer RX, configure as input
; Port C7 = Input computer TX
INIT_PORTD bank0 ; port D will drive eight pairs of leds (rpm meter/shift light)
clrf portd ; clear output data latches, all outputs low
bank1 ;
movlw b'00000000' ;
movwf trisd ; make port D all outputs
INIT_PORTE bank0 ; port E will have three analog inputs (note: port E is set as ANALOG i/o as default)
clrf porte ; clear output data latches
bank1 ;
movlw b'00000111' ; make port E all inputs
movwf trise ;
; Port E0 = Input Throttle
; Port E1 = Input XAccelleration
; Port E2 = Input YAccelleration
INIT_TIMER0 clrwdt ; clear watchdog timer to prevent unintended device reset
movlw b'10100001' ; we want 32 Hz interrupts using the 32768 Hz output from clock chip, divide by 4,
bank1 ; assign prescaler to timer0, increment from external clock on low-to-high,
movwf optionreg ; pull-ups on portb disabled, interrupt on falling edge of B0/int pin
bcf intcon,t0ie ; disable interrupt from timer 0, it will be enabled only during logging
INIT_TIMER1 bank0 ; use timer 1 as a timer/counter to count instruction cycles
movlw b'00000001' ; use internal instruction cycle clock divided by 1, turn on timer
movwf t1con ; configure timer 1
clrf tmr1l ; start timer at zero value
clrf tmr1h ; start timer at zero value
bank1 ;
bsf pie1,tmr1ie ; enable interrupt from timer 1
INIT_TIMER2 bank0 ;
movlw b'00000000' ;
movwf t2con ; disable timer 2
INIT_CCP1 bank1 ;
bsf trisc,2 ; make sure pin rc2/ccp1 is configured as input
bsf pie1,ccp1ie ; enable interupts from CCP1 module
bank0 ;
movlw b'00000101' ; capture mode, on every rising edge of pin rc2/ccp1
movwf ccp1con ;
INIT_CCP2 bank1 ;
bsf trisc,1 ; make sure pin rc1/t1osi/ccp2 is configured as input
bsf pie2,ccp2ie ; enable interrupt from CCP2 module
bank0 ;
movlw b'00000101' ; capture mode, on every rising edge of pin rc1/t1osi/ccp2
movwf ccp2con ;
INIT_IIC bank1 ; configure the MSSP Module as IIC bus, PIC is bus master
bcf pie1,sspie ; disable interrupt from ssp action
bcf pie2,bclie ; disable interrupt from ssp bus collision
movlw d'9' ; baud rate calculation: x = ((( Fosc / IICbaudrate)/4)-1) (~100 kHz @ 3.6864Mhz)
movwf sspadd ; set IIC baud rate to 100 kHz
bcf sspstat,cke ; select IIC input levels
bsf sspstat,smp ; set slew rate for standard speed mode (100 kHz)
bank0 ;
movlw b'00101000' ; enable serial port, master mode
movwf sspcon ; configure
pagesel IIC_START ; make right program memory page selection
call IIC_START ; send initialization sequence (see Microchip AN709): start, 9 ones, start, stop
bank0 ; to properly reset eeprom devices on iic bus (when circuit has been reset during write)
movlw b'11111111' ; send 8 times 1
movwf sspbuf ; send the slave address
bank1 ;
pagesel INIT_IIC_LOOP1 ; make right program memory page selection
INIT_IIC_LOOP1 btfsc sspstat,r_notw ; is the transmission completed ?
goto INIT_IIC_LOOP1 ; no, wait here until it is completed
bsf sspcon2,ackdt ; select NOACK
bsf sspcon2,acken ; send NOACK, 9th one bit
INIT_IIC_LOOP2 btfsc sspcon2,acken ; send completed ?
goto INIT_IIC_LOOP2 ; no, wait here until send has been completed
pagesel IIC_START ; make right program memory page selection
call IIC_START ;
call IIC_STOP ;
bank1 ;
clrf iicchip ; select first eeprom chip
INIT_AD bank1 ;
movlw b'10000000' ; right justified, five pins of port A and three pins of port E will be analog inputs,
movwf adcon1 ; note: more configuration is to be done in a/d subroutine
bcf pie1,adie ; disable interrupt from a/d module
INIT_UART bank1 ; configure UART for asynchronous communications
movlw d'3' ; value for baudrate (23:9600, 11:19200, 3:57600, 1:115200 baud Fosc=3.6864 MHz)
movwf spbrg ; set UART to this value
movlw b'01000110' ; 9 bit, Tx off, async, high speed (transmit: 8 data bits, odd parity , 1 stop bit)
movwf txsta ; load Tx status register
bank0 ;
movlw b'01010000' ; serial port disabled, 9 bit, Rx off (receive: 8 data bits, odd parity, 1 stop bit)
movwf rcsta ; load Rx status register
bsf rcsta,spen ; enable reception
bank1 ;
bsf txsta,txen ; enable transmission
bsf pie1,rcie ; enable interrupt on receive
bcf portc,cts_out ; set CTS to allow computer to send data
INIT_CLOCK movlw d'7' ; location of clock control byte
bank2 ;
movwf clockaddr ;
movlw b'10000011' ; clock control byte, set square wave at 32768 Hz but still disabled and it's output high
call IIC_WR_CLKCHIP ; write byte to control bytes or static ram of clock chip, returns in bank1
INIT_EEPROM nop ; ****** see if datalogger internal eeprom has ever been intialized, otherwise set defaults
INIT_VARIABLES clrf flags1 ; clear flag register1
clrf flags2 ; clear flag register2
bank2 ;
clrf timer1y ; range extension for timer1 byte three
clrf timer1z ; range extension for timer1 byte four
clrf new1cap0 ; make sure the rpm and speed values start at zero when there are no input pulses
clrf new1cap1 ;
clrf new1cap2 ;
clrf new1cap3 ;
clrf new2cap0 ;
clrf new2cap1 ;
clrf new2cap2 ;
clrf new2cap3 ;
clrf lastintr0 ;
clrf lastintr1 ;
clrf lastintr2 ;
clrf lastintr3 ;
clrf lastints0 ;
clrf lastints1 ;
clrf lastints2 ;
clrf lastints3 ;
bank3 ;
clrf current_rec ; no record selected for download
pagesel COPY_RPMVALUES ; make right program memory page selection
call COPY_RPMVALUES ; call all routines seperately because they have all returns
call COPY_WHEELC ; to be able to use them individually, return with page setting...
call COPY_LOGRATES ;
pagesel COPY_ERRORFLAGS ; restore program memory page selection
call COPY_ERRORFLAGS ; get values maximum rpm rate, wheel circumference, lograte values, error flag bits
INIT_INT_ON bank0
clrf pir1 ; clear all pheripheral interrupt request flags
clrf pir2 ;
bsf intcon,peie ; enable peripheral interrupts
bsf intcon,gie ; enable all interrupts
INIT_READY bsf portb,led_red ; turn on red status led as indication power on and software initialized
INIT_RUN ; empty line to avoid mplab error
pagesel MAIN ; make right program memory page selection
goto MAIN ; all initialization has been done, go run main code
;--------------------------------------------------------------------------------------------------------------------------------------
COPY_RPMVALUES ; reads the maximum rpm value from pic eeprom addresses, from this value the interval is
; calculated that will be used to turn on the shift light when the measured rpm rate is
; larger than the given maximum
; calculation below is for one pulse per revolution
; a correction is done for two pulses per revolution
; engine RPM rate calculation, see also INT_CCP1
; F [Hz] = 1 / t [s]
; RPM = 60 / t [s]
; RPM = 60 * timer1clockrate / interval [timer cycles]
; RPM = (60 * 3686400/4) Mhz / interval [instruction cycles]
; RPM = 55,296,000 / interval [instruction cycles]
; RPM = 55,296,000 / (capturevalue - previouscapturevalue)
; RPM = 55,296,000 / (new1cap - old1cap)
; quotient = numerator / denominator
; see also CALC_RPM and COPY_RPM routines
; calculate interval (input values are 32 bits, the result is 32 bits):
; t [s] = 1 / F [Hz]
; t [s] = 60 / RPMMAX
; interval [timer cycles] = 60 * timer1clockrate / RPMMAX
; interval [instruction cycles] = (60 * 3686400/4) MHz / RPMMAX
; interval [instruction cycles] = 55,296,000 / RPMMAX
; interval [instruction cycles] = 55,296,000 / RPMMAX
; interval [instruction cycles] = 55,296,000 / RPMMAX
; interval [instruction cycles] = 55,296,000 / RPMMAX
; rpmmax_3&2&1&0 = 55,296,000 / rpmmax_high&low
; quotient = numerator / denominator
; numerator : nrator3 nrator2 nrator1 nrator0
; denominator: denom_r3 denom_r2 denom_r1 denomr_0
; quotient : rpmmax_3 rpmmax_2 rpmmax_1 rpmmax_0
; remainder : remain3 remain2 remain1 remain0
; the remainder R is not used
; interval : rpmmax_3 rpmmax_2 rpmmax_1 rpmmax_0
; rpm max : rpmmax_high rpmmax_low
COPY_PULSES movlw d'4' ; pic eeprom address of low byte of rpm maximum
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
movwf pulses ; store value
COPY_RPM_READ movlw d'2' ; pic eeprom address of low byte of rpm maximum
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
movwf rpmmax_low ; store value, low byte
movlw d'3' ; eeprom address of high byte of rpm maximum
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
movwf rpmmax_high ; store value, high byte
pagesel COPY_RPM_DIV ; make right program memory page selection
COPY_CORRECTION btfsc pulses,0 ; do we have one pulse per revolution ?
goto COPY_RPM_DIV ; yes, go use the value as it is
clrc ; no, multiply the maxrpm value by two to correct for the number of pulses per revolution
rlf rpmmax_low ; low byte
rlf rpmmax_high ; high byte
COPY_RPM_DIV bank2 ;
movlw d'3' ; set numerator X = 55,296,000 = 3 : 75 : 192 : 0
movwf nrator3 ;
movlw d'75' ;
movwf nrator2 ;
movlw d'192' ;
movwf nrator1 ;
movlw d'0' ;
movwf nrator0 ;
clrf denom_r3 ; get denominator
clrf denom_r2 ;
movf rpmmax_high,w ;
movwf denom_r1 ;
movf rpmmax_low,w ;
movwf denom_r0 ;
movlw d'32' ; there are 32 bits in this division
movwf divcounter ;
clrf remain0 ; clear remainder
clrf remain1 ;
clrf remain2 ;
clrf remain3 ;
COPY_RPM_LOOP clrc ;
rlf nrator0,f ; shift next bit to remainder (msbit numerator to lsbit remainder)
rlf nrator1,f ;
rlf nrator2,f ;
rlf nrator3,f ;
rlf remain0,f ;
rlf remain1,f ;
rlf remain2,f ;
rlf remain3,f ;
COPY_RPM_TEST movf denom_r3,w ; subtract denominator from remainder, if no borrow then next bit of quotient is 1
subwf remain3,w ; if borrow next bit of the quotient is 0
skpz ; check, is the result of remain3 - denom3 exactly 0 ?
goto COPY_RPM_NOTZ ; no, go check for negative result
movf denom_r2,w ; yes, continue
subwf remain2,w ; do test subtraction
skpz ; check, is the result of remain2 - denom2 exactly 0 ?
goto COPY_RPM_NOTZ ; no, go check for negative result
movf denom_r1,w ; yes, continue
subwf remain1,w ; do test subtraction
skpz ; check, is the result of remain1 - denom1 exactly 0 ?
goto COPY_RPM_NOTZ ; no, go check for negative result
movf denom_r0,w ; yes, continue
subwf remain0,w ; do test subtraction
COPY_RPM_NOTZ skpc ; is the result of any remain - denom less than 0 thus negative ?
goto COPY_RPM_NOGO ; yes, skip subtraction, this quotient bit will be zero
COPY_RPM_SUB2 movf denom_r0,w ; no, start with real subtraction, the resulting interval is put in denominator
subwf remain0,f ;
movf denom_r1,w ;
skpc ; is remain0 - denom0 < 0 ?
incfsz denom_r1,w ; yes, 'borrow' from more significant byte
subwf remain1,f ; no, borrow has been skipped, do subtraction
movf denom_r2,w ;
skpc ; is remain1 - denom1 < 0 ?
incfsz denom_r2,w ; yes, 'borrow' from more significant byte
subwf remain2,f ; no, borrow has been skipped, do subtraction
movf denom_r3,w ;
skpc ; is remain2 - denom2 < 0 ?
incfsz denom_r3,w ; yes, 'borrow' from more significant byte
subwf remain3,f ; no, borrow has been skipped, do subtraction
setc ; this quotient bit is one
COPY_RPM_NOGO rlf rpmmax_0,f ; shift bit into quotient result
rlf rpmmax_1,f ; shift bit into quotient result
rlf rpmmax_2,f ; shift bit into quotient result
rlf rpmmax_3,f ; shift bit into quotient result
decfsz divcounter,f ;
goto COPY_RPM_LOOP ; go do next bit
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
COPY_WHEELC ; reads the wheel circumference in millimeters from pic eeprom,
; multiplies this value by 3318 and stores the result in speed_const0..3
; please see INT_CCP2 code for details
; to be used in the calculate speed/ccp2 interrupt routine
; calculate product (input values are 16 bits, the result is 32 bits):
; number1 : - - mult_a1 mult_a0
; number2 : - - mult_b1 mult_b0
; result P : speed_const3 speed_const2 speed_const1 speed_const0
; for minimum execution time number1 should be the smaller number of the two
MULT16X16 bank0 ; multiply the two 16-bit numbers 3318 and circumference and store the 32 bit result
movlw d'0' ; eeprom address of low byte of wheel diameter
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
movwf mult_a0 ; store first number in multiplication, low byte
bank0 ;
movlw d'1' ; eeprom address of high byte of wheel diameter
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
movwf mult_a1 ; store first number in multiplication, high byte
movlw d'246' ; 3318
movwf mult_b0 ; store second number in multiplication, low byte
movlw d'12' ;
movwf mult_b1 ; store second number in multiplication, high byte
clrf speed_const3 ; clear all four bytes of the 32 bit result
clrf speed_const2 ;
clrf speed_const1 ;
clrf speed_const0 ;
bsf speed_const1,7 ; set the 16th bit so we can use the speed_const registers as bit counter
clrc ; start off with clear carry
MULTLOOP rrf mult_a1,f ;
rrf mult_a0,f ;
pagesel MULTSHIFT ; make right program memory page selection
skpc ; was the least significant bit a one ?
goto MULTSHIFT ; no, bypass addition
movf mult_b0,w ; yes, do addition
addwf speed_const2,f ; add first of two bytes
movf mult_b1,w ;
skpnc ; check for overflow after add and
incfsz mult_b1,w ; increment high byte if necessary
addwf speed_const3,f ; add second of the two bytes
MULTSHIFT rrf speed_const3,f ; shift to next position
rrf speed_const2,f ;
rrf speed_const1,f ;
rrf speed_const0,f ;
skpc ; are we done with the multiplication ?
goto MULTLOOP ; no, next
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
COPY_LOGRATES ; copy the values from pic eeprom addresses to registers
movlw d'16' ; internal eeprom address
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
bank3 ;
movwf freq_rpm ; store value
movlw d'17' ;
call IEE_READ ;
bank3 ;
movwf freq_speed ;
movlw d'18' ;
call IEE_READ ;
bank3 ;
movwf freq_lambda ;
movlw d'19' ;
call IEE_READ ;
bank3 ;
movwf freq_voltage ;
movlw d'20' ;
call IEE_READ ;
bank3 ;
movwf freq_tc ;
movlw d'21' ;
call IEE_READ ;
bank3 ;
movwf freq_air ;
movlw d'22' ;
call IEE_READ ;
bank3 ;
movwf freq_water ;
movlw d'23' ;
call IEE_READ ;
bank3 ;
movwf freq_throttle ;
movlw d'24' ;
call IEE_READ ;
bank3 ;
movwf freq_long ;
movlw d'25' ;
call IEE_READ ;
bank3 ;
movwf freq_lat ;
movlw d'26' ;
call IEE_READ ;
bank3 ;
movwf freq_mark ;
movlw d'27' ;
call IEE_READ ;
bank3 ;
movwf freq_brake ;
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
COPY_ERRORFLAGS ; copy the value of the error flags register from pic eeprom addresses to the register
movlw d'15' ; internal eeprom address
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read pic eeprom, address in w, data returned in w, returns in bank2
movwf errors ; store value
return ; done
;---------------------------------------------------------------------------------------------------------------------------
FLASHREAD ; read from a location in the flash program memory
; address should be in eeadrh(bank2) and eeadr(bank2)
; data is returned in eedath(bank2) and eedata(bank2)
bank3 ;
bsf eecon1,eepgd ; point to flash program memory
bsf eecon1,rd ; start read operation
nop ; processor has to wait while data is being read
nop ; wait
return ; return in bank3
;---------------------------------------------------------------------------------------------------------------------------
FLASHWRITE ; write to a location in the flash program memory
; address should be in eeadrh(bank2) and eeadr(bank2)
; data should be in eedath(bank2) and eedata(bank2)
; data will be verified, carry set means error, carry cleared means write was ok
; uses templow and tempmiddle registers during verification
setc ; set error flag, presuming error
bank2 ;
movf eedata,w ; make a copy of the dataword value to use after the write
movwf templow ; to check if the write was ok
movf eedath,w ;
movwf tempmiddle ;
bank3 ;
bsf eecon1,eepgd ; point to flash program memory
bsf eecon1,wren ; enable writes
movlw h'55' ; sequence needed to unlock pic write safety lock,
movwf eecon2 ; used to prevent adverse writes
movlw h'AA' ;
movwf eecon2 ;
bsf eecon1,wr ; start write operation
nop ; two nops allow pic to setup for write and then
nop ; the processor will stop execution for the duration of the entire write cycle
bcf eecon1,wren ; disable writes
call FLASHREAD ; read the value of the flash program memory location into eedata and eedath
bank2 ;
movf eedata,w ; copy the low byte value to w
subwf templow,w ; compare it with the stored value to see if there was a write error
skpz ; was there a write error in the low byte ?
return ; yes, return with error flag (carry) set, return in bank2
movf eedath,w ; no, now check high byte
subwf tempmiddle,w ; compare it with the stored value to see if there was a write error
skpz ; was there a write error in the high byte ?
return ; yes, return with error flag (carry) set, return in bank2
clrc ; reset error flag
return ; return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
org h'0800' ; start of program memory page 1
; Note: The contents of the PCLATH register are unchanged after a RETURN or RETFIE instruction
; is executed ! The user must rewrite the contents of the PCLATH register for any subsequent
; subroutine calls or GOTO instructions
;--------------------------------------------------------------------------------------------------------------------------------------
MAIN ; main program code
MAIN_ONLOOP ; program continously loops to here while rotary switch is set to 'on',
pagesel EXEC_COMMAND ; prepare the right memory page in case we do call
btfsc flags1,command ; commands are received via interrupt routine, has a complete command been put in the buffer ?
call EXEC_COMMAND ; yes, handle it
bank0 ; no, see if the position of the rotary switch has changed from 'on' to 'log'
pagesel MAIN_ONLOOP ; make right program memory page selection
btfss portb,switch ; is the position of the rotary switch currently 'log' ?
goto MAIN_ONLOOP ; no, go back and see if a command has arrived we should handle
btfsc flags1,stx ; yes, are we receiving a command at the moment ?
goto MAIN_ONLOOP ; yes, finish reception first to minimize communication errors
MAIN_LOGTEST bank0 ; we get here if the rotary switch is set to log
bsf portc,cts_out ; clear CTS to hold data stream from computer, we need all processor time for
bcf rcsta,cren ; the logging, so stop reception and ignore any incoming commands
bcf portb,led_red ; turn off the red led
bsf portb,led_green ; turn on the green led
bank3 ; we want to make sure there are channels enabled for logging
movf freq_rpm,w ; so check all channels for their setting
andwf freq_speed,w ;
andwf freq_lambda,w ;
andwf freq_voltage,w ;
andwf freq_tc,w ;
andwf freq_air,w ;
andwf freq_water,w ;
andwf freq_throttle,w ;
andwf freq_long,w ;
andwf freq_lat,w ;
andwf freq_mark,w ;
andwf freq_brake,w ;
andlw b'10000000' ; bit seven will be set if no channels are enabled
skpz ; are there any channels enabled for logging ?
goto MAIN_FLASHLED ; no, all channels are turned off, go flash status led
MAIN_LOGSTART
; **** read errors flag register from eeprom
call MEM_OPEN ; yes, initialize memory, get location for new data, store startdate and -time, bank1 return
bcf flags2,lognow ; before starting actual logging clear this flag, it will be set during every timer0 interrupt
bank0 ;
clrf tmr0 ; clear timer0 register
bcf intcon,t0if ; clear the timer 0 overflow flag
movlw d'7' ; location of control byte in clock chip
bank2 ; turn square wave of real time clock chip on
movwf clockaddr ; select this location
movlw b'10010011' ; clock control byte, set square wave at 32768 Hz, enabled
call IIC_WR_CLKCHIP ; write control byte to clock chip, bank1 return
movlw d'255' ; we want to start logging and get a value stored for
bank3 ; all channels so use 255 as value since the register value
movwf logcounter ; will be increased to zero (log all channels) the first time
MAIN_LOGLOOP movlw d'7' ; show to the user how much room for storing the data there is left
bank1 ; up to ca. 90% (seven out of eight chips) memory filled only green led is on,
subwf mem_chip,w ; above 90% full the red led is also turned on: red and green together (extra bright)
bank0 ; see how many of the eeprom chips we have used so far
skpnc ; have we started filling the last eeprom chip ?
bsf portb,led_red ; yes, turn on the red led as well
btfsc flags2,memfull ; is all memory completely full ?
goto MAIN_LOGSTOP ; yes, exit logloop to do cleanup and then flash red led to notify user
btfsc intcon,t0if ; no, did we get a timer0 overflow interrupt so should we log data ?
call LOGDATA ; yes, actual measurement for the different input channels and the data storage is done here
bank0 ; no,
btfsc portb,switch ; has the position of the rotary switch been changed back to 'on' ?
goto MAIN_LOGLOOP ; no, keep doing the logging stuff
MAIN_LOGSTOP bank2 ; yes, go turn off square wave of real time clock chip to save battery power
movlw d'7' ; location of control byte in clock chip
movwf clockaddr ; point to this location
movlw b'10000011' ; set control value to square wave at 32768 Hz but disabled, output high
call IIC_WR_CLKCHIP ; write control byte to clock chip, bank1 return
call MEM_CLOSE ; write last data block to eeprom, write end position to toc, return in unknown bank
bank0 ; we use this logstop routine in two cases, normal stop and memory full, which one was it ?
btfss portb,switch ; has the position of the rotary switch been changed back to 'on' ?
goto MAIN_CLEANUP ; yes, skip memory full
MAIN_MEMFULL bsf errors,err_mf ; set error flag
MAIN_FLASHLED bank0 ; we will flash red status led at about 2 Hz to notify user that the memory is full
bcf portb,led_green ; turn off the green status led
MAIN_FLASHLOOP bank2
btfsc timer1y,2 ; use timer1y bit for flash rate
bsf portb,led_red ; turn on red status led
btfss timer1y,2 ;
bcf portb,led_red ; turn off red status led
bank0 ;
btfsc portb,switch ; has the position of the rotary switch been changed back to 'on' ?
goto MAIN_FLASHLOOP ; no, keep waiting until the user to switches from 'log' back to 'on' status
MAIN_CLEANUP movlw d'15' ; eeprom address for error flags register
bank2 ;
movwf iee_address ; set internal eeprom address pointer
movf errors,w ; get the value of the error flags register
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
bank0 ;
bsf rcsta,cren ; re-enable reception for incoming commands
bcf portc,cts_out ; set CTS to re-enable data stream from computer
bcf portb,led_green ; turn off the green status led
bsf portb,led_red ; turn on the red status led
goto MAIN_ONLOOP ; done
;--------------------------------------------------------------------------------------------------------------------------------------
; Handle logging flag (set during Timer0 interrupt) log data to external eeprom
;--------------------------------------------------------------------------------------------------------------------------------------
LOGDATA ; timer0 is used as the timebase for the logging event
; when logging is active this routine is called 32 times every second
; acquire input data and move it to the external eeprom
; check which channels need to be logged
; lograte table:
; 00000000 32 Hz
; 00000001 16 Hz
; 00000011 8 Hz
; 00000111 4 Hz
; 00001111 2 Hz
; 00011111 1 Hz or every second
; 00111111 1/2 Hz or every 2 seconds
; 01111111 1/4 Hz or every 4 seconds
; 1xxxxxxx never
LOG_CLEARFLAG bcf intcon,t0if ; clear the flag that brought us here (timer 0 overflow)
bank3 ;
incf logcounter,f ; counter is increased every time, so the very first time it will be 0
bsf logcounter,7 ; this bit is used to skip channels so we want it always set
LOG_RPM movf freq_rpm,w ;
andwf logcounter,w ; compare counter to the bits of the lograte setting (see above)
skpz ; is the result zero and should we take action ?
goto LOG_SPEED ; no, see if we should log the next channel
call CALC_RPM ; yes, calculate the RPM value from the time interval between the input pulses, return in bank2
movf rpm_low,w ; get low byte value (two bytes altogether for 0..16383 RPM)
movwf numlow ;
movf rpm_high,w ; get high byte value
movwf nummiddle ;
call MEM_ADD14 ; write fourteen bits to the external eeprom
LOG_SPEED bank3 ;
movf freq_speed,w ;
andwf logcounter,w ;
skpz ;
goto LOG_LAMBDA ;
call CALC_SPEED ; calculate speed value from time interval between input pulses, return in bank2
movf speed,w ; get value, maximum speed is limited to 255 km/hr (see ccp2 interrupt)
movwf numlow ; copy value
call MEM_ADD8 ;
LOG_LAMBDA bank3 ;
movf freq_lambda,w ;
andwf logcounter,w ;
skpz ;
goto LOG_VOLTAGE ;
movlw d'0' ; lambda is analog channel 0
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_VOLTAGE bank3 ;
movf freq_voltage,w ;
andwf logcounter,w ;
skpz ;
goto LOG_TC ;
movlw d'1' ; 0..5 V voltage input is analog channel 1
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_TC bank3 ;
movf freq_tc,w ;
andwf logcounter,w ;
skpz ;
goto LOG_AIRTEMP ;
movlw d'2' ; thermocouple is analog channel 2
bank0 ;
btfss portb,not_tcd ; is the thermocouple disconnected ?
bsf errors,tcdiscon ; yes, set error flag
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_AIRTEMP bank3 ;
movf freq_air,w ;
andwf logcounter,w ;
skpz ;
goto LOG_WATERTEMP ;
movlw d'3' ; air temperature is analog channel 3
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_WATERTEMP bank3 ;
movf freq_water,w ;
andwf logcounter,w ;
skpz ;
goto LOG_THROTTLE ;
movlw d'4' ; water temperature is analog channel 4
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_THROTTLE bank3 ;
movf freq_throttle,w ;
andwf logcounter,w ;
skpz ;
goto LOG_LONG ;
movlw d'5' ; throttle is analog channel 5
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_LONG bank3 ;
movf freq_long,w ;
andwf logcounter,w ;
skpz ;
goto LOG_LAT ;
movlw d'6' ; longitudinal acceleration is analog channel 6
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_LAT bank3 ;
movf freq_lat,w ;
andwf logcounter,w ;
skpz ;
goto LOG_MARK ;
movlw d'7' ; lateral accelation is analog channel 7
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
call MEM_ADD10 ;
LOG_MARK bank3 ;
movf freq_mark,w ;
andwf logcounter,w ;
skpz ;
goto LOG_BRAKE ;
clrw ; start with clearing w register
bank0 ;
btfss portb,not_mark ; test if mark input is high, use inverse value for not_mark signal
movlw b'00000001' ; change if the value should be 1
call MEM_ADD1 ;
LOG_BRAKE bank3 ;
movf freq_brake,w ;
andwf logcounter,w ;
skpz ;
goto LOG_CHK_OVERFL ;
clrw ; start with clearing w register
bank0 ;
btfsc portb,brake ; test if brake input is high
movlw b'00000001' ; change if the value should be 1
call MEM_ADD1 ;
LOG_CHK_OVERFL btfsc intcon,t0if ; check for log event overflow, we just handled a log event, did we get a new request ?
bsf errors,logoflow ; yes, set flag
LOG_DONE return ; no, done
;--------------------------------------------------------------------------------------------------------------------------------------
; Calculate the RPM rate
;--------------------------------------------------------------------------------------------------------------------------------------
CALC_RPM
; calculate RPM (input values are 32 bits, the result is 16 bits):
; numerator : nrator3 nrator2 nrator1 nrator0
; denominator: denom_r3 denom_r2 denom_r1 denom_r0
; quotient : - - rpm_high rpm_low
; remainder : remain3 remain2 remain1 remain0
; only the lower 16 bits of the 32 bit quotient are used as rpm result
; the remainder R is not used
; after that even more bits are thrown away, a maximum rpm rate of 16383 rpm is
; more than sufficient and only needs 14 bits
; see also INT_CCP1 routine
CALC_RPM_COPY bcf intcon,gie ; disable interrupts during copy
bank2 ;
movf ccp1interval3,w ; copy rpm interval for later use in division routine
movwf denom_r3 ;
movf ccp1interval2,w ;
movwf denom_r2 ;
movf ccp1interval1,w ;
movwf denom_r1 ;
movf ccp1interval0,w ;
movwf denom_r0 ; these values are used to calculate the rpm rate
bsf intcon,gie ; re-enable interrupts
CALC_RPM_DIV movlw d'3' ; set numerator X = 55,296,000 = 3 : 75 : 192 : 0
movwf nrator3 ;
movlw d'75' ;
movwf nrator2 ;
movlw d'192' ;
movwf nrator1 ;
movlw d'0' ;
movwf nrator0 ;
movlw d'32' ; there are 32 bits in this division
movwf divcounter ;
clrf rpm_low ; clear rpm result so we can check for 2 byte overflow (rpm > 65535)
clrf rpm_high ;
clrf remain0 ; clear remainder
clrf remain1 ;
clrf remain2 ;
clrf remain3 ;
CALC_RPM_LOOP clrc ;
rlf nrator0,f ; shift next bit to remainder (msbit numerator to lsbit remainder)
rlf nrator1,f ;
rlf nrator2,f ;
rlf nrator3,f ;
rlf remain0,f ;
rlf remain1,f ;
rlf remain2,f ;
rlf remain3,f ;
CALC_RPM_TEST movf denom_r3,w ; subtract denominator from remainder, if no borrow then next bit of quotient is 1
subwf remain3,w ; if borrow next bit of the quotient is 0
skpz ; check, is the result of remain3 - denom3 exactly 0 ?
goto CALC_RPM_NOTZ ; no, go check for negative result
movf denom_r2,w ; yes, continue
subwf remain2,w ; do test subtraction
skpz ; check, is the result of remain2 - denom2 exactly 0 ?
goto CALC_RPM_NOTZ ; no, go check for negative result
movf denom_r1,w ; yes, continue
subwf remain1,w ; do test subtraction
skpz ; check, is the result of remain1 - denom1 exactly 0 ?
goto CALC_RPM_NOTZ ; no, go check for negative result
movf denom_r0,w ; yes, continue
subwf remain0,w ; do test subtraction
CALC_RPM_NOTZ skpc ; is the result of any remain - denom less than 0 thus negative ?
goto CALC_RPM_NOGO ; yes, skip subtraction, this quotient bit will be zero
CALC_RPM_SUB2 movf denom_r0,w ; no, start with real subtraction
subwf remain0,f ;
movf denom_r1,w ;
skpc ; is remain0 - denom0 < 0 ?
incfsz denom_r1,w ; yes, 'borrow' from more significant byte
subwf remain1,f ; no, borrow has been skipped, do subtraction
movf denom_r2,w ;
skpc ; is remain1 - denom1 < 0 ?
incfsz denom_r2,w ; yes, 'borrow' from more significant byte
subwf remain2,f ; no, borrow has been skipped, do subtraction
movf denom_r3,w ;
skpc ; is remain2 - denom2 < 0 ?
incfsz denom_r3,w ; yes, 'borrow' from more significant byte
subwf remain3,f ; no, borrow has been skipped, do subtraction
setc ; this quotient bit is one
CALC_RPM_NOGO rlf rpm_low,f ; shift bit into quotient result, store lower 16 bits of quotient as result
rlf rpm_high,f ; throw away the upper 16 bits
skpnc ; do we have a rpm rate of more than 65535 rpm ?
goto CALC_RPM_OFLOW ; yes, the result will not fit in the 16 bits of rpm_low and rpm_high, exit
decfsz divcounter,f ;
goto CALC_RPM_LOOP ; go do next bit
CALC_RPM_2PULS btfsc pulses,0 ; do we have only one puls per revolution of the crankshaft ?
goto CALC_RPM_14BIT ; yes, we do not need to adjust the value
rrf rpm_high,f ; no, so we have two pulses per revolution, we have to divide the value by two
rrf rpm_low,f ; no need to clear carry, it was already 'cleared' by previous instructions
CALC_RPM_14BIT movlw b'11000000' ; test value to see if we use the upper 2 bits of the 16 bit rpm value
andwf rpm_high,w ; do the test
skpz ; is the rpm value more than 16383 (the maximum value that will fit in 14 bits) ?
goto CALC_RPM_OFLOW ; yes, go set to maximum value (16383)
return ; no, we're done here, return in bank2
CALC_RPM_OFLOW movlw d'255' ; we have an overflow, set to 14 bit maximum (16383) instead
movwf rpm_low ;
movlw d'63' ;
movwf rpm_high ;
return ; return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
; Calculate the Speed value
;--------------------------------------------------------------------------------------------------------------------------------------
CALC_SPEED ; since we can have both timer 1 overflow and ccp interrupt request at the same
; time it is important to update the timer 1 extension bytes at the right time,
; now see if we can use the present timer 1 values to calculate the vehicle speed
; from CCP module 2 using the time (t) between two captures, otherwise we exit this
; routine and come back later when timer 1 has been incremented
; we assume there is one puls per revolution of the wheel
; t [s] = time between pulses = 1 / rotation frequency of wheel = 1 / F [Hz]
; c [mm] = circumference wheel = distance per revolution of the wheel
; SPEED [mm/s] = F * c
; SPEED [km/hr] = (F * c * 3600) / 1000000
; SPEED [km/hr] = ((1 / t) * c * 3600) / 1000000
; SPEED [km/hr] = (c * 3600) / (t * 1000000)
; SPEED [km/hr] = (c * 3600) / ((1 / (timer1clockrate / interval)) * 1000000)
; SPEED [km/hr] = (c * 3600) / ((1 / (3686400 Hz / interval)) * 1000000)
; SPEED [km/hr] = (921600 * c * 3600) / (interval * 1000000)
; SPEED [km/hr] = (3318 * c) / interval
; SPEED [km/hr] = (3318 * c) / (capturevalue - previouscapturevalue)
; the value 3318 * c has been calculated during intialization at processor reset
; and is stored in speed_const0..3 (value 3318 is actually 3317.76)
; calculate interval (32 bits):
; current = timer1z timer1y ccpr1h ccpr1l
; new = new2cap3 new2cap2 new2cap1 new2cap0
; old = old2cap3 old2cap2 old2cap1 old2cap0
; interval = denom_s3 denom_s2 denom_s1 denom2_0
; calculate speed (input values are 32 bits, the result is 16 bits):
; quotient Q = numerator X / denominator Y (and remainder R)
; numerator : nrator3 nrator2 nrator1 nrator0
; denominator: denom_s3 denom_s2 denom_s1 denom2_0
; result Q : - - - speed
; remainder : remain3 remain2 remain1 remain0
; only the lower 8 bits of the 32 bit quotient are used as speed result,
; the other bits are thrown away since a top speed of 255 km/hr is more than
; sufficient and can be stored as just one byte
; final speed value (0..255 km/hr) is stored in speed register in bank2
CALC_SPEED_COPY bcf intcon,gie ; disable interrupts during copy
bank2 ;
movf ccp2interval3,w ; copy speed interval for use in division routine
movwf denom_s3 ;
movf ccp2interval2,w ;
movwf denom_s2 ;
movf ccp2interval1,w ;
movwf denom_s1 ;
movf ccp2interval0,w ;
movwf denom_s0 ; use these values to calculate vehicle speed
bsf intcon,gie ; re-enable interrupts
CALC_SPEED_DIV movf speed_const3,w ; set numerator X = 3318 * circumference
movwf nrator3 ;
movf speed_const2,w ;
movwf nrator2 ;
movf speed_const1,w ;
movwf nrator1 ;
movf speed_const0,w ;
movwf nrator0 ;
movlw d'32' ; there are 32 bits in this division
movwf divcounter ;
clrf speed ; clear speed result so we can check for 1 byte overflow (speed > 255)
clrf remain0 ; clear remainder
clrf remain1 ;
clrf remain2 ;
clrf remain3 ;
CALC_SPEED_LOOP clrc ;
rlf nrator0,f ; shift next bit to remainder (msbit numerator to lsbit remainder)
rlf nrator1,f ;
rlf nrator2,f ;
rlf nrator3,f ;
rlf remain0,f ;
rlf remain1,f ;
rlf remain2,f ;
rlf remain3,f ;
CALC_SPEED_TEST movf denom_s3,w ; subtract denominator from remainder, if no borrow then next bit of quotient is 1
subwf remain3,w ; if borrow next bit of the quotient is 0
skpz ; check, is the result of remain3 - denom3 exactly 0 ?
goto CALC_SPEED_NOTZ ; no, go check for negative result
movf denom_s2,w ; yes, continue
subwf remain2,w ; do test subtraction
skpz ; check, is the result of remain2 - denom2 exactly 0 ?
goto CALC_SPEED_NOTZ ; no, go check for negative result
movf denom_s1,w ; yes, continue
subwf remain1,w ; do test subtraction
skpz ; check, is the result of remain1 - denom1 exactly 0 ?
goto CALC_SPEED_NOTZ ; no, go check for negative result
movf denom_s0,w ; yes, continue
subwf remain0,w ; do test subtraction
CALC_SPEED_NOTZ skpc ; is the result of any remain - denom less than 0 thus negative ?
goto CALC_SPEED_NOGO ; yes, skip subtraction, this quotient bit will be zero
CALC_SPEED_RSUB movf denom_s0,w ; no, start with real subtraction
subwf remain0,f ;
movf denom_s1,w ;
skpc ; is remain0 - denom0 < 0 ?
incfsz denom_s1,w ; yes, 'borrow' from more significant byte
subwf remain1,f ; no, borrow has been skipped, do subtraction
movf denom_s2,w ;
skpc ; is remain1 - denom1 < 0 ?
incfsz denom_s2,w ; yes, 'borrow' from more significant byte
subwf remain2,f ; no, borrow has been skipped, do subtraction
movf denom_s3,w ;
skpc ; is remain2 - denom2 < 0 ?
incfsz denom_s3,w ; yes, 'borrow' from more significant byte
subwf remain3,f ; no, borrow has been skipped, do subtraction
setc ; this quotient bit is one
CALC_SPEED_NOGO rlf speed,f ; shift bit into quotient result, store lower 8 bits of quotient as result
skpnc ; do we have a speed of more than 255 km/hr ?
goto CALC_SPEED_OFLW ; yes, the result will not fit in the 8 bits of speed register, exit
decfsz divcounter,f ;
goto CALC_SPEED_LOOP ; go do next bit
return ; we're done here, return in bank2
CALC_SPEED_OFLW movlw d'255' ; we have an overflow, set to 8 bit maximum (255) instead
movwf speed ;
return ; done, return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
; analog input subroutine
;--------------------------------------------------------------------------------------------------------------------------------------
GET_ANALOG ; get 10 bit value of one analog input
; 3 bit channel number should be in w register (0..7)
; w register content is destroyed
; value is returned in numlow and nummiddle
movwf adtemp ; use adtemp register in channel selection calculation
swapf adtemp,f ; move channel selection bits to the right position
rrf adtemp,w ; move channel selection bits to the right position, no need to clear carry:
andlw b'00111000' ; mask out all but the three bits that hold channel number
iorlw b'01000000' ; Fosc/8 gives 2.2 us bit conversion time@Fosc=3.6864 MHz), channel 0, a/d module off
bank0 ;
movwf adcon0 ; apply settings
bsf adcon0,adon ; activate a/d module
movlw d'7' ; wait the required acquisition time (approx. 20 microseconds), which is
movwf adtemp ; about 19 instruction cycles @ 3.6864 Mhz (1085 ns per instruction)
ADLOOP1 decfsz adtemp,f ; count down from to zero, this instruction is one cycle
goto ADLOOP1 ; this instruction is two cycles, wait until we are done (7*3*1.085=22.8 us)
bsf adcon0,go_notdone ; now start conversion
ADLOOP2 btfsc adcon0,go_notdone ; is conversion done ?
goto ADLOOP2 ; no, wait here until conversion is completed
bcf adcon0,0 ; shut-off a/d module for minimal power consumption
movf adresh,w ; store results, note that this will also give us the neccesary delay of 2 Tad
movwf nummiddle ; between two a/d sampling actions (1.085 us per instruction @ 3.6864 Mhz )
bank1 ;
movf adresl,w ;
movwf numlow ;
return ; return in bank1
;--------------------------------------------------------------------------------------------------------------------------------------
; PIC internal EEPROM read and write routines
;--------------------------------------------------------------------------------------------------------------------------------------
IEE_READ ; reads one byte from PIC EEPROM
; address should be in w
; data byte is returned in w
; returns in bank 2
bank2 ;
movwf eeadr ; register address (0-255 decimal for PIC16F877)
bank3 ;
bcf eecon1,eepgd ; select eeprom data memory for read/write access instead of program memory
bsf eecon1,rd ; set bit to read
bank2 ;
movf eedata,w ;
return ;
;--------------------------------------------------------------------------------------------------------------------------------------
IEE_WRITE ; writes one byte to PIC EEPROM
; address should be in iee_address (bank2), data should be in w
; w content is destroyed
; returns in bank 0
bank3 ;
btfsc eecon1,wr ; is there currently a write cycle busy ?
goto $-1 ; wait here for previous write to finish
bank2 ;
movwf eedata ; set data
movf iee_address,w ; get address
movwf eeadr ; select address
bank3 ;
bcf eecon1,eepgd ; select eeprom data memory for read/write access instead of program memory
bsf eecon1,wren ; write enable
bcf intcon,gie ; disable all interrupts
btfsc intcon,gie ; check if disabled
goto $-2 ; else try again
movlw h'55' ; required sequence
movwf eecon2 ;
movlw h'AA' ;
movwf eecon2 ;
bsf eecon1,wr ; start write
bsf intcon,gie ; re-enable interrupts
bcf eecon1,wren ; disable writes (does not affect current write cycle)
bank0 ;
btfss pir2,eeif ;
goto $-1 ; wait here for the write to complete
bcf pir2,eeif ; clear eeprom write interrupt flag
return ; return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
; IIC subroutines
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_IDLE bank1 ; use this subroutine for interrupt driven IIC communication
btfsc sspstat,r_notw ; is the IIC bus free (test if a transmission is in progress) ?
goto $-1 ; no, wait until it is free
movf sspcon2,w ; yes, get a copy of sspcon2 to test status bits
andlw b'00011111' ; apply mask to mask out non-status bits
skpz ; test for zero state, if zero bus is idle, bus busy ?
goto $-3 ; yes, test again until bus is free
return ; no, bus is free, exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_START bank1 ;
bsf sspcon2,sen ; generate start condition
btfsc sspcon2,sen ; is the start completed ?
goto $-1 ; no, wait until it is completed
return ; yes, exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_RESTART bank1 ;
bsf sspcon2,rsen ; generate restart condition
btfsc sspcon2,rsen ; is the restart completed ?
goto $-1 ; no, wait until it is completed
return ; yes, exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_STOP bank1 ;
bsf sspcon2,pen ; generate stop condition
btfsc sspcon2,pen ; is the stop completed ?
goto $-1 ; no, wait until it is completed
return ; yes, exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_EADDRESS bank1 ; send the control byte, high and low address bytes to eeprom
rlf iicchip,w ; get chip select number in right position, no need to clear carry prior to byte rotation
andlw b'00001110' ; avoid possible errors and make sure we only use the three bit number
iorlw b'10100000' ; control code for eeprom chips, chip number 0, bit 0 clear for write operation
bank0 ;
movwf sspbuf ; send the slave address
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
return ; no, exit and deal with error
movf iicahigh,w ; yes, get upper byte of address (**** to do: current eeproms are only 32kB>15 bit number!)
bank0 ;
movwf sspbuf ; send address upper byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
return ; no, exit and deal with error
movf iicalow,w ; yes, get lower address byte
bank0 ;
movwf sspbuf ; send lower address byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
return ; yes, exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_WRBYTE ; write one byte to external IIC eeprom
; address in iicchip, iicalow and iicahigh
; data in iicdata
call IIC_START ;
call IIC_EADDRESS ; send the address and check for any ACK errors
btfsc sspcon2,ackstat ; did we get any ACK error while sending the address ?
goto IIC_STOP ; yes, error, send stop then exit
movf iicdata,w ; no, get data byte
bank0 ;
movwf sspbuf ; send data byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
IIC_POLL1 call IIC_STOP ; start write cycle, then poll eeprom for completion cycle, wait for ACK from eeprom
call IIC_START ; (on completion of the write cycle the eeprom sends an ACK)
bank1 ; send the control byte to eeprom:
rlf iicchip,w ; get chip select number, no need to clear carry prior to byte rotation
andlw b'00001110' ; avoid possible errors and make sure we only use the three bit number
iorlw b'10100000' ; control code for eeprom chips, chip number 0, bit 0 clear for write operation
bank0 ;
movwf sspbuf ; send slave address
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_POLL1 ; no, go poll again
goto IIC_STOP ; yes, send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_RDBYTE ; read one byte from external IIC eeprom
; address in iicchip, iicalow and iicahigh
; data is returned in iicdata
call IIC_START ;
call IIC_EADDRESS ; send the address and check for any ACK errors
btfsc sspcon2,ackstat ; did we get any ACK error while sending the address ?
goto IIC_STOP ; yes, send stop then exit
call IIC_RESTART ; no, send restart
bank1 ; send the control byte to eeprom:
rlf iicchip,w ; get chip select number, no need to clear carry prior to byte rotation
andlw b'00001110' ; avoid possible errors and make sure we only use the three bit number
iorlw b'10100001' ; control code for eeprom chips, chip number 0, bit 0 set for read operation
bank0 ;
movwf sspbuf ; send slave address
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, send stop then exit
bsf sspcon2,rcen ; receive data byte from eeprom
btfsc sspcon2,rcen ; have we received the byte ?
goto $-1 ; no, wait here until byte receive is completed
bank0 ;
movf sspbuf,w ; get received data byte
bank1 ;
movwf iicdata ; store the data byte
bsf sspcon2,ackdt ; select NOACK
bsf sspcon2,acken ; send NOACK
btfsc sspcon2,acken ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
goto IIC_STOP ; yes, send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_WRBLOCK ; writes one block (64 bytes) to the external IIC eeprom memory
; first address in iicchip, iicalow and iicahigh, when address value is not
; the start of a block, the address counter will roll over
; w register content is destroyed
; data is in block buffer in bank1, from address AF hex up to and including EE hex
call IIC_START ; send start condition
call IIC_EADDRESS ; send the address and check for any ACK errors
bank1 ;
btfsc sspcon2,ackstat ; did we get any ACK error while sending the address ?
goto IIC_STOP ; yes, error, send stop then exit
bcf status,irp ; no, make sure upper bit in bank address is zero (select bank 0 and 1)
movlw blockbuff00 ; start position of data in buffer
movwf fsr ; point to this address
IIC_WRITELOOP movf indf,w ; read data byte from buffer
bank0 ;
movwf sspbuf ; send data byte to eeprom
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; has ACK been received ?
goto IIC_STOP ; no, send stop then exit
incf fsr,f ; increase pointer to point to next value
movf fsr,w ; use pointer value
sublw blockbuff63 ; was this the last byte ?
skpnc ; let's see
goto IIC_WRITELOOP ; no, do loop again and send next data byte
IIC_POLL2 call IIC_STOP ; yes, start block write, poll eeprom for completion cycle, wait for ACK from eeprom
call IIC_START ; (on completion of the write cycle the eeprom sends an ACK)
bank1 ; send the control byte to eeprom:
rlf iicchip,w ; get chip select number in right position, no need to clear carry prior to byte rotation
andlw b'00001110' ; avoid possible errors and make sure we only use the three bit number
iorlw b'10100000' ; control code for eeprom chips, chip number 0, bit 0 clear for write operation
bank0 ;
movwf sspbuf ; send slave address
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_POLL2 ; no, go poll again
goto IIC_STOP ; yes, send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_RDBLOCK ; reads one block (64 bytes) from the external IIC eeprom memory
; first address in iicchip, iicalow and iicahigh
; w register content is destroyed
; data is returned in buffer in bank1, from address 2F hex up to and including 6E hex
; return in bank1
movlw blockbuff00 ; no, start position of data in buffer
movwf fsr ; point to this address
bcf status,irp ; make sure upper bit in address is zero (select bank 0 and 1)
call IIC_START ; read one byte from external IIC eeprom into iicdata, address in iicchip, iicalow and iicahigh
call IIC_EADDRESS ; send the address and check for any ACK errors
btfsc sspcon2,ackstat ; did we get any ACK error while sending the address ?
goto IIC_STOP ; yes, send stop then exit
call IIC_RESTART ; no, send restart
bank1 ; send the control byte to eeprom:
rlf iicchip,w ; get chip select number, no need to clear carry prior to byte rotation
andlw b'00001110' ; avoid possible errors and make sure we only use the three bit number
iorlw b'10100001' ; control code for eeprom chips, chip number 0, bit 0 set for read operation
bank0 ;
movwf sspbuf ; send slave address
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, send stop then exit
IIC_READLOOP bsf sspcon2,rcen ; receive data byte from eeprom
btfsc sspcon2,rcen ; have we received the byte ?
goto $-1 ; no, wait here until byte receive is completed
bank0 ;
movf sspbuf,w ; get received data byte
bank1 ; the buffer is in bank 1
movwf indf ; store the data byte at the right position in the buffer
incf fsr,f ; increase pointer to point to next value
movf fsr,w ; use pointer value
sublw blockbuff63 ; was this the last byte ?
skpc ; let's see
goto IIC_READDONE ; yes, send termination NOACK then exit
bcf sspcon2,ackdt ; select ACK
bsf sspcon2,acken ; send ACK
btfsc sspcon2,acken ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
goto IIC_READLOOP ; do loop again and read next data byte
IIC_READDONE bsf sspcon2,ackdt ; select NOACK
bsf sspcon2,acken ; send NOACK
btfsc sspcon2,acken ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
goto IIC_STOP ; yes, send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_RDCLOCK ; read the eight time related bytes from the external IIC clock chip DS1307
; into the buffer in bank2, from address 68 hex up to and including 6F hex
; w register content is destroyed
call IIC_START ;
movlw b'11010000' ; clock control code/slave address, bit 0 is cleared as indication for write
bank0 ;
movwf sspbuf ; send the control byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
bank0 ;
clrw ; address byte is zero indicating start of clock memory
movwf sspbuf ; send address byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
call IIC_STOP ; yes, continue
call IIC_START ; send start
bank0 ;
movlw b'11010001' ; clock control code/slave address, bit 1 is set as indication for read
movwf sspbuf ; send control byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, send stop then exit
movlw h'68' ; no, start position of data in buffer
movwf fsr ; point to this address
bsf status,irp ; make sure upper bit in address is one (select bank 2 and 3)
IIC_CRDLOOP bank1 ;
bsf sspcon2,rcen ; receive data byte from clock chip
btfsc sspcon2,rcen ; have we received the byte ?
goto $-1 ; no, wait here until byte receive is completed
bank0 ;
movf sspbuf,w ; get received data byte
movwf indf ; store the data byte at the right position in the buffer
incf fsr,f ; increase pointer to point to next value
movf fsr,w ; use pointer value
sublw h'6F' ; was this the last byte ?
skpc ; let's see
goto IIC_CRDDONE ; yes, send termination NOACK then exit
bank1 ;
bcf sspcon2,ackdt ; select ACK
bsf sspcon2,acken ; send ACK
btfsc sspcon2,acken ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
goto IIC_CRDLOOP ; do loop again and read next data byte
IIC_CRDDONE bank1 ;
bsf sspcon2,ackdt ; select NOACK
bsf sspcon2,acken ; send NOACK
btfsc sspcon2,acken ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
goto IIC_STOP ; yes, send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_WRCLOCK ; write eight time related bytes to the external IIC clock chip DS1307
; uses the data from buffer in bank2, from 68 hex up to and including 6F hex
call IIC_START ;
movlw b'11010000' ; clock chip control code, bit 0 is cleared as indication for write
bank0 ;
movwf sspbuf ; send the control byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it has completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
bank0 ; yes,
clrw ; address byte is zero indicating start of clock memory
movwf sspbuf ; send address byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it has completed
btfsc sspcon2,ackstat ; has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
movlw h'68' ; yes, start position of data in buffer
movwf fsr ; point to this address
bsf status,irp ; make sure upper bit in address is one (select bank 2 and 3)
IIC_CWRLOOP bank0 ;
movf indf,w ; read data byte from buffer
movwf sspbuf ; send data byte to clock
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it has completed
btfsc sspcon2,ackstat ; has ACK been received ?
goto IIC_STOP ; no, send stop then exit
incf fsr,f ; increase pointer to point to next value
movf fsr,w ; use pointer value
sublw h'6F' ; was this the last byte ?
skpnc ; let's see
goto IIC_CWRLOOP ; no, do loop again and send next data byte
goto IIC_STOP ; yes, send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_RD_CLKCHIP ; read a byte from the control bytes or static ram of the clock chip DS1307
; address in w register (0..63 addresses include the time settings and wrap around !)
; returns with value in w register
bank2 ;
movwf clockaddr ; store the address byte for later use
call IIC_START ;
movlw b'11010000' ; clock control code/slave address, bit 0 is cleared as indication for write
bank0 ;
movwf sspbuf ; send the control byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
bank2 ;
movf clockaddr,w ; get the address byte
bank0 ;
movwf sspbuf ; send address byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
call IIC_STOP ; yes, continue
call IIC_START ; send start
bank0 ;
movlw b'11010001' ; clock control code/slave address, bit 1 is set as indication for read
movwf sspbuf ; send control byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, send stop then exit
IIC_RSTLOOP bank1 ;
bsf sspcon2,rcen ; receive data byte from clock chip
btfsc sspcon2,rcen ; have we received the byte ?
goto $-1 ; no, wait here until byte receive is completed
bank0 ;
movf sspbuf,w ; get received data byte
bank2 ;
movwf clockdata ; store data byte for later use
bank1 ;
bsf sspcon2,ackdt ; select NOACK
bsf sspcon2,acken ; send termination NOACK
btfsc sspcon2,acken ; is the transmission completed ?
goto $-1 ; no, wait here until it is completed
call IIC_STOP ; yes, send stop
bank2 ;
movf clockdata,w ; retrieve data value
return ; return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
IIC_WR_CLKCHIP ; write one byte to the control bytes or static ram of the clock chip DS1307
; address in clockaddr register (0..63 addresses include the time settings and wrap around !)
; data in w register
; w register content is destroyed
bank2 ;
movwf clockdata ; store data byte for later use
call IIC_START ;
movlw b'11010000' ; clock chip control code, bit 0 is cleared as indication for write
bank0 ;
movwf sspbuf ; send the control byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it has completed
btfsc sspcon2,ackstat ; yes, has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
bank2 ; yes,
movf clockaddr,w ; get address byte
bank0 ;
movwf sspbuf ; send address byte
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it has completed
btfsc sspcon2,ackstat ; has ACK been received ?
goto IIC_STOP ; no, deal with error: send stop then exit
bank2 ; yes,
movf clockdata,w ; get data byte
bank0 ;
movwf sspbuf ; send data byte to clock
bank1 ;
btfsc sspstat,r_notw ; is the transmission completed ?
goto $-1 ; no, wait here until it has completed
goto IIC_STOP ; send stop then exit
;--------------------------------------------------------------------------------------------------------------------------------------
MEMORY ; EEPROMS - measured data is stored in the EXTERNAL eeprom, the location of this data in the
; external eeprom and starttime information are stored in the INTERNAL eeprom, meaning that
; the internal eeprom serves as a table of contents (TOC)
; TOC - the table of contents runs from '@tocstart' up to and including address 255,
; at the start of the logging the start time and date is stored in the toc, when closing the
; record file (after switching back from the 'log' to the 'on' mode) then the address of the
; last used bit in the external memory is stored in the toc (in iicalow, iicahigh and
; iicchip/bitp, so each record in the toc uses 10 bytes:
; 9 high byte upper nibble = bitpointer, lower nibble = iicchip
; 8 middle byte iicahigh
; 7 low byte iicalow
; 6 year start time
; 5 month ,,
; 4 date ,,
; 3 day ,,
; 2 hours ,,
; 1 minutes ,,
; 0 seconds ,,
; BLOCK SIZE - during logging all measured data values are written to the external eeprom and
; the actual writes happen in eeprom block write size (64 bytes, the eeprom datasheet calls
; them pages, but to avoid confusion with pic memory pages we will call them blocks)
; to maximize eeprom lifetime and data throughput, the data is first buffered in pic registers
; and will only written to the external eeprom when the 64 byte size has been reached or when
; the command MEM_CLOSE is executed
; the 64 byte block buffer is in bank 1 from 2F to 6E hex, 6F hex is used as overflow
; there are 512 blocks per eeprom chip (9 bit number), in total there are 4096 blocks
; the following registers hold the first available free block in the external eeprom:
; mem_alow here value is multiple of 64 to always point to start of a block
; mem_ahigh maximum value is 127 since each memory chip is only 32 kbytes in size
; mem_chip value from zero to seven, we have eight eeprom chips
; START POSITION - records always start at the beginning of a new eeprom block (64 bytes)
; and are NOT stored directly after the bits of the first record to make the download routine
; to the computer easier and to prolong the external eeprom lifetime
; the start position for any new record is calculated by the MEM_OPEN command
; note: the start address of the first record is always zero
; WRITES - the following commands are used to store the recorded data in the external
; eeprom chips, there are eight chips of 32k bytes each (total 2^21=2097152 bits)
; MEM_ADD1 digital channels: mark & brake
; MEM_ADD8 speed
; MEM_ADD10 analog channels
; MEM_ADD14 rpm
; writes are not verified by a read !
; after each add command the value of the memfull bit in the flags register
; indicates if there is any room in the memory left, this memfull flag is set at the page
; before the last page so the close command can still write the very last block to the memory
; COMPRESSION - data is stored in compressed form, meaning that a 9 bit value will be stored
; as exactly nine bits in the external eeprom, directly after any previously stored bits
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_CLEAR movlw @tocstart ; clear all toc bytes, both the address and the starttime bytes
bank2 ; location of first byte in table of contents
movwf iee_address ; address for internal eeprom writes should be here
MEM_CLEAR_LOOP clrw ; data for internal eeprom writes should be in w register
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w, bank0 return
bank2 ; iee_address is in bank2
incfsz iee_address,f ; point to next byte and skip when all are done
goto MEM_CLEAR_LOOP ; go clear next byte
movlw d'15' ; eeprom address for error flags register
bank2 ;
movwf iee_address ; set internal eeprom address pointer
clrf errors ; clear error flags register
clrw ; clear all error flags in eeprom as well,
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w, bank0 return
bank3 ;
clrf num_records ; there are no records available anymore
clrf current_rec ; there is no record selected for download anymore
bcf flags2,memfull ; clear flag indicating the table of contents is now empty
return ; return in bank3
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_OPEN ; when both the external memory and the table of contents are not full then:
;
; 1. get the new values for:
; mem_alow
; mem_ahigh
; mem_chip
; bitpointer
; regpointer
; toc_pointer
; memfull flag (set when memory is full, registers above will contain junk)
;
; 2. initialize (clear): blockbuff00
;
; 3. write the current time as starttime (seven bytes) into toc
movlw d'255' ; position of last byte in table of contents, we start at the top and work our way down
bank1 ; empty locations will contain three zero values, first try three most upper bytes
movwf toc_pointer ; point to the top location
MEM_OPEN_SEARCH movf toc_pointer,w ; get copy of tocpointer value, needed in loop
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank1 ; pointer registers and eeprom block write buffer are all in bank 1
movwf mem_chip ; store value for later use, but remember this value includes bitpointer in upper nibble
decf toc_pointer,f ; point to lower location in toc
movf toc_pointer,w ; copy the value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank1 ; pointer registers and eeprom block write buffer are all in bank 1
movwf mem_ahigh ; store value for later use
decf toc_pointer,f ; point to lower location in toc
movf toc_pointer,w ; copy the value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank1 ; pointer registers and eeprom block write buffer are all in bank 1
movwf mem_alow ; store value for later use, check all three values of this record to see if they are all zero
iorwf mem_ahigh,w ; since this indicates that this record location is not in use yet,
iorwf mem_chip,w ; so it can be used in the next logging event
skpz ; are all three values zero, meaning this location is not used ?
goto MEM_OPEN_INUSE ; no, use this location to get address, then point to next location which we know is empty
MEM_OPEN_EMTEST movlw d'7' ; yes, go see if the toc is completely empty or if there is already another record
subwf toc_pointer,f ; point to start of time and date bytes for this record
movlw @tocstart ; if toc is empty then we now point to the start of the toc
subwf toc_pointer,w ; see if this is the first record in the toc
skpnz ; will this be the first record in the toc ?
goto MEM_OPEN_1STREC ; yes, go set address of first record to zero to point to bottom of external eeprom memory
MEM_OPEN_DONEXT decf toc_pointer,f ; no, there are lower locations we should test
goto MEM_OPEN_SEARCH ; do loop and try next
MEM_OPEN_INUSE movlw d'255' - d'2' ; when toc is full this is where the pointer will be
subwf toc_pointer,w ; test the value of tocpointer, it the pointer at the last record position
skpnz ; is the current pointer value valid ?
goto MEM_OPEN_TOCFUL ; no, stop looking, the toc is full
MEM_OPEN_POINT movlw d'3' ; point to first time and date byte of next record we know is free to use
addwf toc_pointer,f ; since we have started at the top of the toc
MEM_OPEN_CALC movlw b'11000000' ; use the end address of a previous record to calculate the start of the next record
andwf mem_alow,f ; find the start of the last used block by stripping the lower six bits from the low byte
movlw d'64' ; this value is the size of one block
addwf mem_alow,f ; add one block to point to the next block, which is not used yet
skpnc ; did we get an overflow of the lower byte ?
incf mem_ahigh,f ; yes, also increase high byte
btfsc mem_ahigh,7 ; no, did we get an overflow of the lower seven bits of the high byte (we use 32k eeproms) ?
incf mem_chip,f ; yes, also increase the chip select byte
btfsc mem_ahigh,7 ; no, again, did we get an overflow of the lower seven bits of high byte (we use 32k eeproms) ?
bcf mem_ahigh,7 ; yes, then reset this bit
movlw b'00001111' ; no, the pointer to the last used bit was stored in upper nibble of the chip select byte
andwf mem_chip,f ; we only want the chip select value so strip this nibble
btfsc mem_chip,3 ; see if are we pointing to a non-existing eeprom chip (there are eight eeprom chips)
goto MEM_OPEN_MEMFUL ; yes, we cannot use this non-existing location
MEM_OPEN_TEST movlw d'7' ; no, chip number seven is the last chip
subwf mem_chip,w ; see if we are using the last chip
skpz ; are we pointing to the last chip ?
goto MEM_OPEN_WRTIME ; no, the address is ok
movlw d'127' ; yes, this is the number for last four pages
subwf mem_ahigh,w ; see if we are already there
skpnz ; are we using one of the last four pages ?
goto MEM_OPEN_MEMFUL ; yes, we do not want to use this location
goto MEM_OPEN_WRTIME ; no, the address is ok
MEM_OPEN_1STREC clrf mem_alow ; yes, since there are no records yet we will start at address zero
clrf mem_ahigh ; clear all address pointer bytes
clrf mem_chip ; and start at the bottom of chip zero
MEM_OPEN_WRTIME call IIC_RDCLOCK ; read the time and date bytes to buffer in bank2 (from 68..6E hex), bank1 return
bsf status,irp ; make sure upper bit in bank address is one (select bank 2 and 3)
movlw h'68' ; the time and date bytes were put here
movwf fsr ; point to this address
MEM_OPEN_WRLOOP bank1 ; switch to bank1 because of loop
movf toc_pointer,w ; get a copy of the tocpointer value
bank2 ; register is in bank2
movwf iee_address ; the address byte for internal eeprom write operations
movf indf,w ; get the data value for this address
call IEE_WRITE ; do the actual write operation, return in bank0
bank1 ;
incf toc_pointer,f ; point to next position in toc, after all time writes value will be at first address position
incf fsr,f ; point to the next time and date byte
movlw h'6F' ; position past the last time and date byte
subwf fsr,w ; check if all byte have been written
skpz ; have we written all bytes ?
goto MEM_OPEN_WRLOOP ; no, repeat until all bytes have been written to the toc
MEM_OPEN_INIT clrf blockbuff00 ; yes, clear first byte of blockbuffer as we use logical or operation to add new bits to buffer
clrf bitpointer ; clear pointer for any new write operations, point to first bit
movlw blockbuff00 ; location of first byte in block buffer
movwf regpointer ; use value to set register pointer to start of blockbuffer
bcf flags2,memfull ; clear flag indicating the external eeproms are not full
return ; return in bank1
MEM_OPEN_TOCFUL bsf flags2,tocfull ; set flag indicating the table of contents is full
MEM_OPEN_MEMFUL bsf flags2,memfull ; set flag indicating the memory is full
return ; return in bank1
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_WRITEBLOCK ; write of block buffer to external eeprom, update buffer pointers and memory address pointer
; block buffer should contain the data
; set the memfull flag when the page before the last page is reached, this is done to notify
; to the logging loop that recording should be stopped immediately to allow for a proper
; record file ending (the last page will only be used partially)
; the following registers should hold the address in the external eeprom:
; mem_alow this value is always a multiple of 64 to point to the start of a block
; mem_ahigh maximum value is 127 since each memory chip is only 32 kbytes in size
; mem_chip value from zero to seven, we have eight eeprom chips
movlw blockbuff00 ; location of first byte in block buffer
movwf regpointer ; reset the register pointer for following write events
btfsc mem_chip,3 ; test chip number validity, is there still room in any of the eight external eeproms ?
return ; no, return without writing data or updating pointers, the memfull flag has been set already
movf mem_alow,w ; get address of the next available free block in the memory, select address low byte
movwf iicalow ; copy value to iic write routine
movf mem_ahigh,w ; select address high byte
movwf iicahigh ; copy value to iic write routine
movf mem_chip,w ; select chip
movwf iicchip ; copy value to iic write routine
call IIC_WRBLOCK ; yes, do the actual write operation and copy the block into the external eeprom
movlw d'64' ; now update all adresses for following write operations, this is size of one block
bank1 ; we will add one block to the address
addwf mem_alow,f ; try to point to next block in same chip, low byte of pointer
skpc ; should we also update high byte of pointer ?
return ; no, we're done
incf mem_ahigh,f ; yes, increase high byte of pointer
btfsc mem_ahigh,7 ; is there any room left in this chip ?
goto MEM_WRBL_NEXT ; no, go reset high address byte, we know low byte has wrapped around and is zero
MEM_WRBL_TEST movlw d'7' ; go see if we have to set memfull flag, chip number seven is the last chip
subwf mem_chip,w ; see if we are using the last chip
skpz ; are we pointing to the last chip ?
return ; no, we're done
movlw d'127' ; yes, this is the number for last four pages
subwf mem_ahigh,w ; see if we are already there
skpnz ; are we using one of the last four pages ?
bsf flags2,memfull ; yes, the external eeproms are almost full, set flag to allow for the very last block write
return ; no, we're done, bank1 return
MEM_WRBL_NEXT clrf mem_ahigh ; no, reset high address byte, we know low byte has wrapped around and is zero
incf mem_chip,f ; point to next chip
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_ADD1 ; write one bit to the external eeprom
; actual writes are done when the 64 byte block buffer in pic is full
; this is done to optimize eeprom lifetime
; input = bit zero of w register (actually ior of all bits)
bank1 ; block buffer pointer registers and eeprom block write buffer are all in bank 1
bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
iorlw d'00000000' ; see what value the bit is
skpnz ; is input bit value a zero ?
goto MEM_ADD1_ZERO ; yes, skip bit set code
MEM_ADD1_ONE movf regpointer,w ; no, get the value of the pointer to the register where we will put the bit
movwf fsr ; use indirect addressing
movf bitpointer,w ; convert 3 bit number of bitpointer to eight bit mask, for example 010>00000100
andlw b'00000011' ; first strip upper six bits and continue with only two bits
movwf bitmask ; store the result
incf bitmask,w ; increase by one
btfsc bitmask,1 ; is the first bit in mask a one ?
iorwf bitmask,f ; yes, adjust result
incf bitmask,f ; no, increase by one
btfsc bitpointer,2 ; was bitpointer value larger than three, should we have got a bit in upper nibble ?
swapf bitmask,f ; yes, simply swap nibbles
movf bitmask,w ; no, result is eight bit mask
iorwf indf,f ; use OR operation to set the bit
MEM_ADD1_ZERO nop ; zero bit, we have to do nothing since the new bytes are always cleared
MEM_ADD1_INC incf bitpointer,f ; be ready for next push so increase pointer to point to next bit
btfss bitpointer,3 ; has the bitcounter reached value 8 (bit 3 is now set) ?
return ; no, done
clrf bitpointer ; yes, so we move on to the next byte, let the bitpointer point to the first bit again
incf regpointer,f ; increase the register pointer by one
movlw blockbuff63 + 1 ; one position past buffer, overflow value
subwf regpointer,w ; see if the register pointer has arrived at this overflow register
skpnc ; is the 64 byte block buffer full ?
call MEM_WRITEBLOCK ; yes, write block buffer to external eeprom and reset register pointer, bank1 return
movf regpointer,w ; no, get a copy of the register pointer
movwf fsr ; use this copy to set indirect file pointer to point to this location
clrf indf ; clear every new byte
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_ADD8 ; write eight bits (one byte) to the external eeprom
; actual writes are done when the 64 byte block buffer in pic is full
; this is done to optimize eeprom lifetime
; the byte should be in numlow register
; numlow and nummiddle content is not changed
; databyte0 and databyte1 contents are destroyed
MEM_ADD8_SELECT bank1 ; block buffer pointer registers and eeprom block write buffer are all in bank 1
bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
movf numlow,w ; copy value
movwf databyte0 ;
movf regpointer,w ; get the register location where we will put the data bits
movwf fsr ; use indirect addressing
clrf databyte1 ; use databyte1 as shift register or to clear new locations
movf bitpointer,w ; get the position of the first free bit in this register
skpnz ; is bit number zero the first free bit ?
goto MEM_ADD8_POS0 ; yes, so we can copy the byte directly and don't have to shift any of the bits
MEM_ADD8_POS1_7 movwf bitcounter ; no, we need to shift the bits left, copy value of bitpointer to the loopcounter
clrc ; we only need to clear carry once since databyte1 has been cleared
MEM_ADD8_LOOP rlf databyte0,f ; shift the bits
rlf databyte1,f ; shift the bits
decfsz bitcounter,f ; are all the bits in the right position ?
goto MEM_ADD8_LOOP ; no, go do another shift
MEM_ADD8_POS0 movf databyte0,w ; yes, add the lower bits to the currently selected register of the block buffer
iorwf indf,f ; we use the or operation to add the new bits
incf regpointer,f ; set pointer to the next byte in the buffer
movlw blockbuff63 + 1 ; pointing past buffer, overflow value
subwf regpointer,w ; see if the pointer has arrived at this overflow register
skpnc ; is the 64 byte block buffer full ?
call MEM_WRITEBLOCK ; yes, write block buffer contents to external eeprom and reset register pointer
movf regpointer,w ; no, get the (updated) register location where we will put the data bits
movwf fsr ; use indirect addressing
movf databyte1,w ; get the upper bits or clear byte
movwf indf ; store value
return ; done, we don't have to update bitpointer since we added exactly eight bits
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_ADD10 ; write ten bits to the external eeprom
; actual writes are done when the 64 byte block buffer in pic is full
; this is done to optimize eeprom lifetime
; the bits should be in numlow and nummiddle register
; numlow and nummiddle content stays unchanged
; databyte0, databyte1 and databyte2 content is destroyed
MEM_ADD10_SEL bank1 ; block buffer pointer registers and eeprom block write buffer are all in bank 1
bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
movf numlow,w ; copy value
movwf databyte0 ;
movf nummiddle,w ; copy value
movwf databyte1 ;
movlw b'00000011' ; make sure we use a 10 bit number
andwf databyte1,f ; strip any excess bits
clrf databyte2 ; use databyte2 as shift register or to clear new locations
movf regpointer,w ; get the register location where we will put the data bits
movwf fsr ; use indirect addressing
movf bitpointer,w ; get the position of the first free bit in this register
skpnz ; is bit number zero the first free bit ?
goto MEM_ADD10_POS0 ; yes, so we can copy the bytes directly and don't have to shift any of the bits
MEM_ADD10_POS17 movwf bitcounter ; no, we need to shift the bits left, copy value of bitpointer to the loopcounter
clrc ; we only need to clear carry once since databyte1 and databyte2 have been cleared
MEM_ADD10_LOOP rlf databyte0,f ; shift the bits
rlf databyte1,f ; shift the bits
rlf databyte2,f ; shift the bits
decfsz bitcounter,f ; are all the bits in the right position ?
goto MEM_ADD10_LOOP ; no, go do another shift
MEM_ADD10_POS0 movf databyte0,w ; yes, add the lower bits to the currently selected register of the block buffer
iorwf indf,f ; we use the or operation to add the new bits
incf regpointer,f ; set pointer to the next byte in the buffer
movlw blockbuff63 + 1 ; pointing past buffer, overflow value
subwf regpointer,w ; see if the pointer has arrived at this overflow register
skpnc ; is the 64 byte block buffer full ?
call MEM_WRITEBLOCK ; yes, write block buffer contents to external eeprom and reset register pointer
movf regpointer,w ; no, get the (updated) register location where we will put the data bits
movwf fsr ; use indirect addressing
movf databyte1,w ; no, get (part of) the upper bits
movwf indf ; store these bits
incf bitpointer,f ; update the position of the bitcounter
incf bitpointer,f ; new bitpointer value = (bitpointer + 10) MOD 8 = bitpointer + 2
btfss bitpointer,3 ; was the start position of the bitcounter bit 6 or bit 7 ?
return ; no, still some room left after storing 10 bit value in two registers, done
MEM_ADD10_THREE bcf bitpointer,3 ; yes, no room left or using three registers, update register pointer, clear overflow bit
incf regpointer,f ; set pointer to the next byte in the buffer
movlw blockbuff63 + 1 ; pointing past buffer, overflow value
subwf regpointer,w ; see if the pointer has arrived at this overflow register
skpnc ; is the 64 byte block buffer full ?
call MEM_WRITEBLOCK ; yes, write block buffer contents to external eeprom and reset register pointer
movf regpointer,w ; get the (updated) register location where we will put the data bits
movwf fsr ; use indirect addressing
movf databyte2,w ; no, get the uppermost bit
movwf indf ; store this bit
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_ADD14 ; write fourteen bits to the external eeprom
; actual writes are done when the 64 byte block buffer in pic is full
; this is done to optimize eeprom lifetime
; the bits should be in numlow and nummiddle register
; numlow and nummiddle content stays unchanged
; databyte0, databyte1 and databyte2 content is destroyed
MEM_ADD14_SEL bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
movf numlow,w ; copy value
bank1 ; block buffer pointer registers and eeprom block write buffer are all in bank 1
movwf databyte0 ;
movf nummiddle,w ; copy value
andlw b'00111111' ; make sure we use a 14 bit number
movwf databyte1 ; store result
movf regpointer,w ; get the register location where we will put the data bits
movwf fsr ; use indirect addressing
bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
clrf databyte2 ; use databyte2 as shift register or to clear new locations
movf bitpointer,w ; get the position of the first free bit in this register
skpnz ; is bit number zero the first free bit ?
goto MEM_ADD14_POS0 ; yes, so we can copy the bytes directly and don't have to shift any of the bits
MEM_ADD14_POS17 movwf bitcounter ; no, we need to shift the bits left, copy value of bitpointer to the loopcounter
clrc ; we only need to clear carry once since we know value of databyte1 and databyte2
MEM_ADD14_LOOP rlf databyte0,f ; shift the bits
rlf databyte1,f ; shift the bits
rlf databyte2,f ; shift the bits
decfsz bitcounter,f ; are all the bits in the right position ?
goto MEM_ADD14_LOOP ; no, go do another shift
MEM_ADD14_POS0 movf databyte0,w ; yes, add the lower bits to the currently selected register of the block buffer
iorwf indf,f ; we use the or operation to add the new bits
incf regpointer,f ; set pointer to the next byte in the buffer
movlw blockbuff63 + 1 ; pointing past buffer, overflow value
subwf regpointer,w ; see if the pointer has arrived at this overflow register
skpnc ; is the 64 byte block buffer full ?
call MEM_WRITEBLOCK ; yes, write block buffer contents to external eeprom and reset register pointer
movf regpointer,w ; no, get the (updated) register location where we will put the data bits
movwf fsr ; use indirect addressing
movf databyte1,w ; no, get (part of) the upper bits
movwf indf ; store these bits
movlw d'6' ; update the position of the bitcounter
addwf bitpointer,f ; new bitpointer value = (bitpointer + 14) MOD 8 = bitpointer + 6
btfss bitpointer,3 ; was the start position of the bitcounter bit 2 or greater ?
return ; no, still some room left after storing 14 bit value in two registers, done
MEM_ADD14_THREE bcf bitpointer,3 ; yes, no room left or using three registers, update register pointer, clear overflow bit
incf regpointer,f ; set pointer to the next byte in the buffer
movlw blockbuff63 + 1 ; pointing past buffer, overflow value
subwf regpointer,w ; see if the pointer has arrived at this overflow register
skpnc ; is the 64 byte block buffer full ?
call MEM_WRITEBLOCK ; yes, write block buffer contents to external eeprom and reset register pointer
movf regpointer,w ; get the (updated) register location where we will put the data bits
movwf fsr ; use indirect addressing
movf databyte2,w ; no, get the uppermost bits
movwf indf ; store these bits
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_CLOSE ; write any bytes that are still in the blockbuffer to the external eeprom, unused bytes are
; cleared first, update the table of contents with the address of the last used bit
; this routine may also be called when we didn't store anything yet, when the memory is full
; or when the table of contents is already full and we are just aborting the logging
; note: during the add commands we use a pointer that points to the next free bit,
; but we store the position of last used bit in the toc
MEM_CL_CHECK1 nop ; **** check if we have added anything to store at all
MEM_CL_CHECK2 btfsc flags2,tocfull ; is the table of contents full and should we ignore the call to this subroutine ?
return ; yes, return without updating the table of contents
MEM_CL_CHECKOK movlw blockbuff00 ; no, start of block buffer location
bank1 ; pointer registers and eeprom block write buffer are all in bank 1
subwf regpointer,w ; see if we are still at the first byte of the block buffer
skpz ; did we write anything into the buffer yet ?
goto MEM_CL_CLRBUFF ; yes, go clear rest of bytes in buffer
movf bitpointer,w ; no, also get value of bitpointer
skpnz ; are we sure the buffer is completely empty ?
goto MEM_CL_DECPOINT ; yes, we don't have to write this block to the external eeprom
MEM_CL_CHECKP movlw blockbuff63 ; no, position of last byte in buffer
subwf regpointer,w ; see if we are pointing to the last byte in the buffer
skpnz ; are we pointing to the last byte ?
goto MEM_CL_ADDR ; yes, there are no bytes to be cleared, skip clear routine
MEM_CL_CLRBUFF incf regpointer,w ; no, start at register pointer location plus one with clearing bytes
movwf fsr ; use indirect addressing
bcf status,irp ; make sure upper bit in address is zero (select register bank 0 and 1)
MEM_CL_CLRLOOP clrf indf ; clear byte of buffer, we want to clear all the rest of the buffer
movlw blockbuff63 ; position of last byte in buffer
incf fsr,f ; point to next byte in buffer for when we do loop
subwf fsr,w ; see if the pointer has arrived at last position
skpz ; have we done the all of the 64 byte block buffer ?
goto MEM_CL_CLRLOOP ; no, do loop to clear next byte
MEM_CL_ADDR movf mem_alow,w ; yes, write contents of block buffer to external eeprom, use address of next free block
movwf iicalow ; copy value to iic write routine
movf mem_ahigh,w ; select address high byte
movwf iicahigh ; copy value to iic write routine
movf mem_chip,w ; select chip
movwf iicchip ; copy value to iic write routine
call IIC_WRBLOCK ; do the actual write operation and copy the block into the external eeprom, bank1 return
MEM_CL_DECPOINT decf bitpointer,f ; don't point to next free bit anymore but to the last used bit, decrement pointer one bit
movlw blockbuff00 ; offset between zero and start address of blockbuffer in bank1
subwf regpointer,w ; get lower six bits of the lower address byte (end position can be anywhere in a block)
iorwf mem_alow,f ; merge with upper two bits of low address byte (which always holds start of a block)
comf bitpointer,w ; since decf does not change the carry we use the complement to see if the result is negative
skpnz ; is the complement zero, meaning the result of the decrement was a negative value ?
decf mem_alow,f ; yes, decrease the lower address byte by one because we have to borrow
movlw b'00000111' ; no, when the result from the decrement of the bitpointer is negative then
andwf bitpointer,f ; set the bitpointer to its maximum value instead
comf mem_alow,w ; since decf does not change the carry we use the complement to see if the result is negative
skpnz ; was the result of the decrement of the low byte negative ?
decf mem_ahigh,f ; yes, decrease the higher address byte by one because we have to borrow
comf mem_ahigh,w ; since decf does not change the carry we use the complement to see if the result is negative
skpnz ; is the complement zero, meaning the result of the decrement was a negative value ?
decf mem_chip,f ; yes, borrow from the chip select byte
movlw b'01111111' ; no, when the result from the decrement of the high address byte is negative then
andwf mem_ahigh,f ; set the high address byte to its maximum value instead (we use 15 bit/32kB eeproms)
MEM_CL_WRITETOC movf toc_pointer,w ; get the location in the toc where we should store the address of the last used bit
bank2 ; so we can determine where data from one record stops and a new record begins
movwf iee_address ; copy value for use in to pic eeprom write routine
bank1 ; pointer registers and eeprom block write buffer are all in bank 1
movf mem_alow,w ; get the low byte of the address pointer
call IEE_WRITE ; write one byte to pic eeprom, address in iee_address(bank2), data in w register, bank0 return
bank2 ;
incf iee_address,f ; point to next byte in toc
bank1 ;
movf mem_ahigh,w ; get the high byte of the address pointer
call IEE_WRITE ; write one byte to pic eeprom, address in iee_address(bank2), data in w register, bank0 return
bank2 ;
incf iee_address,f ; point to next byte in toc
bank1 ;
swapf bitpointer,f ; move bitpointer bits to high nibble
movf mem_chip,w ; since the bitpointer and the chip select value are stored in the same byte
iorwf bitpointer,w ; combine values of bitpointer and chip select
call IEE_WRITE ; write one byte to pic eeprom, address in iee_address(bank2), data in w register, bank0 return
return ; done, return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_USAGE nop ; **** get the used space of the external eeprom memory in percent into w register
nop ; **** read end of last record position, do division to get percentage
movlw d'100' ; **** dummy value
return ; **** return in bank?
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_GETNUMRECS ; determine the number of records currently present in the table of contents
; value is stored in num_records in bank3
; registers used: toc_pointer, toc_test, num_records
; returns in bank1 or in bank3
movlw d'255' ; start with number of records is -1
bank3 ;
movwf num_records ;
movlw @tocstart + d'7' ; start address of address bytes of first record in table of contents in internal eeprom
bank1 ;
movwf toc_pointer ; point to this location
MEM_GETNRLOOP bank3 ;
incf num_records,f ; increment number of records by one
movlw @tocstart ; to test for pointer overflow after loop increment see if value of pointer
bank1 ;
subwf toc_pointer,w ; has not wrapped around since the table of contents ends at address 255
skpc ; is the current pointer value valid ?
return ; no, the pointer has wrapped around, exit with number of 20 records, return in bank3
movf toc_pointer,w ; yes, get value of pointer
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank1 ;
movwf toc_test ; store value to test if all three bytes are zero
incf toc_pointer,f ; pointer to the next location in the toc
movf toc_pointer,w ; use copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank1 ;
iorwf toc_test,f ; also test this byte for zero value
incf toc_pointer,f ; pointer to the next location in the toc
movf toc_pointer,w ; use copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank1 ;
iorwf toc_test,f ; also test this byte for zero value
movlw d'8' ; records in toc each take ten bytes, we already increased pointer by two
addwf toc_pointer,f ; point to next record in toc in case we do loop
movf toc_test,w ; now we have to test again if all three bytes are zero
skpz ; is the value of all three byte zero ?
goto MEM_GETNRLOOP ; no, this location is already taken, go see if next location is free
return ; yes, return in bank1
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_SELECTREC ; reset the block download pointers pointer_low/high/chip and endpoint_low/high/chip for the
; given record number, update current_rec
; record number should be in w register
; the pointer values are rounded to block size since we can only download complete blocks
bank3 ; this routine is called only with a valid record selection, no need to check record number
movwf current_rec ; the new record number selection is in w register
movlw @tocstart +d'7' ; start off with pointing to the first address byte of the first record in the toc
bank1 ; we will have to look up the right address
movwf toc_pointer ; so we will use this value in the pointer calculation which follows
bank3 ; this routine is called only with a valid record selection, no need to check record number
decf current_rec,w ; copy selected record number minus one to a loopcounter, value is now 0..19
movwf rec_loopcntr ; we may use this counter in the following loop
skpnz ; is the value zero meaning record number one is currently selected ?
goto MEM_SELECTR_ZER ; yes, this is a special case, the starting address is not in the toc since it is always zero
MEM_SELECTR_INC bank3 ; first time we get here is with records 2..20, loopcounter value 1..19
decf rec_loopcntr,f ; count every record
skpnz ; should we increase the pointer to the next record ?
goto MEM_SELECTR_STA ; no, get values
movlw d'10' ; yes, we repeat until the pointer has the right value
bank1 ; each record uses ten bytes in the table of contents
addwf toc_pointer,f ; point to the next record
goto MEM_SELECTR_INC ; repeat until the pointer has the right value
MEM_SELECTR_STA bank1 ; no, read the values from the toc into the pointer registers
movf toc_pointer,w ; use the value of the tocpointer
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf pointer_low ;
bank1 ;
incf toc_pointer,f ; also for the next byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf pointer_high ;
bank1 ;
incf toc_pointer,f ; and for this byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf pointer_chip ; this value also includes bitpointer
MEM_SELECTR_CAL movlw b'11000000' ; strip the lower six bits from pointer_low value
andwf pointer_low,f ; since we want to start at beginning of the next block
movlw d'64' ; this value is the size of one block
addwf pointer_low,f ; add one block to current block pointer
skpnc ; did we get an overflow of the lower byte ?
incf pointer_high,f ; yes, also increase high byte of pointer
btfsc pointer_high,7 ; no, did we get an overflow of the lower seven bits of the high byte (we use 32k eeproms) ?
incf pointer_chip,f ; yes, also increase the chip select byte
btfsc pointer_high,7 ; no, again, did we get an overflow of the lower seven bits of high byte (we use 32k eeproms) ?
bcf pointer_high,7 ; yes, then reset this bit
movlw b'00001111' ; no, the pointer to the last used bit was stored in upper nibble of the chip select byte
andwf pointer_chip,f ; we only want chip select so strip bitpointer from value
movlw d'8' ; point to end address positions
bank1 ; we already increased the pointer by two positions
addwf toc_pointer,f ; now add the other eight
movf toc_pointer,w ; copy value
MEM_SELECTR_END call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf endpoint_low ;
movlw b'11000000' ; strip the lower six bits from pointer_low value
andwf endpoint_low,f ; since we want to start at beginning of the block
bank1 ;
incf toc_pointer,f ; also for the next byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf endpoint_high ;
bank1 ;
incf toc_pointer,f ; and for this byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf endpoint_chip ; this value also includes bitpointer
movlw b'00001111' ; last free bit pointer is stored in upper nibble
andwf endpoint_chip,f ; we only want chip select so strip bitpointer from value
return ; return in bank3
MEM_SELECTR_ZER clrf pointer_low ; we get here in bank3
clrf pointer_high ; set block pointer to zero for record number one
clrf pointer_chip ; since this record always starts at the bottom of the memory
bank1 ;
movf toc_pointer,w ; get pointer of address bytes of first record
goto MEM_SELECTR_END ; tocpointer was already set to right address for end of record number one
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_GETTIMEDATE ; read the record start time and date of currently selected record from the toc and store
; these in the time and date buffer in bank2
; return in bank2
bsf status,irp ; make sure upper bit in address is one (select bank 2 and 3)
movlw h'68' ; get the time and date bytes in the buffer in bank2
movwf fsr ; since we have to decode them first, set pointer which we will use later
movlw @tocstart -d'10' ; point to the time bytes of first record in the toc,
bank1 ; minus ten bytes since following addition loop runs at least once
movwf toc_pointer ; use this value in the pointer calculation which follows
bank3 ;
movf current_rec,w ; get the currently selected record number and use this number to calculate the offset
movwf rec_loopcntr ; in the table of contents, increment value with one for proper loop end
MEM_GTDFINDLOOP movlw d'10' ; each record uses ten bytes in the table of contents
bank1 ;
addwf toc_pointer,f ; point to the next record
bank3 ;
decfsz rec_loopcntr,f ; should we repeat the addition ?
goto MEM_GTDFINDLOOP ; yes, repeat until the pointer has the right value
MEM_GTDCOPYLOOP bank1 ; no, now go copy the bytes from internal eeprom to buffer
movf toc_pointer,w ; use the value of the tocpointer
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
movwf indf ; store the data value for this address
bank1 ;
incf toc_pointer,f ; point to next position in table of contents
incf fsr,f ; point to the next time and date byte
movlw h'6F' ; position past the last time and date byte
subwf fsr,w ; check if all byte have been written
skpz ; have we copied all bytes ?
goto MEM_GTDCOPYLOOP ; no, repeat until all bytes have been copied to the buffer
return ; return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_GETRECSIZE ; store size (in bits) of currently selected record into registers numlow, nummiddle, numhigh
; this routine is called only with a valid record selection, no need to check record number
movlw @tocstart +d'7' ; start off with pointing to the first address byte of the first record in the toc
bank1 ; we will have to look up the right address for the selected record
movwf toc_pointer ; use this value in the pointer calculation which follows
bank3 ; this routine is called only with a valid record selection, no need to check record number
decf current_rec,w ; copy selected record number minus one to a loopcounter, value is now 0..19
movwf rec_loopcntr ; we may use this counter in the following loop
skpnz ; is the value zero meaning record number one is currently selected ?
goto MEM_RECSIZE_ZER ; yes, this is a special case, the starting address is not in the toc since it is always zero
MEM_RECSIZE_INC bank3 ; first time we get here is with records 2..20, loopcounter value 1..19
decf rec_loopcntr,f ; loopcounter
skpnz ; should we repeat the addition ?
goto MEM_RECSIZE_STA ; no, we are at the right position, go use this location as start address of record
movlw d'10' ; yes, we repeat until the pointer has the right value
bank1 ; each record uses ten bytes in the table of contents
addwf toc_pointer,f ; point to the next record
goto MEM_RECSIZE_INC ; do loop until we get right address
MEM_RECSIZE_STA bank1 ; no, read the values from the toc into the pointer registers
movf toc_pointer,w ; use the value of the tocpointer
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf recsizea0 ; a0/a1/a2 is the smaller number (record n), b0/b1/b2 will be the larger number (record n+1)
bank1 ; so result is record size = b - a [bits]
incf toc_pointer,f ; also for the next byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf recsizea1 ;
bank1 ;
incf toc_pointer,f ; and for this byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf recsizea2 ; this value is combined chipselect (least significant nibble) and bitpointer (upper nibble)
movlw d'8' ; move pointer to end address position bytes
bank1 ; we already increased the pointer by two positions
addwf toc_pointer,f ; now add the other eight
MEM_RECSIZE_CAL bank3 ; we have to adjust the start address
movlw b'11000000' ; use the end address of a previous record to calculate the start of the next record
andwf recsizea0,f ; find the start of the last used block by stripping the lower six bits from the low byte
movlw d'64' ; this value is the size of one block
addwf recsizea0,f ; add one block to point to the next block, which is not used yet
skpnc ; did we get an overflow of the lower byte ?
incf recsizea1,f ; yes, also increase high byte
btfsc recsizea1,7 ; no, did we get an overflow of the lower seven bits of the high byte (we use 32k eeproms) ?
incf recsizea2,f ; yes, also increase the chip select byte
btfsc recsizea1,7 ; no, again, did we get an overflow of the lower seven bits of high byte (we use 32k eeproms) ?
bcf recsizea1,7 ; yes, then reset this bit
movlw b'00001111' ; no, the pointer to the last used bit was stored in upper nibble of the chip select byte
andwf recsizea2,f ; we only want the chip select value so strip this nibble
MEM_RECSIZE_END bank1 ; select bank since we may come from bank3 (record number is zero code below)
movf toc_pointer,w ; get pointer of address bytes of first record
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf recsizeb0 ;
bank1 ;
incf toc_pointer,f ; also for the next byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf recsizeb1 ;
bank1 ;
incf toc_pointer,f ; and for this byte
movf toc_pointer,w ; get copy of value
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
bank3 ;
movwf recsizeb2 ; this value also includes bitpointer
MEM_RECSIZE_HI rlf recsizeb2,w ; the b recordsize registers hold larger address
movwf numhigh ; calculate address from bitp/chipselect, high address byte and low address byte
rlf numhigh,f ; store address in numlow, nummiddle and numhigh
rlf recsizeb0,w ;
movwf numlow ;
rlf recsizeb1,w ;
movwf nummiddle ;
rlf numhigh,f ;
rlf numlow,f ;
rlf nummiddle,f ;
rlf recsizeb2,f ;
rlf numhigh,f ;
rlf numlow,f ; alow43210 bitp210
rlf nummiddle,f ; ahigh43210 alow765
rlf recsizeb2,w ;
andlw b'00011111' ;
movwf numhigh ; 0 0 0 chip210 ahigh65
MEM_RECSIZE_LO rlf recsizea2,w ; the a recordsize registers hold smaller address
movwf recsizeb2 ; calculate address from bitp/chipselect, high address byte and low address byte
rlf recsizeb2,f ; store address in recsizeb2, recsizeb1, recsizeb0
rlf recsizea0,w ;
movwf recsizeb0 ;
rlf recsizea1,w ;
movwf recsizeb1 ;
rlf recsizeb2,f ;
rlf recsizeb0,f ;
rlf recsizeb1,f ;
rlf recsizea2,f ;
rlf recsizeb2,f ;
rlf recsizeb0,f ;
rlf recsizeb1,f ;
rlf recsizea2,w ;
andlw b'00011111' ;
movwf recsizeb2 ;
MEM_RECSIZE_SUB movf recsizeb0,w ; now do subtraction to get record size
subwf numlow,f ; store result in numlow, nummiddle and numhigh
movf recsizeb1,w ;
skpc ;
incfsz recsizeb1,w ;
subwf nummiddle,f ;
movf recsizeb2,w ;
skpc ;
incfsz recsizeb2,w ;
subwf numhigh,f ;
MEM_RECSIZE_ADD movlw d'1' ; because of the way we store the start and end position of a record in the table of contents
addwf numlow,f ; we have to add one extra bit to the size of the record
skpnc ; a record of one bit will not be found in the toc since the start and end addresses are of
incf nummiddle,f ; the same value, therefore the minimum size of a record is two bits
skpnz ;
incf numhigh,f ;
return ; return in bank3
MEM_RECSIZE_ZER clrf recsizea0 ; set block pointer to zero for record number one
clrf recsizea1 ; since this record always starts at the bottom of the memory
clrf recsizea2 ;
goto MEM_RECSIZE_END ; tocpointer is already at right address
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_RDBLOCK ; copy data block from external eeprom to the block buffer in bank1
; carry set when all blocks done
; return in bank1 or bank3
MEM_RDBL_CHECK2 bank3 ;
movf pointer_low,w ; check for end of record, have we sent all blocks?
subwf endpoint_low,w ; subtract, first low bytes
movf pointer_high,w ; high byte
skpc ; did we have to borrow ?
incfsz pointer_high,w ; yes, adjust value
subwf endpoint_high,w ; no, subtract high bytes
movf pointer_chip,w ; chip select bytes
skpc ; did we have to borrow ?
incfsz pointer_chip,w ; yes, adjust value
subwf endpoint_chip,w ; no, subtract chip select bytes
skpnc ; do we have a valid address ?
goto MEM_RDBL_COPY ; yes, go copy the block from external eeprom to buffer in bank1
setc ; no, set carry as indication that we have already read all blocks of this record
return ; carry has been set, return in bank3
MEM_RDBL_COPY bank3 ; get block pointer
movf pointer_low,w ; address low byte
bank1 ;
movwf iicalow ; copy value
bank3 ;
movf pointer_high,w ; select address high byte
bank1 ;
movwf iicahigh ; copy value
bank3 ;
movf pointer_chip,w ; select chip
bank1 ;
movwf iicchip ; copy value
call IIC_RDBLOCK ; read 64 bytes from external eeprom, address in iicchip, iicalow and iicahigh, bank1 return
clrc ; clear carry
return ; return in bank1
;--------------------------------------------------------------------------------------------------------------------------------------
MEM_INC_RDBLOCK ; auto increment blockpointer, then copy data block from external eeprom to the block
; buffer in bank1
; carry set when all blocks done
; return in bank1 or bank3
MEM_RDBL_CHECK1 bank3 ;
movf pointer_low,w ; check for end of record, have we sent all blocks?
subwf endpoint_low,w ; subtract, first low bytes
movf pointer_high,w ; high byte
skpc ; did we have to borrow ?
incfsz pointer_high,w ; yes, adjust value
subwf endpoint_high,w ; no, subtract high bytes
movf pointer_chip,w ; chip select bytes
skpc ; did we have to borrow ?
incfsz pointer_chip,w ; yes, adjust value
subwf endpoint_chip,w ; no, subtract chip select bytes
skpnc ; do we have a valid address ?
goto MEM_RDBL_INCADD ; yes, go copy the block from external eeprom to buffer in bank1
setc ; no, set carry as indication that we have already read all blocks of this record
return ; carry has been set, return in bank3
MEM_RDBL_INCADD movlw d'64' ; no, this is the size of one memory block in external eeprom
bank3 ;
addwf pointer_low,f ; increment memory block pointer, first low byte
skpc ; do we need to update high byte as well ?
goto MEM_RDBLOCK ; no, go check address again, then copy block
incf pointer_high,f ; yes, do so
btfsc pointer_high,7 ; the current eeprom chips are 32kB (15 bits address), did we get an overflow ?
incf pointer_chip,f ; yes, also increase chip select byte
bcf pointer_high,7 ; no, we don't use bit 7 since we have 32kB eeproms, clear bit
goto MEM_RDBLOCK ; go check address again, then copy block
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
org h'1000' ; start of program memory page 2
;--------------------------------------------------------------------------------------------------------------------------------------
; RS232 subroutines for transmitting and receiving bytes and numbers (ascii strings)
;--------------------------------------------------------------------------------------------------------------------------------------
; a command byte sequence is (in ascii):
; <STX> 1 byte indicator for start of command, value hex 02
; <c1> 1 byte, first letter of command
; <c2> 1 byte, second letter of command
; <data bytes> 0-64 data bytes, all values accepted except ascii codes STX and ETX
; <checksum> 1 byte checksum (see below), any hex value 00-FF
; <ETX> 1 byte indicator for end of command, value hex 03
; checksum value makes sum of all bytes from <STX> up to and including <ETX> zero
TX_BINVALUE addlw h'30' ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
TX_BYTE ; transmit content of w register through RS232 (odd parity)
; checksum calculation is included
; w register content is destroyed
; returns in bank0
bank0 ; select bank, then calculate what the value of the parity bit is going to be:
movwf tx_byte ; w holds the byte to be transmitted, store w for use after the parity calculation
addwf tx_checksum,f ; use byte in checksum calculation
movwf tx_parity ;
swapf tx_parity,w ; use w and tx_parity registers for the calculation
xorwf tx_parity,f ; calculate nibbles
rrf tx_parity,w ;
xorwf tx_parity,f ; at this point the parity values of the nibbles are in bit 2 and bit 0
btfss tx_parity,2 ; if parity one nibble is 1 then the byte parity is that of other nibble, skip ahead
incf tx_parity,f ; otherwise, invert bit 0
bank1 ;
bcf txsta,tx9d ; first assume we should reset the parity bit that will be send
bank0 ;
btfss tx_parity,0 ; was it the right decision to reset the bit ?
goto TX_LOOP ; yes, go send the byte
bank1 ;
bsf txsta,tx9d ; no, first set the parity bit and then send the byte
bank0 ;
TX_LOOP btfss pir1,txif ; yes, ready to send ? (bit set means transmit buffer is empty)
goto TX_LOOP ; no, keep trying
TX_POLL_RTS btfsc portc,rts_in ; is the PC input buffer empty, so are we allowed to send data ? (RTS serves as a CTS here)
goto TX_POLL_RTS ; no, keep trying
; **** to do: we would like to have some timeout testing here....
movf tx_byte,w ; yes, move character to w
movwf txreg ; transmit byte
;nop ; there is a delay of one instruction cycle after writing to txreg, before txif gets cleared
return ; line above, nop, is just information for of possible future changes, return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
TX_COMMANDSTART ; send ACK, STX and command mnemonics
movlw h'06' ; Acknowledgement (ACK)
call TX_BYTE ; send 'command has been accepted', return in bank0
clrf tx_checksum ; start off with clear checksum value
movlw h'02' ; STX
call TX_BYTE ; return in bank0
movf rx_buffer00,w ; location of first letter of mnemonic in RS232 buffer
call TX_BYTE ;
movf rx_buffer01,w ; location of second letter of mnemonic in RS232 buffer
call TX_BYTE ;
return ;
;--------------------------------------------------------------------------------------------------------------------------------------
TX_COMMANDEND ; send checksum and ETX, clear command status byte
bank0 ;
movlw h'03' ; ETX
call TX_BYTE ; transmit, return in bank0
movf tx_checksum,w ; get checksum value
sublw d'0' ; calculate right value (all command bytes added should result in zero value)
call TX_BYTE ; transmit, return in bank0
bcf flags1,command ; now command has been handled we can clear the execute flag
bcf portc,cts_out ; set CTS to re-enable data stream from computer
bsf portb,led_red ; turn on red status led
bcf portb,led_green ; turn off green status led
return ; return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
TX_NUMBER ; this routine transmits the 8 bit number (0-255) in the w register via RS232 as
; (up to three) ascii characters without preceding zeros (23 will be sent as '23'
; and not as '023'), transmit checksum is calculated
; w register content is destroyed
; returns in bank0
; 255 byte value
;
; 100 100
; 10 10
; 1 1
bank0
movwf tx_numberl ; store the value of the number for use in the calculation
movlw b'10000000' ; use the upper bit of the counter as a flag for preceding zeros,
movwf tx_counter ; 1 means skip characters
movlw d'100' ; how many hundreds ?
call TX_DIGIT ; send digit
movlw b'10000000' ; select flag bit
andwf tx_counter,f ; clear counter but keep preceding zeros flag bit
movlw d'10' ; how many tens ?
call TX_DIGIT ; send digit
clrf tx_counter ; the last character always has to be sent so clear counter and flag bit too
movlw d'1' ; how many ones ?
goto TX_DIGIT ; goto instead of call because we are done here
TX_NLOOP bcf tx_counter,7 ; this character is non-zero, so begin sending characters
incf tx_counter,f ; increment counter
TX_DIGIT subwf tx_numberl,f ; subtract
skpnc ; is the result negative ?
goto TX_NLOOP ; no, repeat
addwf tx_numberl,f ; undo negative result, we need the right value for the rest of the calculation
btfsc tx_counter,7 ; can we still skip the preceding zero characters ?
return ; yes, skip those characters
movlw a'0' ; in ascii numbers start at 30 hex
addwf tx_counter,w ; so add the counter to get the right ascii code
call TX_BYTE ; send the ascii character stored in register w, return in bank0
return ; return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
TX_LNUMBER ; this routine transmits the 16 bit number (0-65535) in the registers numlow and
; nummiddle via RS232 as (up to five) ascii characters without preceding zeros
; transmit checksum is calculated
; w register content is destroyed
; returns in bank0
; 65,535 high_byte low_byte
;
; 10,000 39 16
; 1,000 3 232
; 100 0 100
; 10 0 10
; 1 0 1
movf numlow,w ; get lower byte of number
bank0 ;
movwf tx_numberl ; store it for use during calculation
movf nummiddle,w ; get upper byte of number
movwf tx_numberh ; store it for use during calculation
movlw b'10000000' ; use the upper bit of the counter as a flag for preceding zeros,
movwf tx_counter ; 1 means skip characters
movlw d'16' ; first count number of 10,000's, lower byte of binary number 10,000
movwf templow ;
movlw d'39' ; upper byte of binary number 10,000
movwf temphigh ;
call TX_LDIGIT ;
movlw d'232' ; count number of 1,000's, lower byte of binary number 1,000
movwf templow ;
movlw d'3' ; upper byte of binary number 1,000
movwf temphigh ;
call TX_LDIGIT ;
movlw d'100' ; count number of 100's, lower byte of binary number 100
movwf templow ;
clrf temphigh ; high byte is zero
call TX_LDIGIT ;
movlw d'10' ; count number of 10's, lower byte of binary number 10
movwf templow ;
clrf temphigh ; high byte is zero
call TX_LDIGIT ;
movlw d'1' ; count number of 1's, lower byte of binary number 1
movwf templow ;
clrf temphigh ; high byte is zero
clrf tx_counter ; the last character always has to be sent so clear counter and flag bit too
goto TX_LDIGIT ; goto instead of call because we are done here
TX_LDIGIT movlw b'10000000' ; select flag bit
andwf tx_counter,f ; clear counter but keep flag bit for preceding zeros
TX_LTEST movf templow,w ; check if subtraction will give positive or zero result
subwf tx_numberl,w ; compare lower byte
movf temphigh,w ;
skpc ;
incfsz temphigh,w ;
subwf tx_numberh,w ; high byte
skpc ; is the result >= zero ?
goto TX_LSEND ; no, result is negative, go send character
TX_LSUBTR bcf tx_counter,7 ; yes, clear flag bit since we skipped possible zero character, now start sending characters
incf tx_counter,f ; increment counter
movf templow,w ; subtract
subwf tx_numberl,f ; low byte
movf temphigh,w ;
skpc ;
incfsz temphigh,w ; high byte
subwf tx_numberh,f ;
goto TX_LTEST ; next
TX_LSEND btfsc tx_counter,7 ; can we still skip the preceding zero characters ?
return ; yes, skip those characters
movlw a'0' ; in ascii numbers start at 30 hex
addwf tx_counter,w ; so add the counter to get the right ascii code
call TX_BYTE ; send the ascii character stored in register w,return in bank0
return ; return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
TX_WNUMBER ; this routine transmits the 24 bit number (0-16777215)('wide' number) in the registers
; numlow(lsB), nummiddle (middle byte) and numhigh (msB) (word extended) via RS232 as
; (up to eight) ascii characters without preceding zeros, a transmit checksum is calculated
; w register content is destroyed
; returns in bank0
;
; 16,777,215 upper_byte middle_byte lower_byte
; 10,000,000 152 150 128
; 1,000,000 15 66 64
; 100,000 1 134 160
; 10,000 0 39 16
; 1,000 0 3 232
; 100 0 0 100
; 10 0 0 10
; 1 0 0 1
bank0 ;
movf numlow,w ; get lower byte of number
movwf tx_numberl ; store it for use during calculation
movf nummiddle,w ; get middle byte of number
movwf tx_numberm ; store it for use during calculation
movf numhigh,w ; get upper byte of number
movwf tx_numberh ; store it for use during calculation
movlw b'10000000' ; use the upper bit of the counter as a flag for preceding zeros,
movwf tx_counter ; 1 means skip characters
movlw d'128' ; first count number of 10,000,000's, lower byte
movwf templow ;
movlw d'150' ; middle byte
movwf tempmiddle ;
movlw d'152' ; upper byte
movwf temphigh ;
call TX_WDIGIT ;
movlw d'64' ; count number of 1,000,000's, lower byte
movwf templow ;
movlw d'66' ; middle byte
movwf tempmiddle ;
movlw d'15' ; upper byte
movwf temphigh ;
call TX_WDIGIT ;
movlw d'160' ; count number of 100,000's, lower byte
movwf templow ;
movlw d'134' ; middle byte
movwf tempmiddle ;
movlw d'1' ; upper byte
movwf temphigh ;
call TX_WDIGIT ;
movlw d'16' ; count number of 10,000's, lower byte
movwf templow ;
movlw d'39' ; middle byte
movwf tempmiddle ;
clrf temphigh ; upper byte is zero
call TX_WDIGIT ;
movlw d'232' ; number of 1,000's
movwf templow ;
movlw d'3' ; middle byte
movwf tempmiddle ;
clrf temphigh ; upper byte is zero
call TX_WDIGIT ;
movlw d'100' ; number of 100's
movwf templow ;
clrf tempmiddle ; middle byte is zero
clrf temphigh ; upper byte is zero
call TX_WDIGIT ;
movlw d'10' ; count number of 10's
movwf templow ;
clrf tempmiddle ; middle byte is zero
clrf temphigh ; upper byte is zero
call TX_WDIGIT ;
movlw b'00000001' ; count number of 1's
movwf templow ;
clrf tempmiddle ; middle byte is zero
clrf temphigh ; high byte is zero
clrf tx_counter ; the last character always has to be sent so clear counter and flag bit too
goto TX_WDIGIT ; goto instead of call because we are done here
TX_WDIGIT movlw b'10000000' ; select flag bit
andwf tx_counter,f ; clear counter but keep flag bit for preceding zeros
TX_WTEST movf templow,w ; check if subtraction will give positive or zero result
subwf tx_numberl,w ; compare lower byte
movf tempmiddle,w ;
skpc ;
incfsz tempmiddle,w ;
subwf tx_numberm,w ; middle byte
movf temphigh,w ;
skpc ;
incfsz temphigh,w ; high byte
subwf tx_numberh,w ;
skpc ; is the result >= zero ?
goto TX_WSEND ; no, result is negative, go send character
TX_WSUBTR bcf tx_counter,7 ; yes, clear flag bit since we skipped possible zero character, now start sending characters
incf tx_counter,f ; increment counter
movf templow,w ; subtract
subwf tx_numberl,f ; low byte
movf tempmiddle,w ;
skpc ;
incfsz tempmiddle,w ;
subwf tx_numberm,f ; middle byte
movf temphigh,w ;
skpc ;
incfsz temphigh,w ; high byte
subwf tx_numberh,f ;
goto TX_WTEST ; next
TX_WSEND btfsc tx_counter,7 ; can we still skip the preceding zero characters ?
return ; yes, skip those characters
movlw a'0' ; in ascii numbers start at 30 hex
addwf tx_counter,w ; so add the counter to get the right ascii code
call TX_BYTE ; send the ascii character stored in register w,return in bank0
return ; return in bank0
;--------------------------------------------------------------------------------------------------------------------------------------
TX_TIMEANDDATE ; this routine transmits the time and date values from the buffer in bank2 as a string
; use Windows format: 'DD/MM/YY HH:MM:SS'
; transmit checksum is calculated
; w register content is destroyed
; returns in bank2
bank2 ;
swapf date,w ; get date/ 10 date
andlw b'00000011' ; strip date
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
bank2 ;
movf date,w ; get date/ 10 date
andlw b'00001111' ; strip 10 date
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
movlw a'/' ;
call TX_BYTE ;
bank2 ;
swapf month,w ; get months/ 10 month
andlw b'00000001' ; strip months
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
bank2 ;
movf month,w ; get months/ 10 month
andlw b'00001111' ; strip 10 month
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
movlw a'/' ;
call TX_BYTE ;
bank2 ;
swapf year,w ; get year/ 10 year
andlw b'00001111' ; strip year
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
bank2 ;
movf year,w ; get year/ 10 year
andlw b'00001111' ; strip 10 year
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
movlw a' ' ;
call TX_BYTE ;
bank2 ;
swapf hours,w ; get hours/ 10 hours
andlw b'00000011' ; strip hours
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
bank2 ;
movf hours,w ; get 10 hours/ hours
andlw b'00001111' ; strip 10 hours
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
movlw a':' ;
call TX_BYTE ;
bank2 ;
swapf minutes,w ; get minutes/ 10 minutes
andlw b'00000111' ; strip minutes
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
bank2 ;
movf minutes,w ; get 10 minutes/ minutes
andlw b'00001111' ; strip 10 minutes
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
movlw a':' ;
call TX_BYTE ;
bank2 ;
swapf seconds,w ; get seconds/ 10 seconds / oscillator enable
andlw b'00000111' ; strip seconds / oscillator enable
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
bank2 ;
movf seconds,w ; get seconds/ 10 seconds / oscillator enable
andlw b'00001111' ; strip 10 seconds / oscillator enable
call TX_BINVALUE ; transmit the binary value (0..9) in w register as an ascii character ('0'..'9')
return ; return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
TX_FREQVALSTR ; w register should hold the frequency settings value
; this routine transmits the corresponding value from the table below as an ascii string
; 00000000 32
; 00000001 16
; 00000011 8
; 00000111 4
; 00001111 2
; 00011111 1
; 00111111 0.5
; 01111111 0.25
; 11111111 0
TX_FREQ_32 bank0 ;
movwf tx_numberl ;
movlw b'00000000' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_16 ;
movlw a'3' ;
call TX_BYTE ; transmit byte , return in bank0
movlw a'2' ;
call TX_BYTE ; transmit byte , return in bank0
return ; return in bank0
TX_FREQ_16 movlw b'00000001' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_8 ;
movlw a'1' ;
call TX_BYTE ;
movlw a'6' ;
call TX_BYTE ;
return ;
TX_FREQ_8 movlw b'00000011' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_4 ;
movlw a'8' ;
call TX_BYTE ;
return ;
TX_FREQ_4 movlw b'00000111' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_2 ;
movlw a'4' ;
call TX_BYTE ;
return ;
TX_FREQ_2 movlw b'00001111' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_1 ;
movlw a'2' ;
call TX_BYTE ;
return ;
TX_FREQ_1 movlw b'00011111' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_0.5 ;
movlw a'1' ;
call TX_BYTE ;
return ;
TX_FREQ_0.5 movlw b'00111111' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_0.25 ;
movlw a'0' ;
call TX_BYTE ;
movlw a'.' ;
call TX_BYTE ;
movlw a'5' ;
call TX_BYTE ;
return ;
TX_FREQ_0.25 movlw b'01111111' ;
subwf tx_numberl,w ;
skpz ;
goto TX_FREQ_0 ;
movlw a'0' ;
call TX_BYTE ;
movlw a'.' ;
call TX_BYTE ;
movlw a'2' ;
call TX_BYTE ;
movlw a'5' ;
call TX_BYTE ;
return ;
TX_FREQ_0 movlw b'11111111' ;
subwf tx_numberl,w ;
skpz ;
return ;
movlw a'0' ;
call TX_BYTE ;
return ;
;--------------------------------------------------------------------------------------------------------------------------------------
GET_NUMBER ; reads the ascii characters of the RS232 input buffer and converts this data to an
; eight bit number (0-255), preceding zeros are accepted
; returns in bank 0 with:
; w holds number - carry is cleared - read OK
; w holds junk - carry is set - error: not a number
bank0 ;
clrf templow ; we will add the values of each character to this register, so start with zero
movlw (rx_buffer00+2) ; start position of data in buffer (runs up to and includes maxpos)
movwf fsr ; point to this address
bcf status,irp ; make sure upper bit in address is zero (select bank 0 and 1)
READVALUE movlw h'3A' ; subtract 3A hex from the buffer number
subwf indf,w ; if the character is a number, the result should be negative
skpnc ; is the result negative?
HIGHERR return ; no, so it is not an ascii number, we cannot handle this data, exit with carry set, error
addlw h'0A' ; yes, if the character is a number then the result of this addition should be positive
skpc ; is the result positive ?
LOWERR goto GN_ERROR ; no, we cannot handle this data
ADDVALUE addwf templow,f ; yes, store the resulting value
skpnc ; is the resulting number greater than 255 decimal ?
return ; yes, so it won't fit in 1 byte, we cannot handle this data, exit with carry set, error
POINTER incf fsr,f ; no, increase pointer to point to next value
movf fsr,w ; use pointer value
subwf rx_maxpos,w ; was this the last character ?
skpc ; let's see
goto READOK ; yes, end loop and go to exit with carry cleared as indication for no errors
TESTSIZE movlw d'26' ; the value should be smaller than 26 because 25 times 10 will be 250
subwf templow,w ; and we know there is a next character, result should fit in one byte
skpnc ; will the result times 10 be larger than 250 ?
return ; yes, we cannot handle this data, exit with carry set, error
TIMES10 clrc ; no, go multiply the current value by ten, start off with clear carry bit:
rlf templow,f ; first times two,
movf templow,w ; store in w,
rlf templow,f ; and this makes times 4,
rlf templow,f ; and this times 8,
addwf templow,f ; plus 2 is 10 times
goto READVALUE ; next, do loop again and add new numbers
GN_ERROR setc ; indication for not a number, error
return ; done
READOK movf templow,w ; what is the resulting number value of the ascii characters ?
return ; done, exit with carry cleared as indication for no errors
;--------------------------------------------------------------------------------------------------------------------------------------
GET_LNUMBER ; reads the ascii characters of the RS232 input buffer and converts this data to an
; a number from 0-65535, preceding zeros are accepted
; returns in bank 0 with:
; numlow & nummiddle hold number - carry is cleared - read OK
; numlow & nummiddle hold junk - carry is set - error: not a number
bank0 ;
clrf numlow ; we will add the values of each character to these registers,
clrf nummiddle ; so start with zero
movlw (rx_buffer00+2) ; start position of data in buffer (runs up to and includes maxpos)
movwf fsr ; point to this address
bcf status,irp ; make sure upper bit in address is zero (select bank 0 and 1)
LREADVALUE movlw h'3A' ; subtract 3A hex from the buffer number
subwf indf,w ; if the character is a number, the result should be negative
skpnc ; is the result negative?
LHIGHERR goto LGN_ERROR ; no, so it is not an ascii number we cannot handle this data
addlw h'0A' ; yes, if the character is a number then the result of this addition should be positive
skpc ; is the result positive ?
LLOWERR goto LGN_ERROR ; no, we cannot handle this data
LADDVALUE addwf numlow,f ; yes, store the resulting value
skpc ; is the resulting number greater than 255 decimal ?
goto LPOINTER ; no, go get next character
incf nummiddle,f ; yes, add one count to upper byte of number (perform two byte add with carry)
skpnz ; is the resulting number greater than 65535 decimal ?
goto LGN_ERROR ; yes, so it won't fit in 2 bytes, we cannot handle this data
LPOINTER incf fsr,f ; no, increase pointer to point to next value
movf fsr,w ; use pointer value
subwf rx_maxpos,w ; was this the last character ?
skpc ; let's see
return ; yes, end loop and exit with carry cleared as indication for no errors
LTESTSIZE movlw d'231' ; the value of the upper byte should not be more than 25 because 25 times 10 will be 250
addwf nummiddle,w ; and we know there is a next character, the result should fit in two bytes
skpnc ; is the value of the upper byte equal or more than 25 ?
goto LTESTMORE ; yes, go see how much it is exactly and see how much is the lower byte
LTIMES10 bcf status,c ; yes, go multiply the current value by ten, start off with clear carry bit:
rlf numlow,f ; first times two,
movf numlow,w ;
movwf templow ; store value temporarily
rlf nummiddle,f ; first times two, use carry bit from lower byte
movf nummiddle,w ;
movwf temphigh ; store value temporarily
rlf numlow,f ; and this makes times 4, lower byte
rlf nummiddle,f ; and this makes times 4, upper byte, use carry bit of lower byte
rlf numlow,f ; and this makes times 8, lower byte
rlf nummiddle,f ; and this makes times 8, upper byte, use carry bit of lower byte
movf templow,w ;
addwf numlow,f ; plus 2 is 10 times, lower byte
skpnc ;
incf nummiddle,f ; transport carry bit
movf temphigh,w ;
addwf nummiddle,f ; plus 2 is 10 times, upper byte
goto LREADVALUE ; next, do loop again and add new numbers
LTESTMORE skpz ; is the value exactly 25 ?
return ; no, number won't fit in two bytes therefore we cannot handle this data, exit with carry set
movlw d'154' ; yes, lower byte should be smaller than 154 because the total value should be less than 6553
subwf numlow,w ;
skpc ; is the number represented by the two bytes smaller than 6554 ?
goto LTIMES10 ; yes, continue and multiply by 10 and then fetch next character
LGN_ERROR setc ; set error flag
return ; no, number won't fit in two bytes therefore we cannot handle this data, exit with carry set
;--------------------------------------------------------------------------------------------------------------------------------------
GET_TIMEANDDATE ; convert the 17 byte Windows format input string 'DD/MM/YY HH:MM:SS' into eight bytes for
; clock, store the values in the time and date buffer in bank2
; w register content destroyed
; returns in bank2
bank0 ; DATE
movlw h'30' ; ascii to binary offset
subwf rx_buffer03,w ; get Day and convert from ascii character to binary value
bank2 ;
movwf date ; move value to clock buffer
bank0 ;
movlw h'30' ;
subwf rx_buffer02,f ; get 10 Days and convert from ascii character to binary value
swapf rx_buffer02,w ; place result in upper four bits
bank2 ;
iorwf date,f ;
bank0 ; MONTH
movlw h'30' ; ascii to binary offset
subwf rx_buffer06,w ; get Months and convert from ascii character to binary value
bank2 ;
movwf month ; move value to clock buffer
bank0 ;
movlw h'30' ;
subwf rx_buffer05,f ; get 10 Months and convert from ascii character to binary value
swapf rx_buffer05,w ; place result in upper four bits
bank2 ;
iorwf month,f ;
bank0 ; YEAR
movlw h'30' ; ascii to binary offset
subwf rx_buffer09,w ; get Years and convert from ascii character to binary value
bank2 ;
movwf year ; move value to clock buffer
bank0 ;
movlw h'30' ;
subwf rx_buffer08,f ; get 10 Years and convert from ascii character to binary value
swapf rx_buffer08,w ; place result in upper four bits
bank2 ;
iorwf year,f ;
bank0 ; HOURS
movlw h'30' ; ascii to binary offset
subwf rx_buffer12,w ; get Hours and convert from ascii character to binary value
bank2 ;
movwf hours ; move value to clock buffer
bank0 ;
movlw h'30' ;
subwf rx_buffer11,f ; get 10 Hours and convert from ascii character to binary value
swapf rx_buffer11,w ; place result in upper four bits
bank2 ;
iorwf hours,f ;
bcf hours,6 ; select 24 hour clock
bank0 ; MINUTES
movlw h'30' ; ascii to binary offset
subwf rx_buffer15,w ; get Minutes and convert from ascii character to binary value
bank2 ;
movwf minutes ; move value to clock buffer
bank0 ;
movlw h'30' ;
subwf rx_buffer14,f ; get 10 Minutes and convert from ascii character to binary value
swapf rx_buffer14,w ; place result in upper four bits
bank2 ;
iorwf minutes,f ;
bank0 ; SECONDS
movlw h'30' ; ascii to binary offset
subwf rx_buffer18,w ; get Seconds and convert from ascii character to binary value
bank2 ;
movwf seconds ; move value to clock buffer
bank0 ;
movlw h'30' ;
subwf rx_buffer17,f ; get 10 Seconds and convert from ascii character to binary value
swapf rx_buffer17,w ; place result in upper four bits
bank2 ;
iorwf seconds,f ;
bcf seconds,7 ; set bit to enable clock oscillator, is CH (clock halt) bit in clock chip
movlw d'1' ; day 1
movwf day ; just start DAY start at day 1, Sunday, although we don't know this for sure, doesn't matter
movlw b'10000011' ; set square wave at 32768 Hz but disabled and it's output high
movwf clockctrl ; CONTROL
return ; return in bank2
;--------------------------------------------------------------------------------------------------------------------------------------
GET_FREQVALNUM ; convert string data that goes with the logfrequency setting commands to the right lograte
; value according to the following table (example for 16 Hz: 16 > 00000001)
; carry cleared - value is ok
; carry set - error reading number
; 32 00000000
; 16 00000001
; 8 00000011
; 4 00000111
; 2 00001111
; 1 00011111
; 0.5 00111111
; 0.25 01111111
; 0 11111111 (actually 1xxxxxxx is used since only bit 7 is tested)
F_32 bank0 ;
movlw a'3' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_16 ;
movlw a'2' ;
subwf rx_buffer03,w ; test second data byte
skpz ;
goto F_ERROR ;
movlw rx_buffer03 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'00000000' ;
clrc ; clear carry to indicate result is ok
return
F_16 movlw a'1' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_8 ;
movlw rx_buffer03 ;
subwf rx_maxpos,w ; test length first, we not only have the value 16 but also the value 1
skpz ;
goto F_1 ;
movlw a'6' ;
subwf rx_buffer03,w ; test second data byte
skpz ;
goto F_ERROR ;
movlw b'00000001' ;
clrc ; clear carry to indicate result is ok
return
F_8 movlw a'8' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_4 ;
movlw rx_buffer02 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'00000011' ;
clrc ; clear carry to indicate result is ok
return
F_4 movlw a'4' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_2 ;
movlw rx_buffer02 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'00000111' ;
clrc ; clear carry to indicate result is ok
return
F_2 movlw a'2' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_1 ;
movlw rx_buffer02 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'00001111' ;
clrc ;
return ; clear carry to indicate result is ok
F_1 movlw a'1' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_0 ;
movlw rx_buffer02 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'00011111' ;
clrc ; clear carry to indicate result is ok
return
F_0 movlw a'0' ; test first data byte
subwf rx_buffer02,w ;
skpz ;
goto F_ERROR ;
movlw rx_buffer02 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_0.5 ;
movlw b'11111111' ;
clrc ; clear carry to indicate result is ok
return
F_0.5 movlw a'.' ; test second data byte
subwf rx_buffer03,w ;
skpz ;
goto F_ERROR ;
movlw a'5' ; test third data byte
subwf rx_buffer04,w ;
skpz ;
goto F_0.25 ;
movlw rx_buffer04 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'00111111' ;
clrc ; clear carry to indicate result is ok
return
F_0.25 movlw a'2' ; test third data byte
subwf rx_buffer04,w ;
skpz ;
goto F_ERROR ;
movlw a'5' ; test fourth data byte
subwf rx_buffer05,w ;
skpz ;
goto F_ERROR ;
movlw rx_buffer05 ;
subwf rx_maxpos,w ; test length
skpz ;
goto F_ERROR ;
movlw b'01111111' ;
clrc ; clear carry to indicate result is ok
return
F_ERROR setc ; none of the values matched
return ; return with carry set as indication result is not ok
;--------------------------------------------------------------------------------------------------------------------------------------
; Commands:
;--------------------------------------------------------------------------------------------------------------------------------------
COMMANDS ; label to allow use of pagesel
;--------------------------------------------------------------------------------------------------------------------------------------
EXIT_ACK movlw h'06' ; acknowledgement (ACK)
call TX_BYTE ; send 'command has been accepted', return in bank0
bcf flags1,command ; now command has been handled we can clear the execute flag, ready for next command
bcf portc,cts_out ; set CTS to re-enable data stream from computer
bsf portb,led_red ; turn on red status led
bcf portb,led_green ; turn off green status led
return ; done
;--------------------------------------------------------------------------------------------------------------------------------------
EXIT_NAK movlw h'15' ; unknown command, exit, send negative acknowledgement (NAK)
call TX_BYTE ; send 'command has NOT been accepted', return in bank0
bcf flags1,command ; clear any command bytes received up to now get, ready for next command
bcf portc,cts_out ; set CTS to re-enable data stream from computer
bsf portb,led_red ; turn on red status led
bcf portb,led_green ; turn off green status led
return ; go back to main program loop see what else we can do
;--------------------------------------------------------------------------------------------------------------------------------------
AU ; read the string with the name of the author of this software uses a table read that works
; anywhere in the memory. A normal table read using just the 'addwf pcl' instruction will only
; work if the program code and table code are entirely in the first 8-bit page of program
; memory = the first 256 memory locations !
; a write opens the backdoor for the serial number write (command SE)
btfsc flags1,withdata ; is there any data ?
goto AU_COMMAND ; yes, so we should use this data
call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank3 ;
clrf tablepointer ; start the reading of the table at the first position
AU_LOOP movlw high AU_TABLE ; see where the assembler will put the table in PIC memory and get the high byte
movwf pclath ; now move this into pclath
movlw low AU_TABLE+1 ; load w with the memory address low byte of the first piece of data in the table
addwf tablepointer,w ; calculate the offset address and see if it overflows
skpnc ; did it overflow ?
incf pclath,f ; yes, so increase pclath one count
AU_GET_CHAR call AU_TABLE ; no, lookup value in table, returns ascii character in w register
xorlw d'00' ; zero indicates end of table
skpnz ; are we at the end of the table ?
goto TX_COMMANDEND ; yes, exit: send checksum and ETX, clear command flag
call TX_BYTE ; returns in bank0
bank3 ;
incf tablepointer,f ; point to next position in table
goto AU_LOOP ;
AU_TABLE movwf pcl ; w contains low program counter byte and points to the next location plus counter
retlw a'A' ; offset text in table is 'Andries C. Tip'
retlw a'n' ;
retlw a'd' ; Note: in a Microchip application note it states that it is neccesary to disable the
retlw a'r' ; interrupts before executing the instruction movwf pcl because an interrupt during
retlw a'i' ; this instruction may cause the program to jump to an unknown address. It turnes
retlw a'e' ; out to be not true, so table reads do not have to disable any interrupts.
retlw a's' ;
retlw a' ' ;
retlw a'C' ;
retlw a'.' ;
retlw a' ' ;
retlw a'T' ;
retlw a'i' ;
retlw a'p' ;
retlw d'00' ; end of message
AU_COMMAND bsf flags1,changese ; backdoor to allow serial number to be changed
goto EXIT_NAK ; exit and be ready for next command
;--------------------------------------------------------------------------------------------------------------------------------------
CA ; read/write value of static ram address (value 0..63)
; write: input is ascii string with 8 bit number
btfsc flags1,withdata ; is there any data ?
goto CA_COMMAND ; yes, so we should use this data
CA_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank2 ;
movf clockaddr,w ;
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
CA_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
andlw b'11000000' ; the maximum address for the clock chip static ram and control bytes is 63
skpz ; is the address value valid ?
goto EXIT_NAK ; no, exit and be ready for next command
call GET_NUMBER ; again, read the data input number that goes with the command into the w register
bank2 ;
movwf clockaddr ;
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
CD ; IIC clock chip serial control bytes and static ram read/ write
btfsc flags1,withdata ; is there any data ?
goto CD_COMMAND ; yes, so we should use this data
CD_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel IIC_RD_CLKCHIP ; make right program memory page selection
call IIC_RD_CLKCHIP ; get data byte from clock chip into w register
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
CD_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
pagesel IIC_WR_CLKCHIP ; make right program memory page selection
call IIC_WR_CLKCHIP ; write byte to static ram
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
CL ; read/set clock time and data in the following format HH:MM:SS MM/DD/YY
; external clock chip is Dallas DS1307 (www.dalsemi.com)
btfsc flags1,withdata ; is there any data ?
goto CL_COMMAND ; yes, so we should use this data to write to the clock chip through IIC
CL_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel IIC_RDCLOCK ; make right program memory page selection
call IIC_RDCLOCK ; read the eight time related bytes from external clock chip into buffer (bank2, 68..6F hex)
pagesel TX_TIMEANDDATE ; make right program memory page selection
call TX_TIMEANDDATE ; send time and date values from the buffer in bank2 as a string, bank2 return
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
CL_COMMAND call GET_TIMEANDDATE ; convert string serial input buffer, store in time and date buffer in bank2, bank2 return
pagesel IIC_WRCLOCK ; make right program memory page selection
call IIC_WRCLOCK ; write the eight time related bytes from buffer in bank2 (68..6F) to clock
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
EA ; set eeprom read/write address
; write: input string is 8 bit address
btfsc flags1,withdata ; is there any data ?
goto EA_COMMAND ; yes, so we should use this data to write to the eeprom location
EA_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank2 ;
movf iee_address,w ; get address of eeprom location
bank0 ;
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
EA_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
bank2 ;
movwf iee_address ; store the number for later use with command ED
bank0 ;
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
ED ; read/write eeprom memory location
; write: input is ascii string with 8 bit number
btfsc flags1,withdata ; is there any data ?
goto ED_COMMAND ; yes, so we should use this data to write to the eeprom location
ED_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank2 ;
movf iee_address,w ; get address of eeprom location
bank0 ;
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
ED_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
pagesel IEE_WRITE ; no, make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
ER ; read/write error flags byte
; write: input is ascii string with 8 bit number
btfsc flags1,withdata ; is there any data ?
goto ER_COMMAND ; yes, so we should use this data to write to the eeprom location
ER_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank3 ;
movf errors,w ; get value of error flags register
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
ER_COMMAND movlw d'15' ; eeprom address for error flags register
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
movwf errors ; write value to error flags register
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FA ; read/write air temperature logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FA_COMMAND ; yes, so we should use this data to write to the eeprom location
FA_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_air,w ; get value of lograte for air temperature channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FA_COMMAND movlw d'21' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_air ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FB ; read/write brake switch logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FB_COMMAND ; yes, so we should use this data to write to the eeprom location
FB_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_brake,w ; get value of lograte for brake switch channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FB_COMMAND movlw d'27' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_brake ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FE ; read/write lateral acceleration logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FE_COMMAND ; yes, so we should use this data to write to the eeprom location
FE_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_lat,w ; get value of lograte for lateral acceleration channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FE_COMMAND movlw d'25' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_lat ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FH ; read/write thermocouple logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FH_COMMAND ; yes, so we should use this data to write to the eeprom location
FH_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_tc,w ; get value of lograte for thermocouple channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FH_COMMAND movlw d'20' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_tc ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FL ; read/write lambda logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FL_COMMAND ; yes, so we should use this data to write to the eeprom location
FL_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_lambda,w ; get value of lograte for lambda channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FL_COMMAND movlw d'18' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_lambda ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FM ; read/write mark switch logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FM_COMMAND ; yes, so we should use this data to write to the eeprom location
FM_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_mark,w ; get value of lograte for mark switch channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FM_COMMAND movlw d'26' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_mark ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FO ; read/write longitudinal acceleration logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FO_COMMAND ; yes, so we should use this data to write to the eeprom location
FO_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_long,w ; get value of lograte for longitudinal acceleration channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FO_COMMAND movlw d'24' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_long ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FR ; read/write rpm logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FR_COMMAND ; yes, so we should use this data to write to the eeprom location
FR_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_rpm,w ; get value of lograte for rpm channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FR_COMMAND movlw d'16' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_rpm ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FS ; read/write speed logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FS_COMMAND ; yes, so we should use this data to write to the eeprom location
FS_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_speed,w ; get value of lograte for speed channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FS_COMMAND movlw d'17' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_speed ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FT ; read/write throttle logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FT_COMMAND ; yes, so we should use this data to write to the eeprom location
FT_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_throttle,w ; get value of lograte for throttle channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FT_COMMAND movlw d'23' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_throttle ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FV ; read/write voltage logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FV_COMMAND ; yes, so we should use this data to write to the eeprom location
FV_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_voltage,w ; get value of lograte for voltage channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FV_COMMAND movlw d'19' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_voltage ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
FW ; read/write water temperature logging frequency from/to pic eeprom
btfsc flags1,withdata ; is there any data ?
goto FW_COMMAND ; yes, so we should use this data to write to the eeprom location
FW_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
movf freq_water,w ; get value of lograte for water temperature channel
call TX_FREQVALSTR ; transmit value as string, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
FW_COMMAND movlw d'22' ; eeprom address for log frequency setting
bank2 ;
movwf iee_address ; set internal eeprom address pointer
call GET_FREQVALNUM ; read the value that goes with the command, convert it and put it in w register
skpnc ; were there any errors reading the value ?
goto EXIT_NAK ; yes, exit
bank3 ; no,
movwf freq_water ; copy value
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
ID ; read the identification string explaining the application of this PIC chip
; uses a table read that works anywhere in the memory.
; A normal table read using just the 'addwf pcl' instruction will only work if the
; program code and table code are entirely in the first 8-bit page of program
; memory = the first 256 memory locations !
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank3 ;
clrf tablepointer ; start the reading of the table at the first position
ID_LOOP movlw high ID_TABLE ; see where the assembler will put the table in PIC memory and get the high byte
movwf pclath ; now move this into pclath
movlw low ID_TABLE+1 ; load w with the memory address low byte of the first piece of data in the table
addwf tablepointer,w ; calculate the offset address and see if it overflows
skpnc ; did it overflow ?
incf pclath,f ; yes, so increase pclath one count
ID_GET_CHAR call ID_TABLE ; no, lookup value in table, returns ascii character in w register
xorlw d'00' ; zero indicates end of table
skpnz ; are we at the end of the table ?
goto TX_COMMANDEND ; yes, exit: send checksum and ETX, clear command status byte
call TX_BYTE ; returns in bank0
bank3 ;
incf tablepointer,f ; point to next position in table
goto ID_LOOP ;
ID_TABLE movwf pcl ; w contains low program counter byte and points to the next location plus counter
retlw a'M' ; offset text in table is 'Motorcycle Datalogger'
retlw a'o' ;
retlw a't' ; Note: in a Microchip application note it states that it is neccesary to disable the
retlw a'o' ; interrupts before executing the instruction movwf pcl because an interrupt during
retlw a'r' ; this instruction may cause the program to jump to an unknown address. It turnes
retlw a'c' ; out to be not true, so table reads do not have to disable any interrupts.
retlw a'y' ;
retlw a'c' ;
retlw a'l' ;
retlw a'e' ;
retlw a' ' ;
retlw a'D' ;
retlw a'a' ;
retlw a't' ;
retlw a'a' ;
retlw a'l' ;
retlw a'o' ;
retlw a'g' ;
retlw a'g' ;
retlw a'e' ;
retlw a'r' ;
retlw d'00' ; end of message
;--------------------------------------------------------------------------------------------------------------------------------------
KC ; read/write wheel circumference [mm] to/from pic eeprom
; value is used in speed calculation
; write: input is ascii string with 16 bit number
btfsc flags1,withdata ; is there any data ?
goto KC_COMMAND ; yes, so we should use this data
KC_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
movlw d'0' ; eeprom address 0
bank2 ;
movwf iee_address ; set address of pic eeprom location
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
movwf numlow ;
movlw d'1' ; eeprom address 1
movwf iee_address ; set address of pic eeprom location
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
movwf nummiddle ;
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
KC_COMMAND call GET_LNUMBER ; read the data input number that goes with the command into the numlow and nummiddle register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
movlw d'0' ;
bank2 ;
movwf iee_address ; set address of pic eeprom location
movf numlow,w ;
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
movlw d'1' ;
bank2 ;
movwf iee_address ; set address of pic eeprom location
movf nummiddle,w ;
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel COPY_WHEELC ; make right program memory page selection
call COPY_WHEELC ; *** do not update while logging/calculate constant from value
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
KP ; read/write pulses per revolution to/from pic eeprom
; value is used in rpm calculation
; write: input is ascii string with 8 bit number (only values 1 and 2 are allowed)
btfsc flags1,withdata ; is there any data ?
goto KP_COMMAND ; yes, so we should use this data
KP_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
movlw d'4' ; eeprom address 4
bank2 ;
movwf iee_address ; set address of pic eeprom location
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w register as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
KP_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
sublw d'1' ; no, the number should be one or two
KP_TESTONE skpnz ; is the value one ?
goto KP_VALUEOK ; yes, go store value
call GET_NUMBER ; no, read the data input number that goes with the command into the w register
sublw d'2' ; the number should be one or two
KP_TESTTWO skpz ; is the value two ?
goto EXIT_NAK ; no, exit and be ready for next command
KP_VALUEOK movlw d'4' ; yes, eeprom address 4
bank2 ;
movwf iee_address ; set address of pic eeprom location
call GET_NUMBER ; read the data input number that goes with the command into the w register
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel COPY_RPMVALUES ; make right program memory page selection
call COPY_RPMVALUES ; copy the value from eeprom to pic registers for use during the ccp interrupt
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
KR ; set or read the maximum RPM rate, above this RPM rate, the shift light will be
; turned on when the measured rpm value is more than this maximum, otherwise the shift
; light is off
; write: input is ascii string with a number of not more than 14 bits (0..16383)
btfsc flags1,withdata ; is there any data ?
goto KR_COMMAND ; yes, so we should use this data
KR_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
movlw d'2' ; eeprom address for rpm maximum low byte
pagesel IEE_READ ; make right program memory page selection
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
movwf numlow ;
movlw d'3' ; eeprom address for rpm maximum high byte
call IEE_READ ; read value from internal eeprom, address in w, data returned in w, return in bank2
movwf nummiddle ;
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
KR_COMMAND call GET_LNUMBER ; read the data input number that goes with the command into the numlow and nummiddle register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
movlw b'11000000' ; value for test
andwf nummiddle,w ; test if the upper two bits of the received number are ones
skpz ; is the received number larger than 16383 ?
goto EXIT_NAK ; yes, so it will not fit in 14 bits, exit and be ready for next command
movlw d'2' ; no, continue, this is the eeprom address for the rpm maximum low byte
bank2 ;
movwf iee_address ; select eeprom write address
movf numlow,w ;
pagesel IEE_WRITE ; make right program memory page selection
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
movlw d'3' ; eeprom address for the rpm maximum high byte
bank2 ;
movwf iee_address ; select eeprom write address
movf nummiddle,w ;
call IEE_WRITE ; write data to eeprom, address in iee_address, data in w
pagesel COPY_RPMVALUES ; make right program memory page selection
call COPY_RPMVALUES ; copy the value from eeprom to pic registers for use during the ccp interrupt
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
LS ; **** select start condition for logging (RPM, mark button...)
; input value is eight bit number
btfsc flags1,withdata ; is there any data ?
goto LS_COMMAND ; yes, so we should use this data
LS_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'0' ; **** dummy value
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
LS_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
nop ; **** store the value in the proper place
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
LV ; **** select value for start condition for logging (when RPM, Speed...)
; input value is 16 bit, use 14 bits for RPM or 8 bits for speed
btfsc flags1,withdata ; is there any data ?
goto LV_COMMAND ; yes, so we should use this data
LV_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'0' ; **** dummy value
movwf numlow ;
movwf nummiddle ;
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
LV_COMMAND call GET_LNUMBER ; read the data input number that goes with the command into numlow and nummiddle registers
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
;nop ; **** store the value in the proper place
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
RC ; clear all record memory
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RC_COMMAND ; empty line to prevent illegal label error from MPLAB IDE
pagesel MEM_CLEAR ; make right program memory page selection
call MEM_CLEAR ; clear all bytes of the table of contents, return in bank3
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
RD ; download record data in blocks of 64 bytes
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RD_REQUEST bank3 ; check if there are any records
movf current_rec,w ; get currently selected record number, zero for no selection yet or when no records available
skpnz ; are there any records and has there been a record selected yet ?
goto EXIT_NAK ; no, exit
pagesel MEM_RDBLOCK ; yes, make right program memory page selection
call MEM_RDBLOCK ; copy data block to buffer in bank1, increase blocknumber, carry set when all blocks were done
pagesel EXIT_NAK ; make right program memory page selection
RD_RI_CODE skpnc ; have we sent all blocks ? (from here same code for RD and RI commands)
goto EXIT_NAK ; yes, exit
RD_TRANSMIT call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bcf status,irp ; make sure upper bit in address is zero (select bank 0 and 1)
movlw blockbuff00 ; start position of data in buffer in bank1
movwf fsr ; point to this address
RD_LOOP bank1 ; the buffer is in bank 1
movf indf,w ; read the data byte at the right position in the buffer
call TX_BYTE ; transmit the value of the w register, return in bank0
incf fsr,f ; increase pointer to point to next value
movf fsr,w ; get pointer value
sublw blockbuff63 ; was this the last byte ?
skpnc ; let's see
goto RD_LOOP ; no, do loop again and read next data byte
goto TX_COMMANDEND ; no, send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
RI ; increment block number, then download record data in blocks of 64 bytes
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RI_REQUEST bank3 ; check if there are any records
movf current_rec,w ; get currently selected record number, zero for no selection yet or when no records available
skpnz ; are there any records and has there been a record selected yet ?
goto EXIT_NAK ; no, exit
pagesel MEM_INC_RDBLOCK ; yes, make right program memory page selection
call MEM_INC_RDBLOCK ; copy data block to buffer in bank1, increase blocknumber, carry set when all blocks were done
pagesel RD_RI_CODE ; make right program memory page selection
goto RD_RI_CODE ; from here same code as for RD command, save space
;--------------------------------------------------------------------------------------------------------------------------------------
RM ; return the percentage of memory that is used
; value 0..100%
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RM_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel MEM_USAGE ; make right program memory page selection
call MEM_USAGE ; **** get the percentage of used space of external eeprom memory into w register, bank? return
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
RN ; number of records in datalogger memory
; value 0..20
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RN_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel MEM_GETNUMRECS ; make right program memory page selection
call MEM_GETNUMRECS ; get the number of records stored in memory, value stored in num_records, bank1/3 return
bank3 ;
movf num_records,w ; copy the number of records
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
RS ; select one record for downloading and reset the block download position to the start of
; this record
; valid value range is 1..number of available records (maximum 20)
btfsc flags1,withdata ; is there any data ?
goto RS_COMMAND ; yes, so we should use this data
RS_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank3 ;
movf current_rec,w ; get the number of the currently selected record
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
RS_COMMAND ; empty line to prevent illegal label error from MPLAB IDE
pagesel MEM_GETNUMRECS ; make right program memory page selection
call MEM_GETNUMRECS ; get the number of records stored in memory, value stored in num_records, bank1/3 return
pagesel GET_NUMBER ; make right program memory page selection
call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
iorlw d'0' ; see if number is zero without changing w register, the number should not be less than one
skpnz ; is the number zero ?
goto EXIT_NAK ; yes, exit
bank3 ; no, continue
subwf num_records,w ; see if the new value is valid
skpc ; is the new value more than the available number of records ?
goto EXIT_NAK ; yes, do not update value and exit, be ready for next command
call GET_NUMBER ; no, again read the data input number that goes with the command into the w register
pagesel MEM_SELECTREC ; make right program memory page selection
call MEM_SELECTREC ; select record for downloading by value in w register and reset the block download pointer
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
RT ; read start time and date of the currently selected record
; in the following format HH:MM:SS MM/DD/YY
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RT_REQUEST bank3 ; no, check current record selection
movf current_rec,w ; test for zero value
skpnz ; are there any records and is there already a valid record selected ?
goto EXIT_NAK ; no, exit
call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel MEM_GETTIMEDATE ; make right program memory page selection
call MEM_GETTIMEDATE ; store start time and date of currently selected record in the time and date buffer in bank2
pagesel TX_TIMEANDDATE ; make right program memory page selection
call TX_TIMEANDDATE ; send time and date values from the buffer in bank2 as a string, bank2 return
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
RZ ; get record size (in bits !) of currently selected record
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
RZ_REQUEST bank3 ; no, check current record selection
movf current_rec,w ; test for zero value
skpnz ; are there any records and is there already a valid record selected ?
goto EXIT_NAK ; no, exit
call TX_COMMANDSTART ; yes, send ACK, STX and command mnemonics
pagesel MEM_GETRECSIZE ; make right program memory page selection
call MEM_GETRECSIZE ; store size (in bits) of currently selected record into registers numlow, nummiddle, numhigh
pagesel TX_WNUMBER ; make right program memory page selection
call TX_WNUMBER ; transmit the 24 bit number in numlow(lsB), nummiddle and numhigh(msB), bank0 return
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
SE ; get serial number of device from location in bootloader area
; the four topmost words in PIC flash memory are reserved for storing serial numbers etc.
; after the write backdoor is closed again
btfsc flags1,withdata ; is there any data ?
goto SE_COMMAND ; yes, so we should use this data
SE_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
call SE_LOADADDRESS ; bank2 return
pagesel FLASHREAD ; make right program memory page selection
call FLASHREAD ; read flash program memory, address in eeadr/eeadrh, data in eedata/eedath, bank3 return
bank2 ;
movf eedata,w ; get data value into wordlow and wordmiddle
movwf numlow ;
movf eedath,w ;
movwf nummiddle ;
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
SE_COMMAND call GET_LNUMBER ; read the data input number that goes with the command into the numlow and nummiddle register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
btfss flags1,changese ; check the backdoor flag that allows the serial number to be changed
goto EXIT_NAK ; yes, exit and be ready for next command
movlw b'00111111' ; words of pic program memory are 14 bits wide, strip upper two bits
andwf nummiddle,f ;
movf numlow,w ; copy data
bank2 ;
movwf eedata ; low
movf nummiddle,w ;
movwf eedath ; high
bcf flags1,changese ; clear backdoor flag that allows serial number to be changed
call SE_LOADADDRESS ; bank2 return
pagesel FLASHWRITE ; make right program memory page selection
call FLASHWRITE ; write flash memory,addr. in eeadr/eeadrh,data in eedata/eedath, carry set on error, bank2 ret.
pagesel EXIT_ACK ; make right program memory page selection
skpnc ; was the data written ok ?
goto EXIT_NAK ; exit, there was a data write verification error
goto EXIT_ACK ; done
SE_LOADADDRESS bank2 ;
movlw h'FF' ; get low byte value
movwf eeadr ; low byte
movlw h'1F' ; get low byte value
movwf eeadrh ; high byte
return ; return in bank2
;-------------------------------------------------------------------------------------------------------------------------------------
SV ; read firmware build version (for example: 1.66)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
SV_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
movlw fwv0 ; version bytes, defined at the very top of this program
call TX_BYTE ;
movlw a'.' ;
call TX_BYTE ;
movlw fwv1 ;
call TX_BYTE ;
movlw fwv2 ;
call TX_BYTE ;
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
V0 ; get values of all inputs (read only), separated by a horizonal tab (456 22 1014 ...)
; actual command mnemonic is V$, but we cannot use the dollar character in labels
; transmit order:
; RPM,speed,lambda,voltage,thermocouple,air,water,throttle,longitudinal,lateral,digital
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
V0_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
V0_RPM ; prevent mplab ide errror
pagesel CALC_RPM ; make right program memory page selection
call CALC_RPM ; yes, calculate the RPM value from the time interval between the input pulses, return in bank2
movf rpm_low,w ; get low byte value
movwf numlow ;
movf rpm_high,w ; get high byte value
movwf nummiddle ;
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
V0_TAB0 movlw d'9' ; seperator character is ascii horizontal tab character
call TX_BYTE ; send separator character
V0_SPEED ; prevent mplab ide errror
pagesel CALC_SPEED ; make right program memory page selection
call CALC_SPEED ; calculate speed value from time interval between input pulses, return in bank2
movf speed,w ; get value
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w register as ascii characters
V0_TAB1 movlw d'9' ; seperator character is ascii horizontal tab character
call TX_BYTE ; send separator character
V0_ANALOG_CHAN clrf adchannel ; start at channel zero
V0_LOOP movf adchannel,w ; select channel
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
V0_TAB2 movlw d'9' ; seperator character is ascii horizontal tab character
call TX_BYTE ; send separator character
incf adchannel,f ; select next channel
movlw d'8' ; there's eight analog channels
subwf adchannel,w ; see if we have done all
skpz ; was this the last measurement ?
goto V0_LOOP ; no, next
V0_DIGITAL bank0 ; yes,
movf portb,w ; get the status of portb
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; exit, send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VA ; get value of air temperature analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VA_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'3' ; analog input channel 3
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VD ; get the value of digital portb, which are the digital inputs (upper two bits are outputs)
; read: bit7=green led, red led, brdsuppl,tcdisc,laptime,brake,mark,_run_/log=bit0
; write: only upper two bits (the leds) are written
btfsc flags1,withdata ; is there any data ?
goto VD_COMMAND ; yes, so we should use this data to write to the eeprom location
VD_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank0 ;
movf portb,w ; get the status of portb
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
VD_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
bank0
xorwf portb,w ; calculate the difference between new data and the actual status
andlw b'11000000' ; mask, we only should only change bits 6 and 7 which are outputs
xorwf portb,f ; flip bits if they are not the same and write the new value to portb
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
VE ; get value of lateral g-sensor analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VE_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'7' ; analog input channel 7
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VH ; get value of throttle (handlebar) analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VH_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'5' ; analog input channel 5
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VI ; set or read the eight leds of port D (shift light leds)
btfsc flags1,withdata ; is there any data ?
goto VI_COMMAND ; yes, so we should use this data
VI_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
bank0 ;
movf portd,w ; get the current leds status
call TX_NUMBER ; transmits the value of w as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
VI_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
bank0 ;
movwf portd ; set leds to new value
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
VL ; get value of lambda analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VL_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'0' ; analog input channel 0
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VO ; get value of longitudinal g-sensor analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VO_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'6' ; analog input channel 6
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VR ; returns value of engine rpm, calculated from pulses on CCP1 input
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VR_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel CALC_RPM ; make right program memory page selection
call CALC_RPM ; calculate the RPM value from the time interval between the input pulses, return in bank2
movf rpm_low,w ; get low byte value
bank0 ;
movwf numlow ;
bank2 ;
movf rpm_high,w ; get high byte value
bank0 ;
movwf nummiddle ;
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
VS ; returns value of vehicle speed in km/hr, calculated from pulses on CCP2 input
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VS_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel CALC_SPEED ; make right program memory page selection
call CALC_SPEED ; calculate speed value from time interval between input pulses, return in bank2
movf speed,w ; get value
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmits the value of w register as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
;--------------------------------------------------------------------------------------------------------------------------------------
VT ; get value of thermocouple analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VT_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'2' ; analog input channel 2
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters, return in bank0
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VV ; get value of voltage analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VV_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'1' ; analog input channel 1
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
VW ; get value of water temperature analog input (read only)
btfsc flags1,withdata ; is there any data ?
goto EXIT_NAK ; yes, exit
VW_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
movlw d'4' ; analog input channel 4
pagesel GET_ANALOG ; make right program memory page selection
call GET_ANALOG ; get value of analog input (selected by w register) into numlow and nummiddle, return in bank1
pagesel TX_LNUMBER ; make right program memory page selection
call TX_LNUMBER ; transmit value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command flag
;--------------------------------------------------------------------------------------------------------------------------------------
XA ; set external eeprom address, input is ascii string with 16 bit number
btfsc flags1,withdata ; is there any data ?
goto XA_COMMAND ; yes, so we should use this data
XA_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank1 ;
movf iicalow,w ; copy iic address registers to rs232 number receive/transmit registers
bank0 ;
movwf numlow ;
bank1 ;
movf iicahigh,w ;
bank0 ;
movwf nummiddle ;
call TX_LNUMBER ; transmits the value of numlow and nummiddle as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
XA_COMMAND call GET_LNUMBER ; read the data input number that goes with the command into the numlow and nummiddle register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
btfsc nummiddle,7 ; size of the eeproms is 32k x 8 (256kbit), therefore the address maximum is 32767
goto EXIT_NAK ;
movf numlow,w ; store address in iic address registers
bank1 ;
movwf iicalow ;
bank0 ;
movf nummiddle,w ;
bank1 ;
movwf iicahigh ;
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
XC ; select external eeprom chip, input is ascii character with 8 bit number (0..7)
btfsc flags1,withdata ; is there any data ?
goto XC_COMMAND ; yes, so we should use this data
XC_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
bank1 ;
movf iicchip,w ; get number of selected chip
call TX_NUMBER ; transmits the value w register as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
XC_COMMAND call GET_NUMBER ; read the data input number that goes with the command into w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
sublw d'7' ; maximum number of eeprom chips is eight, therefore the number should be from 0..7
skpc ; is the number larger than 7 ?
goto EXIT_NAK ; yes, exit and be ready for next command
sublw d'7' ; no, restore w register content to its previous value
bank1 ;
movwf iicchip ; store new chip select value
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
XD ; read/write data byte from external eeprom value
; write: input is ascii string with 8 bit number
btfsc flags1,withdata ; is there any data ?
goto XD_COMMAND ; yes, so we should use this data
XD_REQUEST call TX_COMMANDSTART ; send ACK, STX and command mnemonics
pagesel IIC_RDBYTE ; make right program memory page selection
call IIC_RDBYTE ; read data byte from external eeprom, address is in iicchip, iicalow and iicahigh
bank1 ;
movf iicdata,w ; store data byte in w register
bank0 ;
pagesel TX_NUMBER ; make right program memory page selection
call TX_NUMBER ; transmit the value of the w register as ascii characters
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
XD_COMMAND call GET_NUMBER ; read the data input number that goes with the command into the w register
skpnc ; errors reading number ?
goto EXIT_NAK ; yes, exit and be ready for next command
bank1 ;
movwf iicdata ; store data byte from w register
pagesel IIC_WRBYTE ; make right program memory page selection
call IIC_WRBYTE ; write byte in iicdata to external eeprom, address in iicchip, iicalow and iicahigh
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
XP ; read/write data 1 block of 64 bytes from external eeprom
; write 64 bytes of data from RS232 input buffer
; **** the receive routine prevents the character h'03' to be included in the data !
btfsc flags1,withdata ; is there any data ?
goto XP_COMMAND ; yes, so we should use this data
XP_REQUEST call TX_COMMANDSTART ; no, send ACK, STX and command mnemonics
pagesel IIC_RDBLOCK ; make right program memory page selection
call IIC_RDBLOCK ; read 64 data bytes from external eeprom, address in iicchip, iicalow and iicahigh
bcf status,irp ; make sure upper bit in bank address is zero (select bank 0 and 1)
movlw h'AF' ; start position of data in buffer in bank1
movwf fsr ; point to this address
XP_LOOP1 movf indf,w ; read the data byte at the right position in the buffer
pagesel TX_BYTE ; make right program memory page selection
call TX_BYTE ; transmit the value of the w register
incf fsr,f ; increase pointer to point to next value
movf fsr,w ; use pointer value
sublw h'EE' ; was this the last byte ?
skpnc ; let's see
goto XP_LOOP1 ; no, do loop again and read next data byte
goto TX_COMMANDEND ; send checksum and ETX, clear command status byte
XP_COMMAND bank0 ; check that we actually got 64 bytes
movlw rx_buffer65 ; position of last data byte
subwf rx_maxpos,w ; test length
skpz ; did we get exactly 64 data bytes ?
goto EXIT_NAK ; no, exit and be ready for next command
movlw h'2F' ; yes, copy the 64 databytes from databuffer in bank0 to the block buffer in bank1
movwf fsr ; point to the start position of the data buffers in bank0 and bank1 (!)
bcf status,irp ; make sure upper bit in bank address is zero (select bank 0 and 1)
XP_LOOP2 movf indf,w ; read the data byte at the right position in the buffer
bsf fsr,7 ; the block buffer is in bank1 (hex 80 to hex FF)
movwf indf ; write the data byte
incf fsr,f ; increase pointer to point to next value
bcf fsr,7 ; the receive databuffer is in bank 0 (hex 00 to hex 7F)
movf fsr,w ; use pointer value
sublw h'6E' ; was this the last byte ?
skpnc ; let's see
goto XP_LOOP2 ; no, do loop again and read next data byte
pagesel IIC_WRBLOCK ; make right program memory page selection
call IIC_WRBLOCK ; yes, write 64 bytes to external eeprom, address in iicchip, iicalow and iicahigh
pagesel EXIT_ACK ; make right program memory page selection
goto EXIT_ACK ; done
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
;--------------------------------------------------------------------------------------------------------------------------------------
org h'1800' ; start of program memory page 3
;--------------------------------------------------------------------------------------------------------------------------------------
; command interpreter: find and go execute selected command
;--------------------------------------------------------------------------------------------------------------------------------------
;
; to do commands are marked with a '>' character
; non optimized commands are marked with '***'
;
; mnemonic read/ value range or description
; write example
;
;
; AU R(/W) Andries C. Tip returns software author, a write opens the backdoor to change serial number
;
; CL R/W 05/31/04 11:23:47 clock time and date in the following format MM/DD/YY HH:MM:SS
; CA R/W 0..63 clock static ram address byte (address wraps around)
; CD R/W 0..255 clock static ram data byte at address specified by CA
;
; EA R/W 0..255 address location for PIC internal eeprom
; ED R/W 0..255 data of the PIC internal eeprom at the address specified by EA
; ER R/W 0..255 error flag bits, bits will be set when errors occur during logging
;
; FA R/W 32 air temperature logging frequency
; FB R/W 16 brake switch logging frequency
; FE R/W 8 lateral acceleration logging frequency
; FH R/W 0 thermocouple logging frequency
; FL R/W 2 lambda logging frequency
; FM R/W 1 mark switch logging frequency
; FO R/W 0.5 longitudinal acceleration logging frequency
; FR R/W 0.25 rpm logging frequency
; FS R/W 0 speed logging frequency
; FT R/W 4 throttle logging frequency
; FV R/W 0 voltage logging frequency
; FW R/W 0 water temperature logging frequency
;
; ID R Motorcycle Datalogger returns device identification string
;
; >KA R/W 0..16383 engine stationary RPM adjust, left half of leds are on, 0=off
; >KB R/W 0..16383 engine high RPM adjust. right half of leds are on, 0=off
; KC R/W 1..65535 wheel circumference [millimeters] used in speed calculation
; >KN R/W 1..255 puls count setting: Number of notches/pulses per revolution of wheel
; >KP R/W 2 pulses per crankshaft revolution, used in rpm calculation
; KR R/W 0..16383 max RPM rate, leds will flash above this rate
;
; >LS R/W 0..255 select logging start condition (Rotary switch, Mark Button, Speed, RPM)
; >LV R/W 0..16363 select value for logging start condition (when RPM/Speed)
;
; >PA R/W 1..7/13 select the desired logging resolution of a channel
;
; RN R 0..20 number of records in datalogger memory
; RS R/W 0..19 select a record for downloading
; RT R 07/28/04 12:32:04 record start time and date in the following format MM/DD/YY HH:MM:SS
; RZ R 93645543 get record size (in bits !) and reset download position
; RD R 6%gr'@:sE.... download record data in blocks of one block (64 bytes)
; RI R 6%gr'@:sE.... increment block, then download record data in blocks of one block (64 bytes)
; RC W clear all record memory
; >RM R 0..100 memory usage/maximum memory address ??
;
; >SD R 14/28/04 device programming date, stored in flash program memory of bootloader
; SE R(/W) 0..16383 device serial number in top of flash program memory, see AU command
; >ST R 0..255 datalogger status (busy, idle, full, error, etc.)
; SV R 1.55 returns firmware version
;
; V$ R 0..1023 values of all inputs separated by a tab (234 444 ...)
; VA R 0..1023 analog input channel 3: air temperature (NTC)
; VD R/W 0..255 status of digital portb
; VE R 0..1023 analog input channel 7: lateral G-sensor
; VH R 0..1023 analog input channel 5: throttle (0..5V)
; VI R/W 0..255 status of leds at portd functioning as shift light and rpm counter
; VL R 0..1023 analog input channel 0: lambda sensor
; VO R 0..1023 analog input channel 6: longitudinal G-sensor
; VR R 0..16383 RPM rate (ccp1 pulse input)
; VS R 0..255 Speed [km/hr] from ccp2 pulse input
; VT R 0..1023 analog input channel 2: K-type thermocouple
; VV R 0..1023 analog input channel 1: voltage in 0..5 V
; VW R 0..1023 analog input channel 4: water temperature (NTC)
;
; XA R/W 0..32767 external eeprom address
; XC R/W 0..7 select external eeprom chip
; XD R/W 0..255 data byte of the external eeprom at the position specified by XA and XC
; XP R/W ABC@%432_;!... block size read or write (64 bytes) external eeprom
;
;--------------------------------------------------------------------------------------------------------------------------------------
EXEC_COMMAND ; go look in buffer to find out which command was sent and has to be executed
; a command starts with two letters which may be followed by one or more data bytes
; remember CTS has already been cleared to hold data stream from computer
; CTS will be set again after command execution to re-enable data reception
bank0 ;
bcf portb,led_red ; turn off red status led
bsf portb,led_green ; turn on green status led
A? movlw a'A' ;
subwf rx_buffer00,w ;
skpnz ;
goto A_ ;
C? movlw a'C' ; does the command start with the letter 'C' ?
subwf rx_buffer00,w ; compare to first command character (first byte in buffer)
skpnz ; let's see
goto C_ ; yes it does, go to all commands starting with the letter 'C'
E? movlw a'E' ;
subwf rx_buffer00,w ;
skpnz ;
goto E_ ;
F? movlw a'F' ;
subwf rx_buffer00,w ;
skpnz ;
goto F_ ;
I? movlw a'I' ;
subwf rx_buffer00,w ;
skpnz ;
goto I_ ;
K? movlw a'K' ;
subwf rx_buffer00,w ;
skpnz ;
goto K_ ;
L? movlw a'L' ;
subwf rx_buffer00,w ;
skpnz ;
goto L_ ;
R? movlw a'R' ;
subwf rx_buffer00,w ;
skpnz ;
goto R_ ;
S? movlw a'S' ;
subwf rx_buffer00,w ;
skpnz ;
goto S_ ;
V? movlw a'V' ;
subwf rx_buffer00,w ;
skpnz ;
goto V_ ;
X? movlw a'X' ;
subwf rx_buffer00,w ;
skpnz ;
goto X_ ;
pagesel EXIT_NAK ; make right program memory page selection
goto EXIT_NAK ; no command mnemonic matched, exit
;--------------------------------------------------------------------------------------------------------------------------------------
A_ ; empty line to prevent mplab editor error
pagesel COMMANDS ; make right program memory page selection
movlw a'U' ;
subwf rx_buffer01,w ;
skpnz ;
goto AU ;
goto EXIT_NAK ; exit_nak is on same page as commands so pagesel is valid
C_ ; empty line to prevent mplab editor error
pagesel COMMANDS ;
movlw a'A' ;
subwf rx_buffer01,w ;
skpnz ;
goto CA ;
movlw a'D' ;
subwf rx_buffer01,w ;
skpnz ;
goto CD ;
movlw a'L' ;
subwf rx_buffer01,w ;
skpnz ;
goto CL ;
goto EXIT_NAK ;
E_ ;
pagesel COMMANDS ;
movlw a'A' ;
subwf rx_buffer01,w ;
skpnz ;
goto EA ;
movlw a'D' ;
subwf rx_buffer01,w ;
skpnz ;
goto ED ;
movlw a'R' ;
subwf rx_buffer01,w ;
skpnz ;
goto ER ;
goto EXIT_NAK ;
F_ ;
pagesel COMMANDS ;
movlw a'A' ;
subwf rx_buffer01,w ;
skpnz ;
goto FA ;
movlw a'B' ;
subwf rx_buffer01,w ;
skpnz ;
goto FB ;
movlw a'E' ;
subwf rx_buffer01,w ;
skpnz ;
goto FE ;
movlw a'H' ;
subwf rx_buffer01,w ;
skpnz ;
goto FH ;
movlw a'M' ;
subwf rx_buffer01,w ;
skpnz ;
goto FM ;
movlw a'L' ;
subwf rx_buffer01,w ;
skpnz ;
goto FL ;
movlw a'O' ;
subwf rx_buffer01,w ;
skpnz ;
goto FO ;
movlw a'R' ;
subwf rx_buffer01,w ;
skpnz ;
goto FR ;
movlw a'S' ;
subwf rx_buffer01,w ;
skpnz ;
goto FS ;
movlw a'T' ;
subwf rx_buffer01,w ;
skpnz ;
goto FT ;
movlw a'V' ;
subwf rx_buffer01,w ;
skpnz ;
goto FV ;
movlw a'W' ;
subwf rx_buffer01,w ;
skpnz ;
goto FW ;
goto EXIT_NAK ;
I_ ;
pagesel COMMANDS ;
movlw a'D' ;
subwf rx_buffer01,w ;
skpnz ;
goto ID ;
goto EXIT_NAK ;
K_ ;
pagesel COMMANDS ;
movlw a'C' ;
subwf rx_buffer01,w ;
skpnz ;
goto KC ;
movlw a'P' ;
subwf rx_buffer01,w ;
skpnz ;
goto KP ;
movlw a'R' ;
subwf rx_buffer01,w ;
skpnz ;
goto KR ;
goto EXIT_NAK ;
L_ ;
pagesel COMMANDS ;
movlw a'S' ;
subwf rx_buffer01,w ;
skpnz ;
goto LS ;
movlw a'V' ;
subwf rx_buffer01,w ;
skpnz ;
goto LV ;
goto EXIT_NAK ;
R_ ;
pagesel COMMANDS ;
movlw a'C' ;
subwf rx_buffer01,w ;
skpnz ;
goto RC ;
movlw a'D' ;
subwf rx_buffer01,w ;
skpnz ;
goto RD ;
movlw a'I' ;
subwf rx_buffer01,w ;
skpnz ;
goto RI ;
movlw a'M' ;
subwf rx_buffer01,w ;
skpnz ;
goto RM ;
movlw a'N' ;
subwf rx_buffer01,w ;
skpnz ;
goto RN ;
movlw a'S' ;
subwf rx_buffer01,w ;
skpnz ;
goto RS ;
movlw a'T' ;
subwf rx_buffer01,w ;
skpnz ;
goto RT ;
movlw a'Z' ;
subwf rx_buffer01,w ;
skpnz ;
goto RZ ;
goto EXIT_NAK ;
S_ ;
pagesel COMMANDS ;
movlw a'E' ;
subwf rx_buffer01,w ;
skpnz ;
goto SE ;
movlw a'V' ;
subwf rx_buffer01,w ;
skpnz ;
goto SV ;
goto EXIT_NAK ;
V_ ;
pagesel COMMANDS ;
movlw a'$' ;
subwf rx_buffer01,w ;
skpnz ;
goto V0 ;
movlw a'R' ;
subwf rx_buffer01,w ;
skpnz ;
goto VR ;
movlw a'S' ;
subwf rx_buffer01,w ;
skpnz ;
goto VS ;
movlw a'A' ;
subwf rx_buffer01,w ;
skpnz ;
goto VA ;
movlw a'D' ;
subwf rx_buffer01,w ;
skpnz ;
goto VD ;
movlw a'E' ;
subwf rx_buffer01,w ;
skpnz ;
goto VE ;
movlw a'H' ;
subwf rx_buffer01,w ;
skpnz ;
goto VH ;
movlw a'I' ;
subwf rx_buffer01,w ;
skpnz ;
goto VI ;
movlw a'L' ;
subwf rx_buffer01,w ;
skpnz ;
goto VL ;
movlw a'O' ;
subwf rx_buffer01,w ;
skpnz ;
goto VO ;
movlw a'T' ;
subwf rx_buffer01,w ;
skpnz ;
goto VT ;
movlw a'V' ;
subwf rx_buffer01,w ;
skpnz ;
goto VV ;
movlw a'W' ;
subwf rx_buffer01,w ;
skpnz ;
goto VW ;
goto EXIT_NAK ;
X_ ;
pagesel COMMANDS ;
movlw a'A' ;
subwf rx_buffer01,w ;
skpnz ;
goto XA ;
movlw a'C' ;
subwf rx_buffer01,w ;
skpnz ;
goto XC ;
movlw a'D' ;
subwf rx_buffer01,w ;
skpnz ;
goto XD ;
movlw a'P' ;
subwf rx_buffer01,w ;
skpnz ;
goto XP ;
goto EXIT_NAK ;
;--------------------------------------------------------------------------------------------------------------------------------------
org h'1EA4' ; start of bootloader version 1.1 from file boot31.asm is at h'1EA5' !!!
nop ; force assembler to notice the start of this page
; we switched off the assember error messages but we want to see if we cross boundaries
;--------------------------------------------------------------------------------------------------------------------------------------
end ; tell the assembler to stop
| file: /Techref/member/AT-planet-T9/datalogger.htm, 425KB, , updated: 2011/2/23 21:13, local time: 2024/11/25 06:14,
owner: AT-planet-T9,
|
| | ©2024 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
<A HREF="http://ecomorder.com/Techref/member/AT-planet-T9/datalogger.htm"> Datalogger</A> |
| Did you find what you needed?
|