Software Usart using timer1 compare and ext int

[Eugeneo]

I just wrote this disasterous code. I know I should have went with a chip with a hardware RS232 usart, but this seems to work really well. There is enough cpu power to write to a flash spi(osc/4) chip at 9600 bps with back to back data. My question is, are there any better ways of doing this .... of course excluding hardware usart.



#byte OSCCON = 0x8F
#bit EXT_INT_FLAG = 0x8B.1
#bit TMR0_INT_FLAG = 0x8B.2
#bit TMR1_INT_FLAG = 0x0C.0
#bit CCP1_INT_FLAG = 0x0c.2

#bit SPI_CKP = 0x14.4 // microchip datasheet has better definitions
#bit SPI_CKE = 0x94.6
#bit SPI_SMP = 0x94.7

ext_int_edge(h_TO_l); // 232 trigger method
enable_interrupts(global); // EI

EXT_INT_FLAG = 0; // Clear interrupt flag
enable_interrupts(int_ext); // serial interrupt

TMR0_INT_FLAG = 0; // clear timer0 int flag
disable_interrupts(INT_RTCC); // Enable rpm input interrupt
setup_timer_0(RTCC_INTERNAL |RTCC_DIV_256); //

setup_timer_1(T1_INTERNAL | T1_DIV_BY_1); // timer 1 interval
disable_interrupts(INT_TIMER1); // overflow interrupts
CCP1_INT_FLAG = 0; // Clear interrupt flag
setup_ccp1(CCP_COMPARE_INT); // Configure CCP1 to set
disable_interrupts(INT_CCP1); // disable for now
CCP_1=165;


setup_spi(SPI_MASTER | SPI_CLK_DIV_4);

SPI_CKP = 0;
SPI_CKE = 1;
SPI_SMP = 0;


It uses a the timer1 and int on ccp

#int_ext // *********** Detect serial input *********** //
void start_bit_isr(void) {

output_high(LED); // Turn on the led
output_high(TEST_PIN); // Turn scope check pin on
set_timer1(0); // Reset timer
output_low(TEST_PIN); // Turn off scope check pin
CCP1_INT_FLAG = 0; // ensure no prior CCP flags
enable_interrupts(INT_CCP1); // start bit bang timer for serial in
ser_byte_in=0; // Clear current serial byte
ser_bit_in=0; // Clear serial bit index
disable_interrupts(int_ext); // disable for the duration of 8 bits
EXT_INT_FLAG = 0; // clear interrupt flag
output_low(LED); // Turn off the led
set_timer1(0); // Reset timer
}


#int_ccp1 // *********** bit to bit interrupt ************//
void next_serial_bit(void)
{

output_high(TEST_PIN);
set_timer1(0); // Reset timer
output_low(TEST_PIN);

if(ser_bit_in==8) // 0-7 bits all in
{
disable_interrupts(INT_CCP1); //
enable_interrupts(int_ext); // wait for start bit again
EXT_INT_FLAG = 0; // clear interrupt flag
CCP1_INT_FLAG = 0;
ser_data_ready = 1;

data_in[data_in_index]=ser_byte_in; //transfer byte to buffer

data_in_index+=1; //advance ring buffer
if(data_in_index==BUFFER_SIZE)
data_in_index=0;

return;
}

[Ttelmah]

What you describe is a perfectly reasonable way of doing this. There are a few comments though.
First the compiler now has a 'clear_interrupt' instruction, so you don't need to access the flags with definitions - makes code more portable if you change chip. This has applied for about the last six months, and is desribed in the 'readme', but not (yet) in the standard manual pages.
You don't need to clear the interrupt in the handler. The compiler does this for you on exiting the handler (obviously you do for the 'other interrupt whan switching between the two sources).
Interrupts are disabled by default, so the disables shown in what I presume is an 'extract' from your main code, are not needed. However as a further comment here, clear the interrupts _after_ configuring the device, not before.
The biggest comment though is timing. You set the CCP value once in the main code. You need to change this latter.
Remember that if you have a serial pattern, your 'edge' interrupt will occur on the falling edge of the start bit. Your sampling point for the first bit, needs to be 1.5 bit times latter, then for the subsequent bits at 1 bit time intervals.
Now your CCP timer should be zeroed as soon as possible in the interrupt handler, and the time interval chosen for the first gap, should be 1.5 bit times, _less_ two interrupt latency times (the time to arrive in the edge interrupt, and the time then to reach the 'sampling' interrupt). In the CCP interrupt, the CCP interval should be set to one bit time (the latencies have already been handled). Don't reset the timer in the CCP handler, have the CCP set to automatically reset it's timer. This way there will not be a cumulative error from the latencies.
I don't see where the 'byte' is actually receivd in the code...
If you set a mask to '1', at the same time as you zero the counter, then in the CCP handler have:

[Guest]

[Guest]