concatenating 4 bytes into one pseudo 32 bit counter?
So having read up about DDS to get sufficient frequency accuracy, it seems most people typically use a 24 bit or 32 bit accumuator.
Every interrupt a fixed number/value is added to the number held in the accumulator - the accumulator is basically a 32 bit counter.
Can this be kludged in picbasic - concatenate 4 bytes into one 'pretend' 32 bit counter - then add a fixed value to it everytime an interrupt happens?
Here's what one guy does in his assembly interrupt routine for a 16f628 PIC (original source - http://www.g4jnt.com/PIC_DDS.zip )...
Code:
ints ;Using divide by prescalar, Interupt service runs at at Fosc / 200
; when set to count 25 before overflowing, ie every 50 clocks = sampling rate
bcf INTCON , T0IF ;reset the interrupt flag
bsf TESTSTRB ;Spare instruction needed to make up 8 clocks total, up to the point of reloading TMR0
;So use it to pulse a test point
movlw d'235' ; Load in value to count up to 256 FROM (= NNN)
movwf TMR0 ;Timer restarts counting 2 cycles after here.
;Up to this point takes 8 clocks from Interrupt trigger
;So NNN = 256 - [Wanted count] + 8 / Prescale
; ie = 256 - 25 + 8 / 2 = 235
;Below here is not time-critical, but must be less than than about 42 clocks total
; so the whole interrupt takes < 50 clocks and doesn't overrun.
movf D3, W ;First output the D/A value from the LAST pass though so there is
call SineTable ; no jittering due to variable timing of the addition routine
movwf PORTB
movf F0, W ;Now add the frequency data stored in F3/2/1/0 to D3/2/1/0
addwf D0
btfss STATUS, C ;Add lowest order byte and check for and carry at each stage
goto Add1Done ; that could ripple right through to MS byte
incf D1
btfsc STATUS, Z
incf D2
btfsc STATUS, Z
incf D3
Add1Done
movf F1, W ;Add the next byte
addwf D1
btfss STATUS, C
goto Add2Done
incf D2
btfsc STATUS, Z
incf D3
Add2Done
movf F2, W ;... and the next
addwf D2
btfsc STATUS, C
incf D3
movf F3, W ;MS Byte now added in. If it has overflowed, its is exactly what we want
addwf D3 ;D0-3 are now updated ready for next pass through, with D3 only sent to D/A converter.
OutInt
bcf TESTSTRB ;Reset the Test Point
retfie ;This interrupt takes a max of 35 clocks for worst case addition, so does leave
; a bit of scope for extra tasks or faster sampling.
....it doesn't mean a lot to me, but the gist of it seems to be add the fixed number to the lowest byte, then when that byte fills up, add a 'carry bit' to the second byte of the four ....rinse repeat until the the whole 32 bits are full, then start again from zero.
If it can be donekludged in Picbasic, would anyone be gracious enough to get me started?!!
If it can't be done, I guess I could try and work out what bits of his code to put in PICBasic ASM interrupt plus other supporting code! (that'll be me gone for a few months!)
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Straying off a little here, on my journey towards having accurate sine waves under precise frequency control, here's the 16f1828's 5 bit DAC pin outputting a sawtooth - won't win any fidelity awards, but very simple to do at least!..
http://img825.imageshack.us/img825/259/sawf.jpg
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Why not use LONG variable? PBP will do everything for you.
Before LONG I use something like this
Code:
A var byte
B var byte
C var byte
etc
main:
GOTO main
Init: ' start value of each byte
A=0
B=0
etc...
RETURN
Inc:
A=A+1
IF A=0 THEN
B=B+1
IF B=0 THEN
C=C+1
IF C=0 THEN
D=D+1
ENDIF
ENDIF
ENDIF
A is lowest byte, D is highest.
A,B,C,D is 0 only on overflow, so if lowest byte overflow(IT go from 255 to 0) you need to add 1 to second byte.
For example if you want to calculate actual value of counter you need to do it like this:
32bitResult=D*2^24+C*2^16+B*2^8+A
Hope that I understand what exactly you need.
EDIT:
Sorry for long, you use 16F. I didn't use 16F since LONG variable is added to PBP...
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Excellent, it was this bit that is all I needed...
Code:
Inc:
A=A+1
IF A=0 THEN
B=B+1
IF B=0 THEN
C=C+1
IF C=0 THEN
D=D+1
ENDIF
ENDIF
ENDIF
obvious when you see someone else type it!
I then just use the value of the final variable (D) as lookup towards extracting a value in a preloaded 256 byte array - great stuff, I'll have a dabble with this later - many thanks!
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Hi,
I'm afraid it's not quite THAT easy :-(
Yes, it works OK as long as the value you add to the accumulator is 1 but what about when you want to add 2? Well, then A goes 0, 2, 4, 6....252, 254, 1 which means that B won't increment.
And what about adding a value larger than 255?
Of course it can be done in PBP but it involves a little bit more.
/Henrik.
Re: concatenating 4 bytes into one pseudo 32 bit counter?
I use similar code for numbers greater then 1.
Something like this:
Code:
A VAR WORD
B,C,D,Add VAR BYTE
INC:
A=A+Add
IF A>255 THEN
A=A-255
B=B+1
IF B=0 THEN
C=C+1
IF C=0 THEN
D=D+1
ENDIF
ENDIF
ENDIF
1 Attachment(s)
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Hi,
Here's a piece of code working with a 32bit accumulator, the lookuptable from the code Hank linked to and the resulting waveform plotted in Excel with addvalues of:
1) 512500
2) 128500
3) 22825
Code:
LSW VAR WORD ' Least significat word of accumulator
MSW VAR WORD ' Most significatn word of accumulator
ADDL VAR WORD ' Least significant work of value to add
ADDH VAR WORD ' Most significant word of value to add
Out VAR BYTE ' This is the actual output from the lookup table
Temp VAR WORD
OverFlow VAR BIT ' Gets set when 32bit accumulator overflows.
i VAR WORD
Init:
LSW = 0
MSW = 0
AddL = 500
AddH = 2000 ' 50*256+500=768500
Pause 3000
Main:
For i = 1 to 1000
OverFlow = 0
TMR1H = 0
TMR1L = 0
Gosub Add
Gosub GetValue
HSEROUT["Count: ", DEC4 i, " MSW: ", DEC5 MSW, " LSW: ", DEC5 LSW, " Overflow: ", BIN Overflow, " Out: ", DEC Out, " Ticks: ", DEC5 TMR1H*256+TMR1L, 13]
Pause 5
NEXT
END
Add:
T1CON = 1 ' This is just used to measure the execution time
Temp = LSW ' Remember least significant word
LSW = LSW + ADDL ' Add low word
If LSW < Temp Then ' Did we wrap around/overflow?
MSW = MSW + 1 ' Increment high word
If MSW = 0 Then OverFlow = 1 ' Did we overflow high word?
ENDIF
Temp = MSW ' Remember high word
MSW = MSW + ADDH ' Add high word
If MSW < Temp Then ' Did we wrap around/overflow?
OverFlow = 1 ' Set flag
ENDIF
T1CON = 0
RETURN
GetValue:
Lookup MSW.HighBYTE, [$80,$83,$86,$89,$8C,$8F,$92,$95,$98,$9C,$9F,$A2,$A5,$A8,$AB,$AE,$B0,$B3,$B6,$B9,$BC,$BF,$C1,$C4,_
$C7,$C9,$CC,$CE,$D1,$D3,$D5,$D8,$DA,$DC,$DE,$E0,$E2,$E4,$E6,$E8,$EA,$EC,$ED,$EF,$F0,$F2,$F3,$F5,$F6,$F7,$F8,$F9,$FA,$FB,$FC,$FC, _
$FD,$FE,$FE,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FE,$FE,$FD,$FC,$FC,$FB,$FA,$F9,$F8,$F7,$F6,$F5,$F3,$F2,$F0,$EF,$ED,$EC, _
$EA,$E8,$E6,$E4,$E2,$E0,$DE,$DC,$DA,$D8,$D5,$D3,$D1,$CE,$CC,$C9,$C7,$C4,$C1,$BF,$BC,$B9,$B6,$B3,$B0,$AE,$AB,$A8,$A5,$A2,$9F,$9C, _
$98,$95,$92,$8F,$8C,$89,$86,$83,$7F,$7C,$79,$76,$73,$70,$6D,$6A,$67,$63,$60,$5D,$5A,$57,$54,$51,$4F,$4C,$49,$46,$43,$40,$3E,$3B, _
$38,$36,$33,$31,$2E,$2C,$2A,$27,$25,$23,$21,$1F,$1D,$1B,$19,$17,$15,$13,$12,$10,$0F,$0D,$0C,$0A,$09,$08,$07,$06,$05,$04,$03,$03, _
$02,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01,$02,$03,$03,$04,$05,$06,$07,$08,$09,$0A,$0C,$0D,$0F,$10,$12,$13, _
$15,$17,$19,$1B,$1D,$1F,$21,$23,$25,$27,$2A,$2C,$2E,$31,$33,$36,$38,$3B,$3E,$40,$43,$46,$49,$4C,$4F,$51,$54,$57,$5A,$5D,$60,$63, _
$67,$6A,$6D,$70,$73,$76,$79,$7C],Out
RETURN
The add routine works with two words instead of four bytes and takes ~86 cycles normally but 121 cycles when it overflows. Not the most effecient code for sure but it does seem to work. If you're running at 32Mhz and interrupting at 20kHz that's still 400 cycles between interrupts.
/Henrik.
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Wow Henrik...what can I say (thank heavens for folks like you & others on here)
I won't pretend to understand it all (once numbers start going above 256 values "woah, there goes scary stuff!").
re this bit...
Code:
Init:
LSW = 0
MSW = 0
AddL = 500
AddH = 2000 ' 50*256+500=768500
Not understanding the bolded bits - can you please let me know what you're doing there?
I'm trying to see how/where I would enter what in DDS terms is called the tuning word (essentially the number that gets added to the accumulator each interrupt?
Also, I was hoping (eventually) that the tuning word would arrive serially (either being calculated manually or sent from another pic)....the maths are going to be a bit troubling...to glean the tuning word to set the required output frequency, it's
required frequency/interrupt rate * accumulator size
so for a wanted frequency of 4971Hz involving a 32 bit accumulator & and say an interupt rate of 20,000Hz
(4971/20000) * 4294967296
...that's gonna be a challenge in an 8 bit PIC?
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Hi,
You have the 32bit accumulator built up by the two WORDS, LSW and MSW. Then you have the 32bit value which gets added to the accumulator each iteration (each interrupt in your case) and that's the ADDL and ADDH words. Perhaps it's the invalid comment that's causing confusion....?
Lets take a 16bit WORD as an example.
myValue VAR WORD
myValue = 12345
Now, the WORD, which is two bytes holds the value 12345, if you'd look at the high byte of that word its value would be 48 and the value in the low byte would be 57. Why? Because 48*256+57=12345
Same thing with our accumulator and "adder value" but this time we're working with two WORDS.
ADDL = 500
ADDH = 2000
2000 * 65536 + 500 = 512500 which is the value getting added to the accumulator each time. In your example, 4971/20000*2^32 the, value to add the accumulator each time is 1067514121 or ADDH=16288, ADDL=64753. Or, which might be easier expressed in hex: 3FA0F909, see there's your two words, ADDH=$3FA0, ADDL=$F909
Let me know if you try it on some real hardware.
/Henrik.
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Thanks Henrik....excellent stuff.
So, using your code where I have say a 20khz interrupt rate in place, would it be the extract below that goes into the actual 'accumulator addition & lookup' interrupt subroutine?
Code:
Add: ' start of interrupt interrupt routine?
Temp = LSW ' Remember least significant word
LSW = LSW + ADDL ' Add low word
If LSW < Temp Then ' Did we wrap around/overflow?
MSW = MSW + 1 ' Increment high word
If MSW = 0 Then OverFlow = 1 ' Did we overflow high word?
ENDIF
Temp = MSW ' Remember high word
MSW = MSW + ADDH ' Add high word
If MSW < Temp Then ' Did we wrap around/overflow?
OverFlow = 1 ' Set flag
ENDIF
'
'
Lookup MSW.HighBYTE, [$80,$83,$86,$89,$8C,$8F,$92,$95,$98,$9C,$9F,$A2,$A5,$A8,$AB,$AE,$B0,$B3,$B6,$B9,$BC,$BF,$C1,$C4,_
$C7,$C9,$CC,$CE,$D1,$D3,$D5,$D8,$DA,$DC,$DE,$E0,$E2,$E4,$E6,$E8,$EA,$EC,$ED,$EF,$F0,$F2,$F3,$F5,$F6,$F7,$F8,$F9,$FA,$FB,$FC,$FC, _
$FD,$FE,$FE,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FE,$FE,$FD,$FC,$FC,$FB,$FA,$F9,$F8,$F7,$F6,$F5,$F3,$F2,$F0,$EF,$ED,$EC, _
$EA,$E8,$E6,$E4,$E2,$E0,$DE,$DC,$DA,$D8,$D5,$D3,$D1,$CE,$CC,$C9,$C7,$C4,$C1,$BF,$BC,$B9,$B6,$B3,$B0,$AE,$AB,$A8,$A5,$A2,$9F,$9C, _
$98,$95,$92,$8F,$8C,$89,$86,$83,$7F,$7C,$79,$76,$73,$70,$6D,$6A,$67,$63,$60,$5D,$5A,$57,$54,$51,$4F,$4C,$49,$46,$43,$40,$3E,$3B, _
$38,$36,$33,$31,$2E,$2C,$2A,$27,$25,$23,$21,$1F,$1D,$1B,$19,$17,$15,$13,$12,$10,$0F,$0D,$0C,$0A,$09,$08,$07,$06,$05,$04,$03,$03, _
$02,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01,$02,$03,$03,$04,$05,$06,$07,$08,$09,$0A,$0C,$0D,$0F,$10,$12,$13, _
$15,$17,$19,$1B,$1D,$1F,$21,$23,$25,$27,$2A,$2C,$2E,$31,$33,$36,$38,$3B,$3E,$40,$43,$46,$49,$4C,$4F,$51,$54,$57,$5A,$5D,$60,$63, _
$67,$6A,$6D,$70,$73,$76,$79,$7C],Out
@ INT_RETURN
Re: concatenating 4 bytes into one pseudo 32 bit counter?
Henrik, rather than have two threads running, if you don't mind I'll cut/paste your input over to the other thread http://www.picbasic.co.uk/forum/show...921#post106921 , which perhaps has a more appropriate title for the content we are now discussing (allowing others to find it easier)
