please dont rip this site
		;
		;**********************************************************************
		; 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 ******************************************************


See also:


file: /Techref/piclist/andrewspicos/stdcmd.htm, 19KB, , updated: 2000/2/17 09:50, local time: 2017/12/11 02:25,
TOP NEW HELP FIND: 
54.83.122.227:LOG IN

 ©2017 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?
Please DO link to this page! Digg it! / MAKE! / 

<A HREF="http://www.piclist.com/techref/piclist/andrewspicos/stdcmd.htm"> piclist andrewspicos stdcmd</A>

After you find an appropriate page, you are invited to your to this massmind site! (posts will be visible only to you before review) Just type in the box and press the Post button. (HTML welcomed, but not the <A tag: Instead, use the link box to link to another page. A tutorial is available Members can login to post directly, become page editors, and be credited for their posts.


Link? Put it here: 
if you want a response, please enter your email address: 
Attn spammers: All posts are reviewed before being made visible to anyone other than the poster.
Did you find what you needed?

  PICList 2017 contributors:
o List host: MIT, Site host massmind.org, Top posters @20171211 RussellMc, Van Horn, David, Sean Breheny, James Cameron, alan.b.pearce, IVP, Neil, Bob Blick, David C Brown, John Gardner,
* Page Editors: James Newton, David Cary, and YOU!
* Roman Black of Black Robotics donates from sales of Linistep stepper controller kits.
* Ashley Roll of Digital Nemesis donates from sales of RCL-1 RS232 to TTL converters.
* Monthly Subscribers: Gregg Rew. on-going support is MOST appreciated!
* Contributors: Richard Seriani, Sr.
 

Welcome to www.piclist.com!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  .