rs232_transmitter.c

example for firmware

#include	<pic.h>
#include	<conio.h>
#include    <stdio.h>
#include    "delay.c"
#include    "delay.h" 
__CONFIG(PWRTEN&WDTDIS&UNPROTECT&HS);

#define tx_pin GPIO1		// 1 wire data out for TX module


signed char g,z;
unsigned char data;
unsigned char tx_bitcount,tx_tempbyte;

bit txbit,process;
void tx_module_send(void);
void tx_sequence_start(void);
void tx_byte_start(void);
void tx_bit(void);
void tx_build_byte(void);


/*************************************
 *	Tunable parameters
 */

/* Transmit and Receive port bits */
#define TxData GPIO2		/* bit2 in GP port  */
#define RxData GPIO0		/* bit0 in GP port  */	

#define	XTAL			4000000	/* Crystal frequency (Hz). */
#define	BRATE			2400L	/* Baud rate. */
#define RX_OVERSAMPLE	4		/* Amount of oversampling the receiver does. 
								   Must be a power of two */

/*
 *	Don't change anything else
 ************************************/

#define TIMER_VALUE	XTAL / (4 * BRATE * RX_OVERSAMPLE)

// 1 start bit + 8 data bits + 2 stop bits + safe.
#define TRANSMIT_NUM_BITS	13	
#if ((TIMER_VALUE) < 90)
#error baud rate or oversample too high for crystal speed
#endif

#if ((TIMER_VALUE) > 256)
#error baud rate or oversample too low for crystal speed
#endif

#if	(RX_OVERSAMPLE-1)&RX_OVERSAMPLE
#error	RX_OVERSAMPLE_value must be a power of 2
#endif

// Receiver states.
enum receiver_state {
	RS_HAVE_NOTHING,
	RS_WAIT_HALF_A_BIT,
	RS_HAVE_STARTBIT,
	RS_WAIT_FOR_STOP = RS_HAVE_STARTBIT+8
};

static unsigned char	sendbuffer;			// Where the output char is stored.
static unsigned char	receivebuffer;		// Where the input char is stored as 
  											// it is received.
static bit 				receivebufferfull;	// 1 = receivebuffer is full.


static unsigned char	send_bitno;
static unsigned char	receivestate;		// Initial state of the receiver (0)
static unsigned char	skipoversamples;	// Used to skip receive samples.
static unsigned char	rxshift;
static bit				tx_next_bit;


void putch(char c)
{
	while(send_bitno)
		continue;
	tx_next_bit = 0;
	sendbuffer = c;
	send_bitno = TRANSMIT_NUM_BITS*RX_OVERSAMPLE;
}

char getch(void)
{
	while(!receivebufferfull)
		continue;
	receivebufferfull = 0;
	return receivebuffer;
}



/**
 * serial_isr
 * 
 * Transmits and receives characters which have been
 * "putch"ed and "getch"ed.
 * 
 * This ISR runs BRATE * RX_OVERSAMPLE times per second.
 * 
 * */
interrupt void serial_isr(void)
{
	// Reset Timer0 value
	// This is added to TMR0 because there is a delay to get to the isr.

	TMR0 += -TIMER_VALUE + 4;	// +2 as timer stops for 2 cycles when writing 
								// to TMR0 +2 for tweak
	T0IF = 0;

	/*** RECEIVE ***/

	if( --skipoversamples == 0) {
		skipoversamples++;			// check next time
		switch(receivestate) {

		case RS_HAVE_NOTHING:
			/* Check for start bit of a received char. */
			if(!RxData){
				skipoversamples = RX_OVERSAMPLE/2;
				receivestate++;
			}
			break;

		case RS_WAIT_HALF_A_BIT:
			if(!RxData) {			// valid start bit
				skipoversamples = RX_OVERSAMPLE;
				receivestate++;
			} else
				receivestate = RS_HAVE_NOTHING;
			break;
			
		// case RS_HAVE_STARTBIT: and subsequent values
		default:
			rxshift = (rxshift >> 1) | (RxData << 7);
			skipoversamples = RX_OVERSAMPLE;
			receivestate++;
			break;

		case RS_WAIT_FOR_STOP:
			receivebuffer = rxshift;
			receivebufferfull = 1;
			receivestate = RS_HAVE_NOTHING;
			break;

		}
	}

	
	/*** TRANSMIT ***/
	/* This will be called every RX_OVERSAMPLEth time
	 * (because the RECEIVE needs to over-sample the incoming
	 * data). */

	if(send_bitno) {
	       	if((send_bitno & (RX_OVERSAMPLE-1)) == 0) {
			TxData = tx_next_bit;		// Send next bit.
			tx_next_bit = sendbuffer & 1;
			sendbuffer = (sendbuffer >> 1) | 0x80;
		}
		send_bitno--;
	}

}


void main(void)
{
      TRISIO=0x39;
      tx_pin=0;
	  TxData=1;
      CMCON0=0x07;
      ANSEL=0;
    receivestate = RS_HAVE_NOTHING;
	skipoversamples = 1;			// check each interrupt for start bit
   receivebufferfull = 0;
  
    // Set up I/O direction.
	
	/* Set up the timer. */
	T0CS = 0;						// Set timer mode for Timer0.
	TMR0 = (2-TIMER_VALUE);			// +2 as timer stops for 2 cycles
									// when writing to TMR0
	T0IE = 1;						// Enable the Timer0 interrupt.
	GIE = 0;


while(1)		// continually

{
GIE=1;
data = getch();
putch(data);  
GIE=0;
for(z=0;z<15;z++)
{ tx_pin=1;
 DelayUs(500);
 tx_pin=0;
 DelayUs(500);
}
tx_module_send();

	}

}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void tx_module_send(void)
{
unsigned char tx_byte[3];
 tx_byte[0]=0xB6;		
 tx_byte[1]=0xAC;	
 tx_byte[2]= data;

tx_sequence_start();

for (g=0;g<3;g++){
	tx_byte_start();
	tx_tempbyte=tx_byte[g];
	tx_build_byte();
					}

tx_pin=1;				// end of transmission
DelayUs(250);
tx_pin=0;
DelayUs(250);

}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void tx_sequence_start(void)		//