// file: irda.c
// vers: 1.1
//
// This is a program for the PIC16F84 running on an iRX board -- 
// see http://www.media.mit.edu/~r/projects/picsem/ for info
// on the iRX board in general.
// 
// The program looks for IrDA data recieved over the infrared
// port and prints it out as serial data.  Similarly, it looks
// for serial data received on the RS232 port and transmits it
// as IR data.  Communication rates are set at 9600 baud.
//
// NOTE 1: A stock iRX board requires some modifications before
// this program can be run.  Refer to the section on "Modifying
// the iRX board" below for the required modifications.
//
// NOTE 2: This program is "half duplex": attempts to receive 
// data on one port (IR or RS232) while transmitting on another 
// will result in dropped characters.
//
// REVISION HISTORY
//
// 1999 Nov 03 - Vers 1.1 - Robert Poor <r@media.mit.edu>
// Eliminated interrupt routine, use INTCON.INTF instead as 
// the pulse catcher.  Added documentation on how to perform 
// the required modifications to a stock iRX board.
//
// PROGRAM STRUCTURE
//
// In main(), the program loops, looking for a start bit either
// from the serial input or from the IrDA receiver.  If an IrDA
// start bit is detected, the program starts reading in IrDA bytes
// and storing them in a global buffer, stopping only when the
// buffer is full or when the IrDA data stops coming in (as detected
// by the absence of a start bit).  The accumulated contents of the
// global buffer is "printed" to the RS232 serial output.
//
// The situation is similar if an RS232 start bit is detected:
// the program starts reading RS232 bytes over the serial port
// and storing the bytes in a buffer, stopping only when the
// buffer is full or when the RS232 data stops coming in (as 
// detected by the absense of a start bit).  The accumulated
// contents of the global buffer is then transmitted over the
// IrDA emitter using "IrDA style" signalling.
//
// CATCHING AN IR PULSE
//
// The iRX board receives IR data through a Sharp IS1U20 IRDA
// receiver.  When the IRDA receiver detects IR, it emits a short 
// (negative going) pulse, approximately 2 uSec long.  It's not
// practical to have the PIC monitoring the IR input line continually
// looking for such a short pulse, so we use a simple trick to 
// latch the pulse.  But the iRX board must be modified for this
// trick:
//
// IR pulses arrive on RB0, the "external interrupt" pin of the PIC.
// (See below for board modifications required to make this so.)
// The call to ext_int_edge() in main() configures RB0 so that the
// external interrupt flag, INTCON.INTF, will be set whenever an IR 
// pulse is detected.  Thereafter, it's sufficient simply to look at 
// INTCON.INTF to see if a pulse has been received.  However, it's
// the responsibility of the code to reset INTON.INTF to zero before 
// any subsequent pulses are received.
//
// MODIFYING AN IRX BOARD
//
// Two modifications are requires to make a "stock" iRX board
// run this program.
//
// 1: Feed the IS1U20 into RB0: you must jumper the PIC RB4 to
//    PIC RB0.  The easiest way is to take a short piece of 
//    wire and connect directly between U3 pin 6 and U3 pin 10.
// 2: Add more decoupling for the IR1U20.  The IR receiver
//    is very sensitive to noise on the power supply, so additional
//    decoupling is needed to prevent false triggers.  Immediately
//    "inboard" of the IR receiver (U4) is a row of V+ and a row
//    of GND connection points.  Solder a 22 uF capacitor *and* a
//    .1 uF capacitor between V+ and GND right there.  (Note to
//    self: next rev should have a small RC filter in line with the
//    V+ lead going to the IS1U20.)
//
#include <16F84.H>
#fuses HS,NOWDT,NOPROTECT,PUT
#use DELAY(clock=10000000)

#use fast_io(A)
#use fast_io(B)

// Standard definitions for the irx2_1 board
//
#define RS232_XMIT      PIN_B1  // (output) RS232 serial transmit
#define RED_LED         PIN_B2  // (output) Red LED (low true)
#define IR_LED          PIN_B3  // (output) Infrared LED (low true)
#define IR_SENSOR       PIN_B4  // (input) IR sensor (Sharp IS1U30)
#define RS232_RCV       PIN_B5  // (input) RS232 serial receive

// Macros to simplify I/O operations
//
#define RED_LED_ON      output_low(RED_LED)
#define RED_LED_OFF     output_high(RED_LED)
#define IR_LED_ON       output_low(IR_LED)
#define IR_LED_OFF      output_high(IR_LED)
#define	IR_RECEIVED	(!input(IR_SENSOR))

// Default TRIS bits: RS232_RCV and IR_SENSOR are inputs, all
// others are outputs
//
#define IRX_B_TRIS      0b00110000

// ===================================================================
// General definitions
//

struct {
  short int RBIF;
  short int INTF;
  short int T0IF;
  short int RBIE;
  short int INTE;
  short int T0IE;
  short int PEIE;
  short int GIE;
} INTCON;
#byte	INTCON	= 0x0B

// general I/O buffer
//
#define BUF_SIZE	32
char gBuf[BUF_SIZE];

// ===================================================================
// IRDA constants
//

// Port B0 is also an input (jumpered from IR_RECEIVE port)
#define IRDA_TRIS	(IRX_B_TRIS | 0b00000001)

// Minimum IRDA pulse is 1.63 uSec.  With 400 nSec instruction
// cycle time (10MHz clock), this requires 4+ cycles, ergo 5.
//
#define IRDA_PULSE_CYCLES	5

// The following assume an RTCC prescaler of 4:1, or 1600 nSec tics
//
#define	IRDA_BIT_TICS		65	// 1/9600 baud
#define	IRDA_STARTBIT_TICS	98	// 1.5 * 1/9600 baud
#define	IRDA_TIMEOUT_TICS	255

// ===================================================================
// IR Output
//

// Wait until the *previous* bit period has expired, then
// write a single bit using IrDA 1.0 protocol: a 1.63 uSec
// pulse for a zero bit, no pulse for a one bit.
//
// Reads low order bit in b
//
void putIRDABit(int b) {
  do {} while (!INTCON.T0IF);	// wait for TMR0 to expire
  set_rtcc(256-IRDA_BIT_TICS);	// reset for next bit period
  INTCON.T0IF = 0;
  output_high(PIN_A2);		// for 'scope testing
  if (!(b&1)) {			// pulse for 0 bit, no pulse for 1
    IR_LED_ON;
    delay_cycles(IRDA_PULSE_CYCLES-1);
    IR_LED_OFF;
  }
  output_low(PIN_A2);		// for 'scope testing
}

// write a start bit, 8 bits of b (LSB first), and a stop
// bit using IrDA 1.0 protocol.
//
void putIRDAByte(char b) {
  output_high(PIN_A1);
  putIRDABit(0);		// start bit
  putIRDABit(b);		// b0: lsb first
  b >>= 1;
  putIRDABit(b);		// b1
  b >>= 1;
  putIRDABit(b);		// b2
  b >>= 1;
  putIRDABit(b);		// b3
  b >>= 1;
  putIRDABit(b);		// b4
  b >>= 1;
  putIRDABit(b);		// b5
  b >>= 1;
  putIRDABit(b);		// b6
  b >>= 1;
  putIRDABit(b);		// b7: msb
  putIRDABit(1);		// stop bit
  output_low(PIN_A1);
}

// Send all the chars in Buf[] via IrDA
//
void putIRDABuf(int count) {
  int i;

  INTCON.T0IF = 1;		// makes putIRBit() start immediately
  for (i=0; i<count; i++) {
    putIRDAByte(gBuf[i]);
  }
}

// ===================================================================
// IR Input
//

// Wait for an IR start bit.  If no start bit
// was seen within the timeout interval, return
// 0.  Otherwise set up RTCC to roll over in the 
// middle of the next bit cell and return 1.
//
int findIRDAStart() {
  output_high(PIN_A1);
  set_rtcc(256-IRDA_TIMEOUT_TICS);
  INTCON.T0IF = 0;

  while (!INTCON.T0IF) {
    if (INTCON.INTF) {
      output_high(PIN_A2);
      // caught a start bit.  next tic in 1.5 bit cells...
      set_rtcc(256-IRDA_STARTBIT_TICS);
      INTCON.T0IF = 0;
      INTCON.INTF = 0;
      output_low(PIN_A1);
      output_low(PIN_A2);
      return 1;			// start bit seen
    }
  }
  output_low(PIN_A1);
  return 0;			// start bit not seen
}

// Wait for TMR0 to indicate the end of a bit cell.  If
// in that time an IR pulse has been received, return a
// zero.  Otherwise return a 1
//
int getIRDABit() {
  int seen;
  output_high(PIN_A3);
  do { 
    output_high(PIN_B7);
    seen = INTCON.INTF;
    output_low(PIN_B7);
  } while (!INTCON.T0IF);
  set_rtcc(256-IRDA_BIT_TICS);	// reset for next bit period
  INTCON.T0IF = 0;
  INTCON.INTF = 0;		// reset "pulse seen" flag
  output_low(PIN_A3);
  return !seen;
}

// Read a single IrDA byte.  Assumes the start bit has 
// already been detected and that RTCC is set to roll 
// over in the middle of the first bit cell.
//
int getIRDAByte() {
  char ch;

  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  shift_right(&ch, 1, getIRDABit());
  return ch;
}

// Read bytes from the IrDA input and store them
// in gBuf[].  Upon entry, it's assumed that a
// start pulse has been detected and that RTCC
// is set up to roll over in the middle of the
// first bit period.
//
// Returns when no start bit is detected within
// the given timeout period OR when the buffer
// is full.
//
int getIRDABuf() {
  int count = 0;
  output_high(PIN_A0);
  do {
    gBuf[count++] = getIRDAByte();
    if (count == BUF_SIZE) break;
  } while (findIRDAStart());
  output_low(PIN_A0);
  return count;
}

// ===================================================================
// RS232 constants

#use rs232(baud=9600, xmit=RS232_XMIT, rcv=RS232_RCV)

// The following assume an RTCC prescaler of 4:1, or 1600 nSec tics
//
#define	RS232_TIMEOUT_TICS	255

// ===================================================================
// RS232 Output
//

// Send all the chars in Buf[] via RS232
//
void putRS232Buf(int count) {
  int i;

  for (i=0; i<count; i++) {
    putc(gBuf[i]);
  }
}

  
// ===================================================================
// RS232 Input
//

// Look for an RS232 start bit, returning 1 if
// a start bit was detected or 0 if no start bit
// was detected in the timeout period.
//
int findRS232Start() {
  set_rtcc(256-RS232_TIMEOUT_TICS);
  INTCON.T0IF = 0;

  while (!INTCON.T0IF) {
    if (kbhit()) return 1;
  }
  return 0;			// timed out waiting for RS232 data
}

// Read bytes from the RS232 input and store them
// in gBuf[].  Upon entry, it's assumed that an
// RS232 start bit has been detected.
//
// Returns when no start bit is detected within
// the given timeout period OR when the buffer
// is full.
//
int getRS232Buf() {
  int count = 0;
  do {
    gBuf[count++] = getc();
    if (count == BUF_SIZE) break;
  } while (findRS232Start());
  return count;
}


// ===================================================================
// Main read/write loop
//

#define IRDA_SEEN	1
#define	RS232_SEEN	0

// loop until an IrDA start bit or a serial start bit
// is detected.
//
// If an IrDA bit is seen, set up RTCC to interrupt 
// after 1.5 bit cells and return IRDA_SEEN.  Otherwise
// if an RS232 start bit is seen, return RS232_SEEN.
//
int waitForStart() {
  output_high(PIN_B6);
  while (1) {
    if (INTCON.INTF) {
      set_rtcc(256-IRDA_STARTBIT_TICS);
      INTCON.T0IF = 0;
      INTCON.INTF = 0;
      output_low(PIN_B6);
      return IRDA_SEEN;
    } else if (kbhit()) {
      output_low(PIN_B6);
      return RS232_SEEN;
    }
  }
}

void main() {
  set_tris_a(0x00);		// all outputs
  set_tris_b(IRDA_TRIS);

  output_low(PIN_A0);
  output_low(PIN_A1);
  output_low(PIN_A2);
  output_low(PIN_A3);
  output_low(PIN_A4);

  setup_counters(RTCC_INTERNAL, RTCC_DIV_4);

  RED_LED_ON;			// reality check at startup
  delay_ms(200);
  RED_LED_OFF;

  ext_int_edge(H_TO_L);		// watch for leading edge of IR pulse

  printf("IrDA 1.1\r\n");

  while (1) {
    if (waitForStart() == IRDA_SEEN) {
      putRS232Buf(getIRDABuf());
    } else {
      putIRDABuf(getRS232Buf());
    }
  }
}