Adding data to an "array" in ASM

[The Master]

Hi, Im trying to write some of my PBP code in ASM. The bit im stuck on is setting values in an array. I know arrays dont really exist in ASM but i know its still possible to do what i want. After reading Mike's example in another thread i can see that i can access the elements of an array by using +1, +2 etc. Thats fine when its being added to a constant value. In Mike's example "Led" appears to be the address of the first element in the array.

The array im working on at the moment uses a variable to decide which element to put data in. Heres the PBP version of the code

bOutData[bOutDataPos]=cControlCharOut	'Control character (a constant)
bOutDataPos=bOutDataPos+1
bOutData[bOutDataPos]=0			'Data length (always zero here)
bOutDataPos=bOutDataPos+1
bOutData[bOutDataPos]=aAddress		'Chip address (from variable aAddress)
bOutDataPos=bOutDataPos+1
bOutData[bOutDataPos]=cAction		'Action (another constant)
bOutDataPos=bOutDataPos+1

bOutData is an output buffer array. bOutDataPos gets incremented every time a byte is added to the array. The send routine elsewhere in the code then sends a byte, shifts all bytes up 1 place in the array then decrements bOutDataPos.

So, can anyone point me in the right direction here? I just need to know how to access the array elements based on the value in bOutDataPos

[Jerson]

This does the same thing in assembly

asm
    movlw   _bOutDataPos    ; read the index to W
    addwf   _bOutData,w     ; add base of the array and keep in W
    movwf   FSR             ; move W to INDirect File register
    movlw   _cControlCharOut
    movwf   INDF
    incf    FSR             ; move to the next location of array
    clrw
    movwf   INDF
    incf    FSR             ; move to the next location of array
    movlw   _aAddress
    movwf   INDF
    incf    FSR             ; move to the next location of array
    movlw   _cAction
    movwf   INDF
    incf    FSR             ; move to the next location of array
endasm

[The Master]

Thanks. That looks like exactly what i want. I wasnt sure if it was even possible with PICs.

Ive looked FSR and INDF up in the datasheet and i found something else interesting too.

POSTINC: accesses the FSR value, then automatically increments it by 1 afterwards

[Bruce]

The first part of this probably isn't working like you might expect.

  movlw   _bOutDataPos    ; gets the "address" of bOutDataPos into W
  addwf   _bOutData,w     ; adds the address + the "value" in bOutData
  movwf   FSR             ; loads FSR with the wrong address

You want to add the base address of the array, which will never change, to the
offset value in bOutDataPos to get the address for each array element;

  movf   _bOutDataPos,W   ; get the value of your index pointer in bOutDataPos
  addlw  _bOutData        ; add the index to the base address of your array
  movwf  FSR              ; load FSR with base address + offset

This will probably make it easier to follow;

Array       VAR BYTE[8]
Index       VAR BYTE
Address     VAR BYTE

Action      CON 10
ControlChar CON 20

CLEAR

Address = 15  ' address
Index = 0     ' starting Array Index position

Main:
 Array[Index]=ControlChar
 Index=Index+1
 Array[Index]=0
 Index=Index+1
 Array[Index]=Address
 Index=Index+1
 Array[Index]=Action
 Index=Index+1
 GOTO Main

The code after Main would be something like this, which maintains your Index pointer.

asm
  movf   _Index, W     ;get "offset" value from Index pointer
  addlw  _Array        ;add it to Array[0] base address (result in W)           
  movwf  FSR           ;load pointer with base + offset  
  movlw  _ControlChar  ;load W with constant value in ControlChar
  movwf  INDF          ;move it to Array[Index]
  incf   _Index, F     ;inc Index pointer  
  movf   _Index, W     ;load new Index pointer value  
  addlw  _Array        ;add it to Array[0] base address            
  movwf  FSR           ;load pointer with base + offset  
  clrf   INDF          ;Clear Array[Index]  
  incf   _Index, F     ;inc Index pointer  
  movf   _Index, W     ;load new Index pointer value
  addlw  _Array        ;add it to Array[0] base address           
  movwf  FSR           ;load pointer with base + offset  
  movf   _Address, W   ;get Address byte value  
  movwf  INDF          ;move it to Array[Index]  
  incf   _Index, F     ;inc Index pointer  
  movf   _Index, W     ;load new Index pointer value  
  addlw  _Array        ;add it to Array[0] base address          
  movwf  FSR           ;load pointer with base + offset  
  movlw  _Action       ;load W with Constant value in Action
  movwf  INDF          ;move it to Array[Index]  
  incf   _Index, F     ;inc Index pointer
endasm

It could be made a bit smaller, and you could use incf FSR to increment the
pointer each time, but you could lose track of which array element you last
wrote to pretty quick.

[The Master]

Ahh, I didnt notice that it was the wrong way round. It is right in my code though because i wrote it out myself instead of copy/paste (i remember better that way).

Heres how my code looks now. I think its all right

	; Get the start address for the array
	MOVLW	_bOutData				; Set WREG to the start of the bOutData array
	ADDWF	_bOutDataPos,0			; Add bOutDataPos to the address and store back in WREG
	MOVWF	FSR0					; Copy WREG to the indirect file register
	
	; Control character
	MOVLW	_cControlCharOut		; Copy the output control character to WREG
	MOVWF	POSTINC0				; Copy WREG to bOutData[bOutDataPos] (specified by indirect file register) and increment FSR0
	INCF	_bOutDataPos			; Increment the array position
	
	; Data length
	MOVLW	0						; Set WREG to 0
	MOVWF	POSTINC0				; Copy WREG to bOutData[bOutDataPos]
	INCF	_bOutDataPos			; Increment the array position
	
	; Chip address
	MOVFF	_aAddress,POSTINC0		; Copy aAddress to bOutData[bOutDataPos]
	INCF	_bOutDataPos			; Increment the array position
	
	; Action
	MOVLW	_cActionPing			; Copy the ping action character to WREG
	MOVWF	POSTINC0				; Copy WREG to bOutData[bOutDataPos]
	INCF	_bOutDataPos			; Increment the array position

[Bruce]

Looks like you have it under control..;o}

I don't recommend using this particular syntax though ADDWF _bOutDataPos,0. I much
prefer being explicit with ADDWF _bOutDataPos,W. I can never remember if 0 or 1 is
specifying W or F, so it's a lot easier for me, at a later time, to review code with explicit
arguments.

[The Master]

Thats a very good point. Originally i saw it written how you said but the datasheet said it had to be 1 or 0. If typing W works too then i will do it that way. Thanks

[rsocor01]

Hi all,

Let me ask you a very stupid question here, but like they say if you don't ask you don't learn. This piece of code is very simple to do using PBP, so what is the purpose of complicating your life using ASM for this program? Using ASM saves programming space, but other than that why would you use it for this simple program?

Thank you for your answers,

Robert

[The Master]

Theres 2 reasons.

1) For a while now ive been wanting to learn ASM. By learning ASM a lot of things in other languages like PBP and even C are starting to make sense. I think its a very usefull thing to learn. It helps to understand how things are actually working inside the chip

2) Probably the most important one. This section of code is only part of a much bigger program. Its actually the same one from my other thread which is titled "PBP Using too many instructions". ASM uses a lot less instructions so i can finally add in the extra features that i wanted to do in PBP but couldnt because the code was running too slow.

[The Master]

Im having a bit of trouble getting this code working.

Heres some test code i wrote

	MOVLW	38
	MOVWF	FSR0
	
	MOVLW	57
	MOVWF	38
	MOVFF	INDF0,TXREG

This code should set W to 38 then move that value to FSR0.

It then sets W to 57 (my test value) and moves W to memory location 38. Then it sends INDF0 over serial to the PC. I would expect INDF0 to reference memory location 38 and send 57 but it doesnt. I keep getting random values (a different one each time i reset the PIC asif its an uninitialized memory location). Its not a serial problem. MOVWF TXREG sends the correct value.

I know im writing data to memory location 38 and if i read FSR0 back it also says 38. Did i miss something obvious? It seems like both are accessing memory location 38 but in 2 different blocks of memory (im not sure if thats possible)

[Darrel Taylor]

FSR0 is a constant that equates to 0.
It's for use with the LFSR opcode, LFSR FSR0, 38

The address for the FSR0 is 2 bytes, FSR0L and FSR0H.
So with your example, it could be one of these ...

	LFSR  FSR0, 38
	
	MOVLW	57
	MOVWF	38
	MOVFF	INDF0,TXREG

... OR ...

	MOVLW	38
	MOVWF	FSR0L
	CLRF	FSR0H
	
	MOVLW	57
	MOVWF	38
	MOVFF	INDF0,TXREG

hth,

[The Master]

Thanks. Thats working perfectly now