initial commit

Makefile

@@ -0,0 +1,5 @@
+ASM=gpasm
+
+adbio.hex: adbio.asm adb.inc adb.asm
+	$(ASM) adbio.asm
+	

README.md

@@ -0,0 +1,5 @@
+# ADBIO PIC Firmware
+
+Target: PIC16F88
+
+Currently 100% untested. This is based on Microchip's AN591 code, which I found to be terribly structured, and riddled with errors. I probably should have just abandoned it and started from scratch. But I didn't.

adb.asm

@@ -0,0 +1,297 @@
+;*** PrScale ROUTINE CALLED AT END OF AttnSig AND Srq SIGNALS
+
+
+PreScale8
+		banksel OPTION_REG
+		movlw	b'00000010'				; BINARY - set to prescale RTCC
+		movwf	OPTION_REG				; Clear 4th bit from right to select RTCC
+		banksel TMR0
+		clrf	TMR0					; last 3 bits set prescale value as 1:4
+		retlw	00h						; this gives a good ratio to monitor the
+										; timing for Reset and Attention signals and
+										; the 2nd Application Task
+
+;*** NoPrScl ROUTINE CALLED AT BEGINNING OF SyncSig AND END OF Srq SIGNALS
+PreScale2
+		banksel OPTION_REG
+		movlw	b'00000000'				; BINARY - set to prescale RTCC
+		movwf	OPTION_REG				; Clear 4th bit from right to select RTCC
+		banksel TMR0
+		clrf	TMR0					; last 3 bits set prescale value as 1:4
+		retlw	00h						; this gives a good ratio to monitor the
+										; timing for Reset and Attention signals and
+										; the 2nd Application Task
+
+
+;***************************************************************************
+
+;*** GET INCOMING BIT & INTERPRET WHETHER IT'S A '1' OR A '0' *** (Get_Bit) ***
+;*** Get_Bit CALLED BY COMMAND AND LISTEN ROUTINES
+; Get the bit, find out whether it's less than or greater than 50 usecs, 
+; if < than 50 usecs, it's a '1' bit
+; if > than 50 usecs, it's a '0' bit
+; if it's a '1' bit, set LSB in the reg. pointed to by the FSR (Command Byte)
+; if it's a '0' bit, do nothing to the LSB
+; then look for the end of the Bit Cell (104 usecs max.)
+; if the maximum Bit time of (72 usecs) or maximum Bit Cell time is exceeded,
+; abort to the Attn Signal
+
+Get_Bit banksel TMR0
+		movf	TMR0,w					; Check the time, then check if the line went high:
+		subwf	TimeVar,w				; See if more than BIT_TST usecs have passed
+		btfss	STATUS,C				; if not, check whether the line went high
+		goto	AttnSig					; if so, abort to the Attn Signal
+		btfss	PORTA,ADBPin			; Check whether the line went high
+		goto	Get_Bit					; if line is still low, loop again
+		movlw	BIT_TST					; if line went high, see if it's a '1' or a '0'
+		movwf	TimeVar					; as the bit has not yet been determined yet,
+		bcf		INDF,0					; ensure the LSB in the indirect address is '0'
+		movf	TMR0,W					; Get the time
+		subwf	TimeVar,W				; if time < 50 usecs, it's a '1' bit
+		btfsc	STATUS,C				; if time > 50 usecs and < 72, it's a '0' bit
+		bsf		INDF,0					; if it's a 1, set LSB in the address FSR points to
+		movlw	BITCELL					; Check whether the Max. Bit Cell time of 104 usecs
+		movwf	TimeVar					; has been exceeded
+CellChk movf	TMR0,W					; Check the time, then check the line
+		subwf	TimeVar,W				; See if more than Max. Bit Cell usecs have passed
+		btfss	STATUS,C				; if not, look for the line to go low again
+		goto	AttnSig					; if so, abort to the Attn Signal or Reset
+		btfsc	PORTA,ADBPin			; Check the line for the start of another bit
+		goto	CellChk					; if the line is still high, loop CelChk1 again
+		clrf	TMR0					; if the line went low, clear the RTCC & return
+		retlw	00h						; 	for another bit or to interpret the Command
+
+
+
+;***************************************************************************
+
+
+
+
+;*** MASK OUT COMMAND NIBBLE AND REG.# BITS FROM THE COMMAND *** (MaskCmd) ***
+; NOTE: This routine should only be called once during any single ADB 
+; transaction, from either AddrChk or CmmdChk
+
+; Command Byte:
+; |	7	|		6	|	5	|		4	|	3	|		2	|	1	|		0	|
+; |	A3 |		A2 |	A1 |		A0 | Cmd Code	|	Register |
+
+DecodeCmd 
+		assume	bank0
+
+		movf	CmdByte, w
+		andlw	0xF0
+		movwf	ReqAddress
+		swapf	ReqAddress, f
+
+		movf	CmdByte, w
+		andlw	0x03
+		movwf	ReqReg
+		addwf	ReqReg, w				; multiply reg by 2 to get 16 bit register offset
+		addlw	Reg0a					; add base address of register memory area
+		movwf	RAMaddr					; store pointer
+
+
+		call	SetCmdFlags				; use a jump table to translate the 16 
+		movwf	ReqCommand				; possible combinations of commands into a
+
+
+		; turn ReqReg into bit field so we can use btfss elsewhere
+
+		btfsc	ReqReg, 1
+		goto	$+5
+		movlw	0x01					; 00
+		btfsc	ReqReg, 0
+		movlw	0x02					; 01
+		goto	storVal
+		movlw	0x04					; 10
+		btfsc	ReqReg, 0
+		movlw	0x08					; 11
+storVal movwf	ReqReg
+
+		return
+
+SetCmdFlags
+
+		movf	CmdByte, w
+		andlw	0x0F
+		addlw	SetCmdFlagsJump
+
+SetCmdFlagsJump
+
+		retlw	1<<cmdReset				; 0
+		retlw	1<<cmdFlush				; 1
+		retlw	1<<cmdReserved			; 2
+		retlw	1<<cmdReserved			; 3
+		retlw	1<<cmdReserved			; 4
+		retlw	1<<cmdReserved			; 5
+		retlw	1<<cmdReserved			; 6
+		retlw	1<<cmdReserved			; 7
+		retlw	1<<cmdListen			; 8
+		retlw	1<<cmdListen			; 9
+		retlw	1<<cmdListen			; A
+		retlw	1<<cmdListen			; B
+		retlw	1<<cmdTalk				; C
+		retlw	1<<cmdTalk				; D
+		retlw	1<<cmdTalk				; E
+		retlw	1<<cmdTalk				; F
+
+
+
+
+
+
+
+
+;***************************************************************************
+
+;*** ISSUE A SERVICE REQUEST IF NECESSARY *** (Srq; may call LineLow) ***
+;*** CALLED BY AddrChk
+; see if the Srq Flag is set, if not, return, otherwise:
+; change the prescaler to RTCC since this takes longer than 255 usecs,
+; load the SRQTIME of 300 usecs into the TimeVariable,
+; call LineLow to:
+; 	keep checking the time to see if 300 usecs have passed,
+; 	let the line go high again, 
+; 	and see if the line is high, and if not, abort, if it is,
+; change the prescaler back to WDT, and return 
+
+SendSrq 
+		call	PreScale8				; switch the prscaler to RTCC
+		banksel TRISA
+		bcf		TRISA, ADBPin			; tri-state PORTA to make the ADB an output
+		movlw	SRQ_MAX
+		call	LineLow
+		call	PreScale2				; change the prescaler back to WDT
+		return
+
+;***************************************************************************
+
+;*** Tlt - TIME FROM STOP BIT TO START BIT ***	(Tlt) ***
+;*** CALLED BY EITHER Talk OR Listen ROUTINES
+; Loop checking the time, then checking the line to see if it went low
+; if at any time the line goes low,
+; 	see if this is a Talk Command, 
+; 		if it is a Talk Commmand, go to the Collision routine
+; if the line goes low before the minimum Tlt time, abort to Attn Signal
+; if the line is high longer than TLT_Min usecs, 
+; 	see if this is a Talk Command, and if it is, wait for the mid-point,
+; 		and return to Send the Start Bit, Data Bytes, & the Stop Bit
+; 	if it's not a Talk Command, see if it's a Listen Command, and if so,
+; 		load Tlt_Max for TimeVariable, and look for the line to go 
+; 			low as the beginning of the Start Bit,
+; 	if more than Tlt_Max usecs pass, abort to Attn Signal
+; if the line goes low and this is a Listen Command,
+; 	clear the RTCC & return to get the rest of the Start Bit
+
+Tlt		movlw	TLT_MIN					; Look for Stop-to-Start-Time, Tlt
+		banksel TimeVar
+		movwf	TimeVar					; Check the time, then check the line
+TltChk1 movf	TMR0,W					; See if more than TLT_MIN usecs have passed
+		xorwf	Random,F				; (ensure the Talk R3 address is Random with XOR)
+		subwf	TimeVar,W				; by checking whether Carry bit is set
+		btfss	STATUS,C				; 	after subtraction
+		goto	ChkFlag					; if TLT_MIN usecs passed, see what Command this is
+		btfsc	PORTA, ADBPin			; if not, check whether the line went low
+		goto	TltChk1					; if the line is still high, keep looping
+		btfsc	Flags1,F1Talk			; if line went low, see if this is a Talk Command
+		goto	Collisn					; 	if it is, there was a Collision, abort
+		movf	TMR0,W					; otherwise, check the time
+		subwf	TimeVar,W				; 	 see if TLT_MIN usecs passed,
+		btfss	STATUS,C				; 	 if not, abort to Attn Signal, too little
+		goto	AttnSig					; 		time passed when the line went low
+		clrf	TMR0					; if it's not a Talk Command, clear the RTCC and
+		retlw	00h						; 	return for the rest of the Start Bit 
+		
+ChkFlag banksel Flags1
+		btfsc	Flags1,F1Talk			; Check whether to Talk or Listen
+		goto	TltTalk					; if Talk, wait for mid-point of Tlt time
+		btfss	Flags1,F1Lstn			; if Listen, continue to look for Start Bit
+		retlw	00h						; if neither flag is set, abort, something's wrong
+		movlw	TLT_MAX					; Load TimeVariable to check for upper limit 
+		movwf	TimeVar					; 	of Tlt time
+TltChk2 movf	TMR0,W					; See if TLT_MAX usecs have been exceeded
+		subwf	TimeVar,W				; by checking whether Carry bit is set
+		btfss	STATUS,C				; 	after subtraction
+		goto	AttnSig					; if so, abort to Attn Signal
+		btfsc	PORTA,ADBPin			; if not, check whether the line went low
+		goto	TltChk2					; if line is still high, check the time again
+		btfsc	Flags1,F1Talk			; if line went low, see if this is a Talk Command
+		goto	Collisn					; 	if so, there was a Collision
+		clrf	TMR0					; 	if it's not a Talk Command, return to get
+		retlw	00h						; 	the rest of the Start Bit from Host
+
+TltTalk movlw	TLT_MID					; Load TimeVariable so Talk will send Start Bit at 
+		banksel TimeVar
+		movwf	TimeVar					; about the mid-point of the Tlt 
+TltChk3 movf	TMR0,W					; See if TLT_MID usecs have been exceeded
+		subwf	TimeVar,W				; by checking whether Carry bit is set
+		btfss	STATUS,C				; 	after subtraction
+		retlw	00h						; if time was exceeded, return to send Start Bit
+		btfsc	PORTA, ADBPin			; if not, check whether the line went low
+		goto	TltChk3					; if line is still high, check the time again
+		goto	Collisn					; if the line went low, abort to Collision
+
+
+Collisn	banksel	bank1
+		btfsc	ReqReg, 3				; if there was a collision during a Talk Reg. 3
+		bsf	 	Flags1, F1Cllsn			; Command, then set the Collision Flag,
+		goto	AttnSig					; otherwise, just abort to Attn Signal
+
+;***************************************************************************
+
+
+SendLow	
+		movlw	LOW0BIT					; Send a '0' bit									
+		call	LineLow					; hold the line low for 2/3rd of a Bit Cell
+		movlw	HI_0BIT
+		call	LineHi					; let the line high for the rest of the Bit Cell
+		return
+
+SendHigh
+		movlw	LOW1BIT					; Send a '1' bit									
+		call	LineLow					; hold the line low for 1/3rd of a Bit Cell
+		movlw	HI_1BIT														
+		call	LineHi					; let the line high for the rest of the Bit Cell
+		return
+
+
+
+
+
+;*** MAKE LINE GO LOW TIME IN TimeVar AS A '1' OR '0' BIT *** (LineLow) ***
+;*** CALLED BY Talk OR Srq
+
+LineLow movwf	TimeVar
+Low_Tmp movf	TMR0,W					; Check the clock,
+		subwf	TimeVar,W				; loop until TimeVar usecs have passed 
+		skpnc
+		goto	Low_Tmp
+		banksel bank1					; Tri-state PORTA to make ADB line an input again
+		bsf		TRISA, ADBPin			; and let the line go high
+		banksel bank0
+		clrf	TMR0					; and clear RTCC
+		goto $+1						; Allow the ADB Port line to stabilize
+		goto $+1						; Allow the ADB Port line to stabilize
+		btfss	PORTA, ADBPin			; check if the line is still low, if so, a
+		goto	Collisn					; Collision occurred
+		retlw	00h						; if not, return to load high time for rest of bit
+
+;*** MAKE LINE GO HIGH FOR REST OF BIT CELL TIME IN TimeVar *** (LineHi) ***
+;*** CALLED BY Talk
+
+LineHi	movwf	TimeVar					; Let the line go high for a pre-designated time
+Hi_Tmp	movf	TMR0,W					; Check the clock, 
+		subwf	TimeVar,W				; loop until TimeVar usecs have passed
+		skpnc
+		goto	Hi_Tmp
+		btfss	PORTA, ADBPin			; check if the line is still high,
+		goto	Collisn					; if not, a Collision occurred, Abort
+		btfsc	Flags1,F1Stop			; if this is the end of the Data Stop Bit, don't
+		retlw	00h						; let the line go low again, just return
+		banksel bank1					; if still high, start sending a bit to the Host
+		bcf		TRISA, ADBPin			; tri-state PORTA to make the ADB an output and
+		banksel bank0
+		clrf	TMR0
+		retlw	00h	
+

adb.inc

@@ -0,0 +1,178 @@
+bank0		equ		00h
+bank1		equ		80h
+bank2		equ		100h
+bank3		equ		180h
+
+; *** BIT ASSIGNMENTS FOR I/O LINES & TRI-STATING
+
+ADBIOPrtATRIS	equ		TRISB
+ADBIOPrtBTRIS	equ		TRISA
+
+ADBPin		equ		RA4	 	; Port A Pin used for ADB
+ADBAltPin	equ		RB0	 	; Port B Pin used for ADB (currently unused)
+ADBIOIDH	equ		RB1		; Unit ID high bit (SW1)
+ADBIOIDL	equ		RB2		; Unit ID high bit (SW2)
+
+ADBIOPortB	equ		PORTA
+ADBIOPinB1	equ		RA0
+ADBIOPinB2	equ		RA1
+ADBIOPinB3	equ		RA2
+ADBIOPinB4	equ		RA3
+
+ADBIOPortA	equ		PORTB
+ADBIOPinA1	equ		RB7
+ADBIOPinA2	equ		RB6
+ADBIOPinA3	equ		RB5
+ADBIOPinA4	equ		RB4
+
+;*** MISC. CONSTANTS
+
+DefaultAddr	equ		07h	 			; default device address to start with (Assigned by Apple)
+DefaultID	equ		7Ah				; default ID (Assigned by Apple)
+									;   Data storage registers
+
+
+;*** DATA HANDLER ID MASKS: MASK DATA REGISTER 3b FOR:
+
+SELFTST equ	0FFh	 ; Self-Test mode
+LISTEN1 equ	  0h	 ; unconditional address change
+LISTEN2 equ	0FEh	 ; address change if no collision detected
+DEV_ACT equ	0FDh	 ; address change if device activator is depressed
+
+
+;*** BITS USED IN THE UPPER NIBBLE OF REGISTER 3a FOR SPECIAL ADB STATUS BITS
+
+Resrvd3 equ	 04h	  ; reserved (Always 0)
+Srq_Bit equ	 05h	  ; determines if Host will accept Service Requests
+ExpEvnt equ	 06h	  ; indicates an Exceptional Event should take place
+Always0 equ	 07h	  ; always set to 0
+
+
+;*** ADB FLAG BITS IN THE "FLAGS1" REGISTER (F1 indicates 1st Flags register)
+
+F1Attn  equ	 00h	 ; set to know if 2nd Task taking place during Attn
+F1Talk  equ  02h     ; indicates to Tlt routine this is a Talk Command
+F1Stop  equ	 03h	 ; set to indicate the Data Stop Bit is being sent
+F1Lstn  equ	 04h	 ; indicates to Tlt routine this is a Listen Command
+
+F1Rcvd1 equ	 06h	 ; 1st byte of Data Register has been received
+F1Cllsn equ	 07h	 ; set to indicate that a collision occurred
+
+
+;*** FLAG BITS IN THE "FLAGS2" REGISTER (F2 indicates 2nd Flags register)
+
+F2Srq		equ	 	00h				; indicate that Srq should be issued
+F2STest		equ		03h				; set to indicate a device Self Test is to be performed
+F2SFail		equ		04h				; set to indicate that the Device Self-Test Failed
+F2DRcvd		equ		05h				; set when data is received for 2nd Application Task
+
+
+; Timing Definitions for 8 Mhz clock
+; ------------------------------------------------------------------------------
+
+PrSclr1		equ		d'4'			; TMR0 period (microseconds) when prescaler is set to 8
+PrSclr2 	equ		d'1'			; TMR0 period (microseconds) when prescaler is set to 2
+
+ATT_MIN 	equ		d'776'/PrSclr1	; Attn lower limit: 800 - 3% tolerance = 776 usecs
+ATT_MAX 	equ		d'824'/PrSclr1	; Attn upper limit: 800 + 3% tolerance = 824 usecs
+TSK2MIN 	equ		d'500'/PrSclr1	; time given to 2nd Task during Attn Signal
+TSK2MAX 	equ		d'900'/PrSclr1	; time given to 2nd Task after Data Sent/Received
+ADBSYNC 	equ		d'72'/PrSclr2	; Sync with extra tolerance after Attn is detected
+BIT_TST 	equ		d'50'/PrSclr2	; if time is < 50 = 1 bit, & > 50 = 0 bit
+MAX_BIT 	equ		d'72'/PrSclr2	; Maximum time line can be low for a bit   
+BITCELL 	equ		d'104'/PrSclr2	; Maximum time for a bit cell = 104 usecs
+TLT_MIN 	equ		d'140'/PrSclr2	; Stop to Start minimum time = 140 usecs
+TLT_MAX 	equ		d'250'/PrSclr2	; Stop to Start maximum time = 260 usecs
+TLT_MID 	equ		d'180'/PrSclr2	; Stop to Start median time  = 208 usecs
+SRQ_MAX 	equ		d'296'/PrSclr1	; amount of time to hold for a Service ReQuest 
+
+; NOTE: for RTCC timing of sending bits, some extra time is allowed for 
+; instruction cycles between the end of the bit and the start of the next bit
+
+LOW1BIT 	equ		d'22'/PrSclr2	; low time for a 1 bit
+HI_1BIT 	equ		d'50'/PrSclr2	; hi time  for a 1 bit
+LOW0BIT 	equ		d'56'/PrSclr2	; low time for a 0 bit
+HI_0BIT 	equ		d'20'/PrSclr2	; hi time  for a 0 bit
+
+ 
+; bits of ReqCommand
+cmdReset	equ		0
+cmdFlush	equ		1
+cmdListen	equ		2
+cmdTalk		equ		3
+cmdReserved	equ		4
+
+reqReg0		equ		0
+reqReg1		equ		1
+reqReg2		equ		2
+reqReg3		equ		3
+
+cblock 20h			; bank0
+	
+	DeviceAddr
+	
+	Reg0a
+	Reg0b
+	Reg1a
+	Reg1b
+	Reg2a
+	Reg2b
+	Reg3a
+	Reg3b
+	
+	ShiftReg
+	
+	TmpReg1			; temporary registers where Data is sent from & 
+	TmpReg2			;  received; NOTE: THESE 2 MUST BE IN THIS ORDER
+	
+	PortTalkBytes:5
+	
+	RegNum 			; holds current ADB Data Reg.# - NOT a RAM address
+	RAMaddr			; holds RAM address of ADB Data Reg.#
+	Flags1 			; two Flags registers used by ADB & 2nd
+	Flags2 			;   Application Task
+	CmdByte			; holds the Command Byte
+	BitCounter			; counts down when sending or receiving bits
+	Random 			; stores Random Address sent in Talk routine
+	TimeVar			; used with RTCC for all ADB timing
+	Tsk2Var			; used with RTCC for timing during 2nd Task
+	
+	ByteCounter
+	
+	CommandNibble
+	CommandCode
+	
+	
+	ReqAddress
+	ReqCommand
+	ReqReg
+	
+	
+	TmpCtr1			; being used for debounce in example code
+	d1				; used in ADC delay loop
+	ADCPort			; used in ADC code
+	
+	
+	PortACfg		; 7:6 = 00, 5:4 = AD Config (always 11 for port A), 3:0 = Port Directions (1 = in)
+	PortBCfg 		; 7:6 = 00, 5:4 = AD Config (always 11 for port A), 3:0 = Port Directions (1 = in)
+	PortAShadow
+	PortBShadow
+	UnitID			; 7:6 = Unit ID
+	
+	A1Timer
+	A2Timer
+	A3Timer
+	A4Timer
+	
+endc
+
+
+ADBIOPortAShadow	equ	PortBShadow
+ADBIOPortBShadow	equ	PortAShadow
+
+
+cblock 70h			; globals
+	SaveStatus
+	SaveW
+endc
+