|
|
NAME Control_AT24Cxx; This collection of routines allows an AT89C2051 microcontroller to read
; and write the AT24Cxx family of serial CMOS EEPROMS. This version of the
; code is compatible only with the AT89C2051 due to the location of the
; data buffer and stack in RAM. The code may be modified to work with the
; AT89C1051 by relocating or resizing the buffer and stack to fit into the
; smaller amount of RAM available in the AT89C1051. Note that the minimum
; size of the buffer is determined by the page size of the AT24Cxx.
;
; All five AT24Cxx device operations are supported. Byte Write, Current
; Address Read and Random Read are implemented by the functions WRITE_BYTE,
; READ_CURRENT and READ_RANDOM, respectively. Page Write and Sequential Read
; are special cases of functions WRITE_BLOCK and READ_BLOCK, respectively.
; WRITE_BLOCK and READ_BLOCK process from one byte to the number of bytes
; in a page and transfer data between the AT24Cxx and the RAM buffer.
;
; The code supports multiple AT24Cxx devices per bus, each with a unique
; address determined by the wiring of the address pins (A0, A1, A2). The
; three-bit programmable address is passed to the WRITE_BYTE, READ_CURRENT,
; READ_RANDOM, WRITE_BLOCK and READ_BLOCK functions, where it is combined
; with the AT24Cxx fixed address (FADDR) and used to address a device on the
; bus. Refer to the AT24Cxx family data sheets for additional information on
; device addressing.
;
; Functions BYTE_FILL, VERIFY_BYTE_FILL, PAGE_FILL and VERIFY_PAGE_FILL are
; artifacts from the debug process and serve to illustrate the use of the
; device read and write functions with an AT24C64. To modify the code for a
; different member of the AT24Cxx family, simply redefine the values of SIZE
; (the number of bytes per device) and PSIZE (the number of bytes per page).
; To change the fill value, redefine FILL. To change the programmable portion
; of the device address, redefine PADDR to a value from zero to seven.
;
; The code meets all AT24Cxx family timing requirements when executed by an
; AT89Cx051 microcontroller with a 12 MHz clock. Code modifications may be
; required if a faster clock is substituted.
FADDR EQU 0a0h ; fixed address for AT24Cxx EEPROMs
PADDR EQU 0 ; programmable address (0..7)
SIZE EQU 2000h ; bytes per AT24C64
PSIZE EQU 32 ; bytes per page for AT24C64
FILL EQU 55h ; example fill value; Register definitions.
index EQU r0 ; buffer pointer
kount EQU r1 ; byte count register
zdata EQU r1 ; data register
addr_lo EQU r2 ; 2-byte address register
addr_hi EQU r3 ;; Microcontroller connections to AT24Cxx serial bus lines.
SCL BIT p1.2 ; serial clock
SDA BIT p1.3 ; serial data
DSEG AT 20HORG 40H
buffer: DS PSIZE ; storage for read/write dataORG 60H ; stack origin
stack: DS 20H ; stack depth
CSEGORG 0000H ; power on/reset vector
jmp on_resetORG 0003H ; external interrupt 0 vector
reti ; undefinedORG 000BH ; timer 0 overflow vector
reti ; undefinedORG 0013H ; external interrupt 1 vector
reti ; undefinedORG 001BH ; timer 1 overflow vector
reti ; undefinedORG 0023H ; serial I/O interrupt vector
reti ; undefinedORG 0080H ; begin code space
USING 0 ; register bank zero
on_reset:
mov sp, #(stack-1) ; initialize stack pointer; Initialize AT24Cxx serial bus lines.
setb SDA ; high
setb SCL ; high
call byte_fill
jc faultcall verify_byte_fill
jc faultcall page_fill
jc faultcall verify_page_fill
jc faultfault:
jmp $
byte_fill:; Fill every byte in an AT24Cxx with the same value.
; Writes one address at a time (page mode is not used).
; Returns CY set to indicate write timeout.
; Destroys A, B, DPTR, XDATA, ADDR_HI:ADDR_LO.mov zdata, #FILL ; set up fill data
mov dptr, #0 ; initialize address pointer
x51:
mov addr_lo, dpl ; set up address
mov addr_hi, dph ;mov b, #120 ; retry counter
x52:
mov a, #PADDR ; programmable address
call write_byte ; try to write
jnc x53 ; jump if write OKdjnz b, x52 ; try again
setb c ; set timeout error flag
jmp x54 ; exit
x53:
inc dptr ; advance address pointer
; mov a, dpl ; check low byte
; cjne a, #(LOW SIZE), x51 ; jump if not last
mov a, dph ; check high byte
cjne a, #(HIGH SIZE), x51 ; jump if not last
clr c ; clear error flag
x54:
ret
verify_byte_fill:; Verify that all bytes in an AT24Cxx match a fill value.
; Reads and verifies one byte at a time (page mode is not used).
; Performs a Random Read function to initialize the internal
; address counter and checks the contents of the first address.
; Then performs multiple Current Address Read functions to step
; through the remaining addressess.
; Returns CY set to indicate read timeout or compare fail.
; Destroys A, B, DPTR.mov dptr, #0 ; initialize address pointer/counter
mov addr_lo, dpl ; set up address
mov addr_hi, dph ;mov b, #120 ; retry counter
x81:
mov a, #PADDR ; programmable address
call read_random ; try to read
jnc x82 ; jump if read OKdjnz b, x81 ; try again
jmp x86 ; set error flag and exit
x82:
cjne a, #FILL, x86 ; jump if compare error
jmp x85 ; do remaining addresses
x83:
mov a, #PADDR
call read_current
jc x87 ; jump if read failscjne a, #FILL, x86 ; jump if compare error
x85:
inc dptr ; advance address pointer
mov a, dph ; check high byte
cjne a, #(HIGH SIZE), x83 ; jump if not last
clr c ; clear error flag
jmp x87 ; exit
x86:
setb c ; set error flag
x87:
ret
page_fill:; Fill every byte in an AT24Cxx with the same value.
; Writes one page at a time.
; Returns CY set to indicate write timeout.
; Destroys A, B, DPTR, KOUNT, INDEX, ADDR_HI:ADDR_LO.; First fill buffer.
mov b, #PSIZE ; bytes per page
mov index, #buffer ; point to buffer
x61:
mov @index, #FILL ; put fill value in buffer
inc index ; advance pointer
djnz b, x61 ; next byte; Copy buffer to device, one page at a time.
mov dptr, #0 ; initialize address pointer
x62:
mov addr_lo, dpl ; set up address
mov addr_hi, dph ;
mov kount, #PSIZE ; bytes per pagemov b, #120 ; retry counter
x63:
mov a, #PADDR ; programmable address
call write_block ; try to write
jnc x64 ; jump if write OKdjnz b, x63 ; try again
setb c ; set timeout error flag
jmp x66 ; exit
x64:
; Add page size to address pointer.mov a, dpl ; get low byte
add a, #PSIZE ; add page size
mov dpl, a ; save low byte
jnc x65 ; jump if high byte not affected
inc dph ; increment high byte
x65:
; cjne a, #(LOW SIZE), x62 ; jump if low byte not last
mov a, dph ; check high byte
cjne a, #(HIGH SIZE), x62 ; jump if not last
clr c ; clear error flag
x66:
ret
verify_page_fill:; Verify that all bytes in an AT24Cxx match a fill value.
; Reads and verifies one page at a time.
; Returns CY set to indicate read timeout or compare fail.
; Destroys A, B, DPTR, KOUNT, INDEX, ADDR_HI:ADDR_LO.; Copy device page to buffer.
mov dptr, #0 ; initialize address pointer
x71:
mov addr_lo, dpl ; set up address
mov addr_hi, dph ;
mov kount, #PSIZE ; bytes per pagemov b, #120 ; retry counter
x72:
mov a, #PADDR ; programmable address
call read_block ; try to read
jnc x74 ; jump if read OKdjnz b, x72 ; try again
x73:
setb c ; set error flag
jmp x77 ; exit
x74:
; Verify buffer contents.mov b, #PSIZE ; bytes per page
mov index, #buffer ; point to buffer
x75:
cjne @index, #FILL, x73 ; jump if compare fails
inc index ; advance pointer
djnz b, x75 ; next byte; Add page size to address pointer.
mov a, dpl ; get low byte
add a, #PSIZE ; add page size
mov dpl, a ; save low byte
jnc x76 ; jump if high byte not affected
inc dph ; increment high byte
x76:
; cjne a, #(LOW SIZE), x71 ; jump if low byte not last
mov a, dph ; check high byte
cjne a, #(HIGH SIZE), x71 ; jump if not last
clr c ; clear error flag
x77:
ret
write_block:; Write from one byte to one page of data to an AT24Cxx.
; Called with programmable address in A, address of first byte
; in register pair ADDR_HI:ADDR_LO, data in BUFFER, byte count
; in register KOUNT.
; Does not wait for write cycle to complete.
; Returns CY set to indicate that the bus is not available
; or that the addressed device failed to acknowledge.
; Destroys A, KOUNT, INDEX.call start
jc x38 ; abort if bus not availablerl a ; programmable address to bits 3:1
orl a, #FADDR ; add fixed address
clr acc.0 ; specify write operation
call shout ; send device address
jc x37 ; abort if no acknowledgemov a, addr_hi ; send high byte of address
call shout ;
jc x37 ; abort if no acknowledgemov a, addr_lo ; send low byte of address
call shout ;
jc x37 ; abort if no acknowledgemov index, #buffer ; point to buffer
x36:
mov a, @index ; get data
call shout ; send data
jc x37 ; abort if no acknowledgeinc index ; advance buffer pointer
djnz kount, x36 ; next byte
clr c ; clear error flag
x37:
call stop
x38:
ret
read_block:; Read from one byte to one page of data from an AT24Cxx.
; Performs a Random Read which is extended into a Sequential Read
; when more than one byte is read. Called with programmable address
; in A, address of first byte in register pair ADDR_HI:ADDR_LO,
; byte count in register KOUNT.
; Returns data in BUFFER. Returns CY set to indicate that the bus is
; not available or that the addressed device failed to acknowledge.
; Destroys A, KOUNT, INDEX.; Send dummy write command to address first byte.
call start
jc x35 ; abort if bus not availablerl a ; programmable address to bits 3:1
orl a, #FADDR ; add fixed address
mov index, a ; save copy of device address
clr acc.0 ; specify write operation
call shout ; send device address
jc x34 ; abort if no acknowledgemov a, addr_hi ; send high byte of address
call shout ;
jc x34 ; abort if no acknowledgemov a, addr_lo ; send low byte of address
call shout ;
jc x34 ; abort if no acknowledge; Send read command and receive data.
call start ; second start for read
jc x34 ; abort if bus not availablemov a, index ; get device address
setb acc.0 ; specify read operation
call shout ; send device address
jc x34 ; abort if no acknowledgemov index, #buffer ; point to buffer
x31:
call shin ; receive data byte
mov @index, a ; save datacjne kount, #1, x32 ; jump if not last byte
call NAK ; do not acknowledge last byte
jmp x33 ; done
x32:
call ACK ; acknowledge byte
inc index ; advance buffer pointer
djnz kount, x31 ; next byte
x33:
clr c ; clear error flag
x34:
call stop
x35:
ret
write_byte:; AT24Cxx Byte Write function.
; Called with programmable address in A, byte address in
; register pair ADDR_HI:ADDR_LO, data in register XDATA.
; Does not wait for write cycle to complete.
; Returns CY set to indicate that the bus is not available
; or that the addressed device failed to acknowledge.
; Destroys A.call start
jc x49 ; abort if bus not availablerl a ; programmable address to bits 3:1
orl a, #FADDR ; add fixed address
clr acc.0 ; specify write operation
call shout ; send device address
jc x48 ; abort if no acknowledgemov a, addr_hi ; send high byte of address
call shout ;
jc x48 ; abort if no acknowledgemov a, addr_lo ; send low byte of address
call shout ;
jc x48 ; abort if no acknowledgemov a, zdata ; get data
call shout ; send data
jc x48 ; abort if no acknowledgeclr c ; clear error flag
x48:
call stop
x49:
ret
read_current:; AT24Cxx Current Address Read function.
; Called with programmable address in A. Returns data in A.
; Returns CY set to indicate that the bus is not available
; or that the addressed device failed to acknowledge.call start
jc x45 ; abort if bus not availablerl a ; programmable address to bits 3:1
orl a, #FADDR ; add fixed address
setb acc.0 ; specify read operation
call shout ; send device address
jc x44 ; abort if no acknowledgecall shin ; receive data byte
call NAK ; do not acknowledge byte
clr c ; clear error flag
x44:
call stop
x45:
ret
read_random:; AT24Cxx Random Read function.
; Called with programmable address in A, byte address in
; register pair ADDR_HI:ADDR_LO. Returns data in A.
; Returns CY set to indicate that the bus is not available
; or that the addressed device failed to acknowledge.push b
mov b, a ; save copy of programmable address; Send dummy write command to set internal address.
call start
jc x47 ; abort if bus not availablerl a ; programmable address to bits 3:1
orl a, #FADDR ; add fixed address
clr acc.0 ; specify write operation
call shout ; send device address
jc x46 ; abort if no acknowledgemov a, addr_hi ; send high byte of address
call shout ;
jc x46 ; abort if no acknowledgemov a, addr_lo ; send low byte of address
call shout ;
jc x46 ; abort if no acknowledge; Call Current Address Read function.
mov a, b ; get programmable address
call read_current
jmp x47 ; exit
x46:
call stop
x47:
pop b
ret
start:; Send START, defined as high-to-low SDA with SCL high.
; Return with SCL, SDA low.
; Returns CY set if bus is not available.setb SDA
setb SCL; Verify bus available.
jnb SDA, x40 ; jump if not high
jnb SCL, x40 ; jump if not highnop ; enforce setup delay and cycle delay
clr SDA
nop ; enforce hold delay
nop ;
nop ;
nop ;
nop ;
clr SCLclr c ; clear error flag
jmp x41
x40:
setb c ; set error flag
x41:
ret
stop:; Send STOP, defined as low-to-high SDA with SCL high.
; SCL expected low on entry. Return with SCL, SDA high.clr SDA
nop ; enforce SCL low and data setup
nop
setb SCL
nop ; enforce setup delay
nop ;
nop ;
nop ;
nop ;
setb SDA
ret
shout:; Shift out a byte to the AT24Cxx, most significant bit first.
; SCL, SDA expected low on entry. Return with SCL low.
; Called with data to send in A.
; Returns CY set to indicate failure by slave to acknowledge.
; Destroys A.push b
mov b, #8 ; bit counter
x42:
rlc a ; move bit into CY
mov SDA, c ; output bit
nop ; enforce SCL low and data setup
setb SCL ; raise clock
nop ; enforce SCL high
nop ;
nop ;
nop ;
clr SCL ; drop clock
djnz b, x42 ; next bitsetb SDA ; release SDA for ACK
nop ; enforce SCL low and tAA
nop ;
setb SCL ; raise ACK clock
nop ; enforce SCL high
nop ;
nop ;
nop ;
mov c, SDA ; get ACK bit
clr SCL ; drop ACK clockpop b
ret
shin:; Shift in a byte from the AT24Cxx, most significant bit first.
; SCL expected low on entry. Return with SCL low.
; Returns received data byte in A.setb SDA ; make SDA an input
push b
mov b, #8 ; bit count
x43:
nop ; enforce SCL low and data setup
nop ;
nop ;
setb SCL ; raise clock
nop ; enforce SCL high
nop ;
mov c, SDA ; input bit
rlc a ; move bit into byte
clr SCL ; drop clock
djnz b, x43 ; next bitpop b
ret
ACK:; Clock out an acknowledge bit (low).
; SCL expected low on entry. Return with SCL, SDA low.clr SDA ; ACK bit
nop ; enforce SCL low and data setup
nop ;
setb SCL ; raise clock
nop ; enforce SCL high
nop ;
nop ;
nop ;
clr SCL ; drop clock
ret
NAK:; Clock out a negative acknowledge bit (high).
; SCL expected low on entry. Return with SCL low, SDA high.setb SDA ; NAK bit
nop ; enforce SCL low and data setup
nop ;
setb SCL ; raise clock
nop ; enforce SCL high
nop ;
nop ;
nop ;
clr SCL ; drop clock
ret
END
E-mail: 
info@telesys.ru
