;Dick Cappels' project pages sap@cappels.org - you shoudl be able to copy and paste this text into an assembler file. ;©2002 Richard Cappels All Rights Reserved
;Use of information presented on this page is for personal, nonprofit educational ;and noncommercial use only. This material (including object files) is copyrighted ;by Richard Cappels and may not be republished or used directly for commercial ;purposes without explicit permission For commercial license, click HERE. ;
;HOME
;******************************************************
;Send and receive FM data, pass through UART at 9600 baud
;******************************************************
.include "2313def.inc"
; memory index =r0 ; used for fetching strings from memory
.def bitsout = r02 ; counter for bits sent (couple also use a delay counter)
.def sendheader = r03 ;headerr to place on outgoing RF byte
.def receiveaddress = r04 ; Address mask for RF received data header
.def temp = r16 ; Scratch register.
.def tcounter = r17 ; 8 Bit loop timing counter.
.def delaycounter = r18 ; Delay to increase time measureble with 8 bit tcounter.
.def runincount = r19 ; Used to keep track of consecutive zeros detected in runin code.
.def wirelessdat = r19 ; data to be sent via wireless port
;REGISTER 19 USED TWICE ON PURPOSE
.def inbyte = r20 ; Decoded data byte could be same register as runincoung
.def header = r21
.def outbyte = r21 ;Byte value to be sent (input to send routine)
;REGISTER 21 USED TWICE ON PURPOSE
.equ minzeros = 9 ;Minimum number of consecutive zeros to qualify as run-in code
.equ defaultsendheader = $10 ;Default value of RF sendingheaderr.
.equ defaultreceiveaddress =$02 ;Default value for RF receiveing address in header
.equ RFxmitdat = 5 Port bit used to send transmit data to RF transmitter
.equ RFrcvdat = 6 Port bit used to receive data from RF receiver
;SETTING UP THE UART
.equ clock = 4000000 ;clock frequency
.equ baudrate = 9600 ;choose a baud rate
.equ baudkonstant = (clock/(16*baudrate))-1
; Used for memory index = ZL,ZH
;PORT D
; bit 0 this pin used for UART RX pin
; bit 1 this pinused for UART TX pin
; bit 5 Send data to RF transmitter
; bit 6 receive data from RF receiver
;EEPROM
;0 not used
;1 sendheader
;2 receiveaddress
.cseg
.ORG $0000
;START INITIALIZATION
ldi temp,low(ramend)
out spl,temp ;Set the 8 bit stack pointer to the top of ram.
ldi temp,baudkonstant;load baud rate into the UART
out ubrr,temp
cbi PORTD,RFrcvdat ;no pullup on receiver input
cbi DDRD,RFrcvdat ;make receier input pin an input
cbi PORTD,RFxmitdat ;initial state of transmitter output is low
sbi DDRD,RFxmitdat ;make transmitter output pin an output
; ldi temp,defaultsendheader ;Establish the default RF sendingheaderr
; mov sendheader,temp ;88888TEMPRORAILLY COMMENTED OUT!!!!!!!!!!!!
;Fetch default transmit address from EEPROM
ldi temp,$01
out eear,temp ;Set up the read address
sbi eecr,eere ;Trigger the read
in temp,eedr ;Get the data into temp
mov sendheader,temp
;Fetch default receive address from EEPROM
ldi temp,$02
out eear,temp ;Set up the read address
sbi eecr,eere ;Trigger the read
in temp,eedr ;Get the data into temp
mov receiveaddress,temp
; mov receiveaddress,temp ;Put it into receiveaddress register.
sbi ucr,rxen ;enable UART receive function
;FINISHED WITH THE INITIALIZATION
;SEND GREETING
rcall greeting
main: ;MAIN FOREGROUND LOOP FOR THIS MACHINE
rcall rsreceiveit ;Check for RS-232 data coming in and send via RF link if anything's ready
rcall rssendit ;Check for incoming RF data. If coming in, decode and send to RS-232 device.
rjmp main
rsreceiveit: ;CHECK FOR DATA FROM TERMINAL. IF PRESENT, RESEND IT. Trap and intrepret Escape sequences.
sbis usr,rxc ;wait for data
rjmp norsdata
in wirelessdat,udr ;read data
cpi wirelessdat,$1B ;See if this is an escape character.
brne NotEscapeCommand ;If it keep going as if nothing happened -skip to bottom
receivecommand: ;If that was an Escape, then wait for command.
sbis usr,rxc ;wait for data
rjmp receivecommand
in wirelessdat,udr ;read command
andi wirelessdat,$DF ;And with $DF to make ASCII upper-casce.
receiveparameter: ;Receive the parameter
sbis usr,rxc ;wait for data
rjmp receiveparameter
in temp,udr ;Read parameter (interpreded as in the range of 0..7).
subi temp,$30 ;Then make into address to insert into the header.
andi temp,$07
lsl temp
lsl temp
lsl temp
mov bitsout,temp ;Store results in bitsout for now.
;Now interpret the command
cpi wirelessdat,$54 ;"T" set transmit address
brne NotTransmit
mov temp,bitsout
mov sendheader,temp ;Store the address
wrat: sbic eecr,eewe ;Wait for EEPROM write to not be busy
rjmp wrat
ldi temp,$01
out eear,temp ;Set up the write address
mov temp,sendheader
out eedr,temp ;Set up the write data
sbi eecr,eemwe
sbi eecr,eewe ;Trigger the write
NotTransmit:
cpi wirelessdat,$52 ;"R" set receive address
brne NotReceive
mov receiveaddress,bitsout ;Put the number in the address receive register
wrar: sbic eecr,eewe ;Wait for EEPROM write to not be busy
rjmp wrar
ldi temp,$02
out eear,temp ;Set up the write address
mov temp,receiveaddress
out eedr,temp ;Set up the write data
sbi eecr,eemwe
sbi eecr,eewe ;Trigger the write
NotReceive:
ret ;End of processing escape.
NotEscapeCommand:
; com wirelessdat ;///////////////////TEST ONLY INVERTED DATA if not commented out///////////
rcall sendabyte
norsdata:
ret
rs_send: ;SEND CONTENTS OF TEMP VIA SERIAL PORT
sbi ucr,txen ;set sender bit
sbis usr,udre ;wait till register is cleared
rjmp rs_send
out udr,temp ;send the contents of temp.
cbi ucr,txen ;clear sender bit
ret ;go back
sendstring: ;call with location of string in Z
lpm ; Load byte from program memory into r0
tst r0 ; Check if we've reached the end of the message
breq finishsendstering ; If so, return
mov temp,r0
rcall rs_send
adiw ZL,1 ; Increment Z registers
rjmp sendstring
finishsendstering:
ret
greeting:
ldi ZH,high(2*gteetingmessage) ; Load high part of byte address into ZH
ldi ZL,low(2*gteetingmessage) ; Load low part of byte address into ZL
rcall sendstring ; sent it.
mov temp,sendheader ;display defualt transmit address
andi temp,$78 ;mask off all but the address
lsr temp ;shift to right to make address into a binary number
lsr temp
lsr temp
ori temp,$30 ;make into an ascii number
rcall rs_send
ldi ZH,high(2*greetingsecondpart) ; Load high part of byte address into ZH
ldi ZL,low(2*greetingsecondpart) ; Load low part of byte address into ZL
rcall sendstring ; sent it.
mov temp,receiveaddress ;display defualt receive address
andi temp,$78 ;mask off all but the address
lsr temp ;shift to right to make address into a binary number
lsr temp
lsr temp
ori temp,$30 ;make into an ascii number
rcall rs_send
;print some blank lines
ldi ZH,high(2*crlfs) ; Load high part of byte address into ZH
ldi ZL,low(2*crlfs) ; Load low part of byte address into ZL
rcall sendstring
ret
gteetingmessage:
.db $0A,$0D
.db "RF interface. 02JUN2002 Dick Cappels."
.db $0A,$0D
.db "To change receive address, type <ESC>, R, <Address> "
.db $0A,$0D
.db "To change transmit address, type <ESC>, T, <Address>"
.db $0A,$0D
.db "Where the valid range of address is 0..7"
.db $0A,$0D
.db "Default transmit address is set to = $0"
.db $00,00
greetingsecondpart:
.db $0A,$0D
.db "Default receive address is set to = $0"
.db $00,00
crlfs:
.db $0A,$0D
.db $0A,$0D
.db $0A,$0D
.db $00,00
;/////////////////////////////////////////////////////////////////////////////////////////////////////
rssendit: ;CHECK FOR DATA FROM RADIO RECEIVER AND IF PRESENT, SEND TO TERMINAL
rcall TryToGetbytemessage ; returns with header in header and data in inbyte
andi header,$78 ;mask off all but the address part of the header
cp header,receiveaddress ;check the header to see if header matches address
brne notforme ;if not for address $01 then don't send it on.
mov temp,inbyte ;if it is addressed tho this machine then send it on to terminal
waittosend:
sbi ucr,txen ;set sender bit
sbis usr,udre ;wait till register is cleared
rjmp waittosend
out udr,temp ;send the recived data
cbi ucr,txen ;clear sender bit
notforme:
ret
;///////////////RADIO RECEIVE BYTE ROUTINES///////////////////
;Try and decode a valid header and data byte. In the case or error, return with header = $00
ErrorQuitReceiving:
ldi header,$00
ret
TrytoGetbytemessage:
ldi header,$00
ldi temp,$00
mov runincount,temp
GetAnotherZero: ;Start of loop to gather minzeros zeros in runin code.
rcall Getbit
brts ErrorQuitReceiving ;It Getbit comes back with T set, its an error; start over.
brcs ErrorQuitReceiving ;If Getbit comes back with carry set, its a one, not a zero -start over
inc runincount
cpi runincount,minzeros
brmi GetAnotherZero
WaitForStartbit: ;Start of loop waiting for a one, which will be the start bit.
rcall Getbit
brts ErrorQuitReceiving ;It Getbit comes back with T set, its an error; start over.
brcc WaitForStartbit ;If its a zero, keep looking
;OK, Now we have the start bit, so the next 8 bits will be the header. Shift them in.
ldi temp,$08
mov runincount,temp
Getheader:
rcall Getbit
brts ErrorQuitReceiving ;It Getbit comes back with T set, its an error; Stop receiveing.
rol header ;Shift new bit into header byte
dec runincount
brne Getheader ;If all bits aren't in yet, go get another.
;At this point, one could tell whether this data is addressed to this machine, but I am going to leave
;address qualification to another part of the code. If time were very precious, one could stop
;execution of this part of the receive routine right here.
rcall Getbit ;Throw this one away. Its the start bit for the next byte
;It must be here so two bytes of zeros can't look like
;the runing code.
brts ErrorQuitReceiving ;It Getbit comes back with T set, its an error; start over.
;Now we have the runinbits, the start bit, and the header. Next is the data. Shift it in.
ldi temp,$08
mov runincount,temp
GetInbyte:
rcall Getbit
brts ErrorQuitReceiving ;It Getbit comes back with T set, its an error; Stop receiveing.
rol inbyte ;Shift new bit into input data byte
dec runincount
brne GetInbyte ;If all bits aren't in yet, go get another
ret ;RETURN WITH header IN header AND DATA IN INBYTE
Getbit: ;Subroutine to get a received bit.
;It returns the value of the received bit in the carry bit
;If this routine does not receive a valid data bit IT WILL NOT RETURN.
;If it is necessary to recover from this situation, the watchdog timer can be used.
;It measures the time between rising edges on the input pin (B3 originally).
;Successfult bit decoding will return with T flag clear. T flag =1 means error.
ldi tcounter,$00 ;Zero the counter.
;Count, waiting for pin to go low.
WaitForLow:
ldi delaycounter,$16 ;load with $16, 1 cycle takes 17.5 us
delayloop1:
dec delaycounter
brne delayloop1
inc tcounter
breq nobit
sbic PIND,RFrcvdat
rjmp WaitForLow
;Continue to count, waiting for pin to go high.
WaitForHigh:
ldi delaycounter,$16
delayloop2:
dec delaycounter
brne delayloop2
inc tcounter
breq nobit
sbis PIND,RFrcvdat
rjmp WaitForHigh
;Determine if we measured a "legal" bit and if so wheter it as a one of a zero.
;pcode:
;If tcount < $42 start over
;If tcount <$6E its a one
;If tcount is < $84 start over
;If tcount is >$DC start over
;Else, its a zero
cpi tcounter,$42
brmi nobit
cpi tcounter,$6E
brmi ItsAOne
cpi tcounter,$84
brmi nobit
cpi tcounter,$DC
brpl nobit
;If it gets here, its a valid zero.;
clt ;Clear T flag (no error), set the carry bit to show that its a zero and return.
clc
ret
ItsAOne:clt ;Clear T flag (error) set carry flag (data is a one), and return.
sec
ret
nobit: ;Error receiving a bit, set T flag and leave
set
ret
;/////////////////////////RADIO SEND BYTE ROUTINES/////////////////////////
Sendabyte:
;SEND RUNIN CODE (16 ZEROS)
ldi outbyte,$00 ;get ready to send 16 zeros
ldi temp,$0F ;$0F databits plus a zero "start bit"
mov bitsout,temp
clc ;no start bit (it goes as another zero)
rcall LateTransmitAByte ;jump into byte sending routine
;Send the header byte. The first and last bit in the headder is always a "1". Its the law.
mov outbyte,sendheader
rcall TransmitAByte
;(Ok, now the 16 bits of runin, the start bit, and the 8 bits of header have been sent.
;Time to send the data byte.
mov outbyte,wirelessdat
rcall TransmitAByte
ldi outbyte,$FF ;get ready to send 1 one, channel idle, to finish the last data bit.
ldi temp,$02 ;$01 databits plus a start bit
mov bitsout,temp
sec ;no start bit
rcall LateTransmitAByte ;jump into byte sending routine
ret ;finished sending the one byte message
TransmitAByte: ;send a byte out the wireless port
ldi temp,$09
mov bitsout,temp
sec ;start bit is a "one"
LateTransmitAByte:
SendACycle: ;a one or a zero, depending on the state of carry bit
sbi PORTD,RFxmitdat
ldi tcounter,$00
ldi delaycounter,$04
brcs notazero1
ldi delaycounter,$08
notazero1:
Delay:
dec tcounter
brne Delay
dec delaycounter
brne delay
cbi PORTD,RFxmitdat
ldi tcounter,$00
ldi delaycounter,$04
brcs notazero2
ldi delaycounter,$08
notazero2:
Delay2:
dec tcounter
brne Delay2
dec delaycounter
brne delay2
rol outbyte ;sent start bit and all 8 data bits yet?
dec bitsout
brne SendACycle ;if not send another bit
ret
;//////////END OF CODE FOR SEND ROUTINE///////////////
;http://projects.cappels.org/
;HOME