Oh, I see. It wouldn't be so evident at a higher sample rate though? Or, as you said, with sufficient row-off time.
Well, I'm glad you don't hate the idea
I have a feeling that Fosc/16 is the fastest SPI rate for 18F uC, so under 32 ins. cy. isn't possible, but getting the precalc under 32 cy. probably isn't possible either (each comparison will take 4 cycles: movfw postinc0/andfw interval/btfss status,z/bsf precalc,bit). So you're right, it should be in the same ballpark as the parallel-load method - quite surprising!pG = &Dgrn[Irow]; // point to Array at IrowL__interrupt66:
;bi88pwm.c,196 :: pG = &Dgrn[Irow]; // point to Array at Irow
MOVLW 3
MOVWF R2
MOVF R3, 0
MOVWF R0
MOVLW 0
MOVWF R1
MOVF R2, 0
L__interrupt67:
BZ L__interrupt68
RLCF R0, 1
BCF R0, 0
RLCF R1, 1
ADDLW 255
GOTO L__interrupt67
L__interrupt68:
MOVLW _Dgrn+0
ADDWF R0, 0
MOVWF _pG+0
MOVLW hi_addr(_Dgrn+0)
ADDWFC R1, 0
MOVWF _pG+1I remember seeing something similar in PICC when I wanted to multiply by some power of 2 - instead of using a multiply instruction it "optimised" it to use a shift left loop. I don't know if it's possible to get around it (even specifying pG = &Dgrn + iRow*8 will likely give the same rubbish). If you're concerned (sounds like you're not), you can use inline assembler to force the use of the multiplier.
void interrupt() // 8-usec (128 cycle) interrupts
{ pir1.TMR2IF = 0; // clear interrupt flag
txreg = Precalc; //
Precalc = 0; //
fsr2 = rowaddr; // fsr2 = &red[row][0] (0x100..0x13F)
asm //
{ movf _interval,W // interval, 0..255
cpfsgt _postinc2 // if(interval >= red[row][0]) {
bsf _Precalc,0 // Precalc |= 1; }
cpfsgt _postinc2 // if(interval >= red[row][1]) {
bsf _redPrecalc,1 // Precalc |= 2; }
cpfsgt _postinc2 // if(interval >= red[row][2]) {
bsf _Precalc,2 // Precalc |= 4; }
cpfsgt _postinc2 // if(interval >= red[row][3]) {
bsf _Precalc,3 // Precalc |= 8; }
cpfsgt _postinc2 // if(interval >= red[row][4]) {
bsf _Precalc,4 // Precalc |= 16; }
cpfsgt _postinc2 // if(interval >= red[row][5]) {
bsf _Precalc,5 // Precalc |= 32; }
cpfsgt _postinc2 // if(interval >= red[row][6]) {
bsf _Precalc,6 // Precalc |= 64; }
cpfsgt _indf2 // if(interval >= red[row][7]) {
bsf _Precalc,7 // Precalc |= 128; }
}
while(!pir1.TXIF) // is this right?
txreg = Precalc; //
Precalc = 0; //
fsr2 |= 64; // fsr2 = &grn[row][7] (0x140..0x17F)
asm //
{ incf _interval,W // interval, 0..255
cpfsgt _postdec2 // if(interval >= grn[row][7]) {
bsf _Precalc,7 // Precalc |= 128; }
cpfsgt _postdec2 // if(interval >= grn[row][6]) {
bsf _Precalc,6 // Precalc |= 64; }
cpfsgt _postdec2 // if(interval >= grn[row][5]) {
bsf _Precalc,5 // Precalc |= 32; }
cpfsgt _postdec2 // if(interval >= grn[row][4]) {
bsf _Precalc,4 // Precalc |= 16; }
cpfsgt _postdec2 // if(interval >= grn[row][3]) {
bsf _Precalc,3 // Precalc |= 8; }
cpfsgt _postdec2 // if(interval >= grn[row][2]) {
bsf _Precalc,2 // Precalc |= 4; }
cpfsgt _postdec2 // if(interval >= grn[row][1]) {
bsf _Precalc,1 // Precalc |= 2; }
cpfsgt _indf2 // if(interval >= grn[row][0]) {
bsf _Precalc,0 // Precalc |= 1; }
}
if(++interval == 0) // if end-of-period
{ asm { //
rlncf _rowsel,F // advance row select bit mask
} //
latc = ~rowsel; // select new row (active low)
rowaddr += 8; // prep for next row
rowaddr &= 0b10111111; // 0x100..0x13F, inclusive
}
while(!pir1.TXIF) // is this right?
stb = 1; stb = 0; // latch data onto outputs
}I'm not actually familiar with pic18 assembler, so maybe I should keep my mouth shut before making assumptions about the language. Well, as you've said, it's possible to do in 20 cy/byte. So that you don't need to waste time waiting for the SPI to finish, just delay the latching of the SPI data until the next ISR, i.e.
void interrupt() // 8-usec (128 cycle) interrupts
{
rowSel = nothing;
stb = 1; stb = 0; // latch data onto outputs from last isr
rowSel = interval;
// setup next interrupt period here...
TXREG = precalcRed;
precalcRed = { your fancy precalc stuff }
tempPrecalcGrn = { your fancy precalc stuff }
// > 40 cycles have now past, so we know the SPI has sent the first byte
TXREG = precalcGrn;
precalcGrn = tempPrecalcGrn;
// update the interval variable here...
}Well its a bit less , but in my case profitable because I do it only once per row.
