;
		;**********************************************************************
		; stdcmd.asm	- Standard set of commands for execution by Cmd
		;**********************************************************************
		;
		; created   3/11/98 -jea
		; modified 10/17/98 -jea
		;
		; Functions in this file:
		;  Null command (CR with no command line text)
		;  PortD set and read in decimal and hex
		;  Banked register read and write
		;  Display a string message on the local terminal
		;  Display the PICos version
		;
		; These functions should be used as examples for adding commands to
		;  the PICos environment. 
		;
		; Functions receive input parameters converted from the cmd line 
		;  according to the format string. All parameters are stored in the 
		;  cmdPrmBuff in the order in which they are entered. Decimal and 
		;  hexadecimal parameters occupy one byte while string parameters are 
		;  terminated with a 0. 
		;
		; Output must be provided in the form of a 0 terminated ascii string.
		;  This string is returned in the cmdOutBuff output buffer. If the
		;  first character in this buffer is not 0 it is resubmitted as 
		;  command input. The most common use of this is for the involkation
		;  of the u1: function to provide output to the user and redraw the
		;  command line prompt. All ouput strings must have a LF character
		;  as the last char before the 0 termination to cause the prompt to
		;  be redisplayed. This buffer is preinitalized by Cmd to contain
		;  header info to involke u1: with a LF only on return from all
		;  functions. This causes a new prompt after functions that don't
		;  generate any output.
		; 
		; The PortD commands are very simple and illustrate the use of both
		;  the input parameter buffer and the output string generation 
		;  utilities. The source code for the output string generation 
		;  utilities is located in the file "oututil.asm".
		;
		; Each command must be terminated with a return instruction which 
		;  results in returning from the command processor function Cmd. This 
		;  is due to the fact that Cmd was the last called function. Cmd loads
		;  the cmd function's address directly into the PC thus causing no 
		;  push onto the stack.
		;
		;*********************************************************************
NullCmd	; CR with no cmd line text
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	data	"\r", CmdPC, "Null command (CR_only)\r\n"		; CmdMenu table entry
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		;
		return						; return null result string from Cmd
		;
		;*********************************************************************
		; I/O Port D interface functions
		;*********************************************************************
SetDDec	; load decimal parameter into port d
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"PORTDD=n\r", CmdPC, "Set portd to a decimal value\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		;
		; fetch decimal parameter from buffer and copy to port d
		movlw	cmdPrmBuff			; load parameter buffer addr
		movwf	FSR1				; into FSR1
		movlb	1					; select sfr bank for port d
		movpf	INDF1, PORTD		; output parameter on port d
		; fall through to DspDDec
		;*********************************************************************
DspDDec	; create output string reporting value in portd as a decimal number
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"PORTDD\r", CmdPC, "Display portd in decimal\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		; copy first part of output string into output buffer using FSR0
		CpyTbl2Out	PortdD
		; copy port d value into output buffer as a decimal number
		movlb	1					; select sfr bank for port d
		movfp	PORTD, WREG			; load port d value into W
		call	Dec2Buf				; convert decimal value into output buffer
		; copy last part of output string into same output buffer using FSR0
		CpyTbl2Out	DcmlD
		return						; return from Cmd
		; This is the end of the functions executable code
		;
		; These data statements store constant ascii output strings in program 
		;  memory. They're accessed using the CpyTbl2Out macro.
PortdD	; constant string for port d display
	data	"\nPortD = ",0
DcmlD	; constant string for decimal display
	data	" decimal\n\r",0
		;
		;*********************************************************************
SetDHex	; load hexidecimal parameter into port d
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"PORTDX=x\r", CmdPC, "Set portd to a hex value\r\n"
	data	"PORTD=x\r", CmdPC, "Set portd to a hex value\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		;
		; fetch hexidecimal parameter from buffer and copy to port d
		movlw	cmdPrmBuff			; load parameter buffer addr
		movwf	FSR1				; into FSR1
		movlb	1					; select sfr bank for port d
		movpf	INDF1, PORTD		; output parameter to port d
		; fall through to DspDHex
		;*********************************************************************
DspDHex	; create output string reporting value in port d as a hex number
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"PORTDX\r", CmdPC, "Display portd in hex\r\n"
	data	"PORTD\r", CmdPC, "Display portd in hex\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		; copy first part of output string into output buffer using FSR0
		CpyTbl2Out	PortdD
		; copy port d value into output buffer as a hex number
		movlb	1					; select sfr bank for port d
		movfp	PORTD, WREG			; load port d value into W
		call	Hex2Buf				; convert hex value into output buffer
		; copy last part of output string into same output buffer using FSR0
		CpyTbl2Out	HexD
		return						; return from Cmd
		; This is the end of the functions executable code
		;
		; These data statements store constant ascii output strings in program 
		;  memory. They're accessed using the CpyTbl2Out macro.
HexD	; constant string for hex display
	data	" hex\n\r",0

		;
		;*********************************************************************
RFRead	; read banked register file x:x
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"REGx:x\r", CmdPC, "Read banked register file x:x\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		; data memory allocation for banked register read
	cblock                          ; declare bank 0 variables
		saveBSR                     ; BSR context save variable
		readVal						; read register value storage
	endc
		; executable code for banked register read
		movlw	cmdPrmBuff			; load addr of parameter buffer
		movwf	FSR1				; into FSR1, pointing to bank parameter
		movlw	0x0F				; put mask in W
		andwf	INDF1, W			; mask bank parameter into W
		movlr	high(saveBSR)		; select gpr bank for BSR save
		movpf	BSR, saveBSR		; save current BSR in banked variable
		movwf	BSR					; load bank parameter into BSR
		incf	FSR1				; point to file address parameter
		movlw	0x18				; load address greater than sfr range
		cpfslt	INDF1				; if file addr is in sfr range then skip
		swapf	BSR					; otherwise move bank value to gpr bits
		movfp	INDF1, FSR0			; move address parameter into FSR0
		movfp	INDF0, WREG			; fetch data value into W
		movlr	high(readVal)		; select gpr bank for register storage
		movwf	readVal				; store read value in banked variable
		; create output string reporting value of data byte
		; copy first part of output string into output buffer using FSR0
		CpyTbl2Out	RFD
		; copy register bank into output buffer as a hexidecimal number
		decf	FSR1				; point back to bank paramter
		movlw	0x0F				; put mask in W
		andwf	INDF1, W			; mask bank parameter into W
		call	Hex2Buf				; convert hex value into output buffer
		; put a ':' after the bank value (Hex2Buf leaves FSR0 pointing at end)
		movlw	':'					; load : char
		movwf	INDF0				; put it into the output string
		movlr	high(cmdOutPtr)		; select cmdOutPtr bank
		incf	cmdOutPtr			; point to next output char location
		; copy register address into output buffer as a hexidecimal number
		incf	FSR1				; point to file address parameter
		movfp	INDF1, WREG			; read register file address into W
		call	Hex2Buf				; convert hex value into output buffer
		; copy " = " into same output buffer using FSR0
		CpyTbl2Out	EqD
		; copy register data into output buffer as a hexidecimal number
		movlr	high(readVal)		; select gpr bank for register storage
		movfp	readVal, WREG		; load read value into W
		call	Hex2Buf				; convert hex value into output buffer
		; put a LF and CR after the data
		movlw	'\n'				; load LF char
		movwf	INDF0				; put it into the output string
		incf	FSR0				; point to next output char location
		movlw	'\r'				; load ascii CR into last location in buff
		movwf	INDF0				;  CR terminates cmd line when resubmited
		movlr	high(saveBSR)		; select gpr bank for saved BSR
		movfp	saveBSR, BSR		; restore original BSR value
		return						; return from Cmd
		; This is the end of the functions executable code
		;
		; These data statements store constant ascii output strings in program 
		;  memory. They're accessed using the CpyTbl2Buf and CpyTblCont macros 
		;  with the addresses given by the labels.
RFD		; constant string for register file display
	data	"\nBanked Register ",0
		;
		;*********************************************************************
RFWrite	; write an x parameter into banked register file x:x
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"REGx:x=x\r", CmdPC, "Write x at banked register file x:x\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		;
		movlw	cmdPrmBuff			; load addr of start of parameter buffer
		movwf	FSR1				; into FSR1
		movlw	0x0F				; put mask in W
		andwf	INDF1, W			; mask bank parameter into W
		movlr	high(saveBSR)		; select gpr bank for BSR save
		movpf	BSR, saveBSR		; save current BSR in banked variable
		movwf	BSR					; load bank parameter into BSR
		incf	FSR1				; point to file address parameter
		movlw	0x18				; load address greater than sfr range
		cpfslt	INDF1				; if file addr is in sfr range then skip
		swapf	BSR					; otherwise move bank value to gpr bits
		movfp	INDF1, FSR0			; move address parameter into FSR0
		incf	FSR1				; point to register value parameter
		movfp	INDF1, INDF0		; write data value into register
		movlr	high(saveBSR)		; select gpr bank for saved BSR
		movfp	saveBSR, BSR		; restore original BSR value
		return						; return null result string from Cmd

		;
		;*********************************************************************
		; USART1 output commands
		;*********************************************************************
MsgDisp	; Display the message string on USART1
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"MSG:s\r", CmdPC, "Display message s on USART1\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		;
		movlw	cmdPrmBuff			; load parameter buffer addr
		movwf	FSR0				;  into FSR0
		bsf		ALUSTA, FS0			; setup FSR0 for auto increment
		bcf		ALUSTA, FS1			;
		movlw	cmdOutBuff			; load start of output buffer addr
		movwf	FSR1				;  into FSR1
		movlw	0x0D				; load CR char
		movwf	INDF1				;  into output buffer
		incf	FSR1				; point to next location
		movlw	0x0A				; load LF char
		movwf	INDF1				;  into output buffer
NxtOutM	incf	FSR1				; point to next location
		movfp	INDF0, INDF1		; move char from parameter to output
		tstfsz	INDF1				; skip if last parameter was 0
		goto	NxtOutM				; copy next char
		; 0 has terminated string parameter copy
		bsf		ALUSTA, FS1			; reset FSR0 to no change
		; send string to user terminal on USART1
		movlw	cmdOutBuff			; load output buffer addr
		movwf	txPtr				;  into txPtr
		call	StartTx				; start interrupt based Tx on UART1
		btfsc	u1Flags, TxRdy		; skip when Tx buffer empty
		goto	$-1					; until then wait
		; load LF and prompt into output buffer
		movlw	cmdOutBuff			; load start of output buffer addr
		movwf	FSR1				;  into FSR1
		movlw	'\n'				; load ascii LF char into W
		movwf	INDF1				; overwrite 0
		incf	FSR1				; point to next location
		movpf	FSR1, cmdOutPtr		; load current location into ptr
		CpyTbl2Out	PromptD			; concatinate prompt onto string
		; send string to user terminal on USART1
		movlw	cmdOutBuff			; load output buffer addr
		movwf	txPtr				;  into txPtr
		call	StartTx				; start interrupt based Tx on UART1
		btfsc	u1Flags, TxRdy		; skip when Tx buffer empty
		goto	$-1					; until then wait
		; init output buffer to cause u1: to display new prompt after cmd
		movlw	cmdOutBuff			; load start of output buffer
		movwf	FSR1				;  into FSR1
		movlw	'u'					; load ascii u
		movwf	INDF1				;  into buffer
		incf	FSR1				; point to next location
		movlw	'1'					; load ascii 1
		movwf	INDF1				;  into buffer
		incf	FSR1				; point to next location
		movlw	':'					; load ascii :
		movwf	INDF1				;  into buffer
		incf	FSR1				; point to next location
		movlw	'\n'				; load ascii LF
		movwf	INDF1				;  into buffer
		movpf	FSR1, cmdOutPtr		; save current location in output pointer
		incf	FSR1				; point to next location
		movlw	'\r'				; load ascii CR into last location in buff
		movwf	INDF1				;  CR terminates cmd line when resubmited
		return						; return from Cmd
		;
		;*********************************************************************
U1Disp	; command used by all commands to send user output to USART1
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"U1:s\r", CmdPC, "Transmit s on USART1\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		;

; support lcd command output display in here somewhere?
;		call	Out2LCD				; display function output on LCD

		movlw	cmdPrmBuff			; load parameter buffer addr
		movwf	FSR0				;  into FSR0
		bsf		ALUSTA, FS0			; setup FSR0 for auto increment
		bcf		ALUSTA, FS1			;
		movlw	cmdOutBuff-1		; load prestart of output buffer addr
		movwf	FSR1				;  into FSR1
NxtOutS	incf	FSR1				; point to next location
		movfp	INDF0, INDF1		; move char from parameter to output
		tstfsz	INDF1				; skip if last parameter was 0
		goto	NxtOutS				; copy next char
		; 0 has terminated string parameter copy
		bsf		ALUSTA, FS1			; reset FSR0 to no change
		decf	FSR1				; backup to char before 0 termination
		movlw	'\n'				; load ascii LF char into W
		cpfseq	INDF1				; skip if last char was a LF
		goto	TxS					; otherwise send existing string
		; last char was a LF, redisplay cmd prompt
		incf	FSR1				; inc to point at 0 termination
		movpf	FSR1, cmdOutPtr		; load current location into ptr
		CpyTbl2Out	PromptD			; concatinate prompt onto string
TxS		; send string to user terminal on USART1
		movlw	cmdOutBuff			; load output buffer addr
		movwf	txPtr				;  into txPtr
		call	StartTx				; start interrupt based Tx on UART1
		btfsc	u1Flags, TxRdy		; skip when Tx buffer empty
		goto	$-1					; until then wait
		clrf	cmdOutBuff			; clear first char in cmdOutBuff
		return						; return from Cmd
		; This is the end of the functions executable code
		;
		; These data statements store constant ascii output strings in program 
		;  memory. They're accessed using the CpyTbl2Buf and CpyTblCont macros 
		;  with the addresses given by the labels.
PromptD	; constant string for command line prompt
	data "\rPICos>",0
		;
		;*********************************************************************
DspVer	; display the PICos version
		;*********************************************************************
		; install this command in the CmdMenu lookup table
	CmdPC = $						; save current inline assembly PC value
	org CurCmdMenuAdr				; set assembly PC to addr for new entry
	; CmdMenu table entry
	data	"VER\r", CmdPC, "Display PICos version\r\n"
	CurCmdMenuAdr = $				; set current CmdMenu addr for next entry
	org CmdPC						; begin cmd code gen at inline address
		; copy first part of output string into output buffer using FSR0
		CpyTbl2Out	VerD
		; copy major version into output buffer
		movlw	high (Version)		; load major rev digit
		call	Dec2Buf				; convert decimal value into output buffer
		; put a . between the major and minor rev
		movlw	'.'					; load . char
		movwf	INDF0				; put it into the output string
		incf	cmdOutPtr			; point to next output char location
		; copy minor version into output buffer as a hex number
		movlw	low (Version)		; load minor rev digit
		call	Hex2Buf				; convert hex value into output buffer
		; put a LF and CR after the rev
		movlw	'\n'				; load LF char
		movwf	INDF0				; put it into the output string
		incf	FSR0				; point to next output char location
		movlw	'\r'				; load ascii CR into last location in buff
		movwf	INDF0				;  CR terminates cmd line when resubmited
		return						; return from Cmd
		; This is the end of the functions executable code
		;
		; These data statements store constant ascii output strings in program 
		;  memory. They're accessed using the CpyTbl2Out macro.
VerD	; constant string for version display
	data	"\nPICos Version ",0

; end of file stdcmd.asm ******************************************************

  .