please dont rip this site

PIC Specific RS232 routine

Rob Hamerling's 57.6kbps interrupt driven 16F628 test circuit and program

// ---------------------------------------------------------------------
// S628.c     Study/experiment with interrupt driven serial
//            communications with a PIC-equiped device as DCE.
//
// Author:    Rob Hamerling.
// Date:      January 2003.
// E-mail:    robh@hccnet.nl
// homepahe:  http://www.robh.nl
// ---------------------------------------------------------------------
//
//  Function: echo incoming datastream from DTE.
//  Features:
//  - Interrupt driven, high speed, full duplex data flow (57600 bps)
//  - Use of builtin USART in RS232 mode (8 bits, no parity).
//  - With relatively large receive buffer.
//  - Using CTS flow control (PC -> PIC).
//    PC-side should have set CTS output flow control enabled,
//    PC FiFo transmit load count may be set to 16 (max).
//  - Note: no RTS flow control (PIC -> PC)!
//
//  Language support: CC5X compiler version 3.1
//
//  Hardware: PIC 16F628 or similar with UART, and MAX232.
//
//
// ---------------------------------------------------------------------
//
//  Simplified schematics:
//                                         COMx     plug
//     PIC16F628           MAX232          RS232   DB9 DB25
//  +-------------+     +-----------+
//  |             |     |           |
//  |     RA2  (1)|-----|(11)---(14)|--->-- CTS --- 8   5
//  |     RB0  (6)|-----|(12)---(13)|---<-- RTS --- 7   4
//  |             |     |           |
//  |     RB1  (7)|-----|(9)-----(8)|---<-- TxD --- 3   2
//  |     RB2  (8)|-----|(10)----(7)|--->-- RxD --- 2   3
//  |             |     |           |
//  |     (5)     |     |   (15)    |
//  +------|------+     +----|------+
//         +-----------------+----------- GND --- 5   7
//
//                                    +-< DTR --- 4  20
//   Optional cable wraps:            |
//   (maybe required by PC softw.)    +-> DSR --- 6   6
//                                    +-> DCD --- 1   8
//
// ---------------------------------------------------------------------
// Some basic PIC and RS232 knowledge will be needed to fully understand
// the data flow and control signalling used in this program.
//
// The PIC ports use positive logic:
// '1' is positive voltage, '0' is ground.
//
// This program uses positive logic for boolean variables:
// the symbol TRUE for '1', the symbol FALSE for '0'.
//
// In the RS232 standard:
// - Negative voltage ('mark') means OFF for control signals, and
//   indicates 1 (one) for a data signals (start-, data-, stop-bits).
// - Positive voltage ('space') means ON for control signals and
//   0 (zero) for start-, data- and stop-bits.
//
// Since the MAX232 is not only a level convertor (between TTL and RS232)
// but also a signal inverter, you should be aware of the following:
// - The inversion of PIC data-in and data-out by the MAX232 is required
//   to convert data-, start- and stop-bits to/from the corresponding
//   RS232 polarity. So nothing special has to be done in the program.
// - For RTS and CTS the inversion by the MAX232 inversion is NOT desired,
//   and therefore the program uses inverted signaling for RTS and CTS:
//   'FALSE' is used for ON and 'TRUE' for OFF with RTS/CTS signals!
//   As a reminder for this 'reversed' logic the signals are called
//   here CTSrev and RTSrev.
//
// -------------------------------------------------------------------------
//  For other examples and useful learning material see also:
//    - MicroChip datasheets (for the PIC16F62X: DS30400C).
//    - Tony Kubek's example for the PIC16F876,
//      ASM, interrupt driven, no CTS flow control, single byte buffer.
//    - Fr. Thomas MacGhee's example for the PIC16C74,
//      ASM, not interrupt driven, but contains many educational notes.
// -------------------------------------------------------------------------

#pragma  chip PIC16F628                         // target PIC

#include <int16cxx.h>                           // interrupt support

#pragma  config |=  0x3FFF                      // all on initially
#pragma  config &= ~0x0080                      // LVP off -> RB4 I/O
#pragma  config FOSC=HS                         // 20MHz crystal
#pragma  config WDTE=off                        // watch dog disabled
#pragma  config ID=6280                         // firmware ID (optional)

#pragma  bit CTSrev  @ PORTA.2                  // CTS signal to DTE (PC)
#pragma  bit RTSrev  @ PORTB.0                  // RTS signal from DTE (PC)

typedef  bit         BOOL, BOOLEAN;             // boolean variable type(s)
#define  FALSE       0                          // PIC: off, low
#define  TRUE        1                          // PIC: on, high

#define  OSCFREQ     20000000                   // oscillator frequency

#define  TMR0COUNT   (OSCFREQ/8/16/1000)        // for 1 ms delay (OPTION = 4)

#define  BPSRATE     57600                      // desired speed
#define  BPSCLASS    TRUE                       // BRGH setting (high)
#define  BPSCOUNT    ((10*OSCFREQ/16/BPSRATE-5)/10 - 1)  // SPBRG (BRGH=1)
                                                // closest integer value

#define  XMTBUFSIZE  32                 // (power of 2) output buffer size
#define  RCVBUFSIZE  64                 // (power of 2) input buffer size
#define  DELTA       17                         // minimum free rcv buffer ..
                                                // .. space (PC UARTFiFo + 1)

char     xmtoffset;                             // offset next byte to xmit
char     putoffset;                             // offset last appl. out byte
char     rcvoffset;                             // offset next byte to receive
char     getoffset;                             // offset last appl. in byte

char     xmtbuf[XMTBUFSIZE];                    // circular output buffer

bank1 char rcvbuf[RCVBUFSIZE];                  // circular input buffer
                                                // located in RAM bank1!


// ----------------------------
//  Interrupt service routine
// ----------------------------
#pragma origin 4                                // hardware requirement
extern interrupt isr(void) {

  char  save_FSR;                               // FSR save byte
  char  x;                                      // intermediate byte value

  int_save_registers                            // save registers
  save_FSR = FSR;                               // save FSR

  if (TXIF == TRUE && TXIE == TRUE) {           // RS232 transmit interrupt
    if (xmtoffset != putoffset) {               // still data in xmit buffer
      x = xmtbuf[xmtoffset];                    // next char to xmit
      xmtoffset = (xmtoffset + 1) & (XMTBUFSIZE - 1);   // update offset
      if (xmtoffset == putoffset)               // was this last byte?
        TXIE = FALSE;                           // disable xmit interrupts
      TXREG = x;                                // now actually xmit char
      }
    }

  if (RCIF == TRUE && RCIE == TRUE) {           // RS232 receive interrupt
    if (OERR == TRUE) {                         // overrun, reset UART
      CREN = FALSE;                             // disable UART
      CREN = TRUE;                              // re-enable UART
      }                                         // discard pending bytes
    else if (FERR == TRUE)                      // framing error (break?)
      x = RCREG;                                // read and discard byte
    else {                                      // data without errors
      rcvbuf[rcvoffset] = RCREG;                // move byte to rcv buffer
      x = (rcvoffset + 1) & (RCVBUFSIZE - 1);   // offset next byte
      if (x != getoffset)                       // buffer not yet full
        rcvoffset = x;                          // update offset,
                                                // (else discard byte,
                                                //  CTS flow control failed)

      if (CTSrev == FALSE) {                    // CTS true!
        if (rcvoffset > getoffset)              // circular buffer situation
          x = RCVBUFSIZE - rcvoffset + getoffset;  // free buffer space
        else                                    // other situation
          x = getoffset - rcvoffset;            // free buffer space
        if (x <= DELTA) {                       // buffer reaches 'full'
          CTSrev = TRUE;                        // drop CTS (CTS FALSE)
          }
        }
      }
    }

  /* Note: All other interrupts disabled, so no further checks needed */

  FSR = save_FSR;                               // restore FSR
  int_restore_registers                         // restore other

  }


// -------------------------------------------------------------------
//  Milliseconds delay by polling TMR0
//
//  See top of source for the calculation of TMR0COUNT,
//  depending on oscillator frequency and prescaling via OPTION.
// -------------------------------------------------------------------
static void msdelay(char millisec) {

  do  {
    TMR0 = 0;
    while (TMR0 < TMR0COUNT)                    // pause of 1 millisecond
      ;
    } while (--millisec > 0);                   // number of milliseconds
  }


// -----------------------------------------------
//  copy output bytes of caller
//    from: application buffer
//      to: interrupt controlled transmit buffer
//
//  returns nothing
//
//  notes: - initiates transmission (interrupt handler)
//           when not currently transmitting
//         - spin when transmission buffer full
//           (wait for free buffer space)
// -----------------------------------------------
static void putdata(char *buffer,
                    char bytesout) {
  char  i;                                      // counter(s)
  char  x;                                      // intermediate byte value

  for (i=0; i<bytesout; i++) {                  // all user data
    x = buffer[i];                              // copy char
    xmtbuf[putoffset] = x;                      // .. to buffer
    x = (putoffset + 1) & (XMTBUFSIZE - 1);     // offset next char
    while (x == xmtoffset)                      // buffer full!
      ;                                         // spin until something xmit'd
    putoffset = x;                              // update offset
    TXIE = TRUE;                                // (re-)enable xmit interrupts
    }
  }


// ----------------------------------------------------------------
//  copy input bytes to caller
//     from: interrupt controlled receive buffer
//       to: application buffer
//  returns: number of bytes actually stored in application buffer
//
//   notes: - rise CTS when receive buffer has more than <DELTA>
//            bytes free space after delivering data to caller.
// ----------------------------------------------------------------
static char getdata(char *buffer,               // application buffer
                    char bufsize) {             // size of appl. buffer

  char  i, x;

  for (i=0; i<bufsize; i++) {                   // fill user buffer (max)
    if (getoffset == rcvoffset)                 // no more data
      break;
    x = rcvbuf[getoffset];                      // copy char
    buffer[i] = x;                              // .. to user buffer
    getoffset = (getoffset + 1) & (RCVBUFSIZE - 1);   // update offset

    }                                             // to caller

  if (CTSrev == TRUE) {                         // CTS FALSE)
    if (rcvoffset > getoffset)                  // circular buffer situation
      x = RCVBUFSIZE - rcvoffset + getoffset;   // free buffer space
    else                                        // other situation
      x = getoffset - rcvoffset;                // free buffer space
    if (x >= DELTA) {                           // enough free space now
      CTSrev = FALSE;                           // rise CTS (CTS TRUE)
      }
    }

  return i;                                     // number of bytes returned
  }


// -------------------------------------------------------
//  Perform all required PIC setup
// -------------------------------------------------------
static void setup() {

  CMCON   = 0b0000.0111;                        // Comparator off
  CCP1CON = 0b0000.0000;                        // Capt/Comp/PWM off

  OPTION = 3;                                   // TMR0 prescaler 1:16
  INTCON = 0;                                   // all interrupt bits off
  PIR1   = 0;                                   //  ..

  PORTA  = 0;                                   // all ports zero
  PORTB  = 0;                                   //  ..
  TRISA  = 0b0010.0000;                         // IN: RA5/MCLR
  TRISB  = 0b0001.0011;                         // IN: RB0,1,4

  PIE1   = 0;                                   // disable all ext. interrupts

  BRGH   = BPSCLASS;                            // baudrate class
  SPBRG  = BPSCOUNT;                            // baudrate clock divisor
  TXEN   = TRUE;                                // enable UART transmit
  SYNC   = FALSE;                               // async mode
  RCIE   = TRUE;                                // enable receive interrupts
  SPEN   = TRUE;                                // enable UART
  CREN   = TRUE;                                // enable UART receive

  PEIE   = TRUE;                                // enable external interrupts
  GIE    = TRUE;                                // globally enable interrupts

  }


// ===============================================================
//
//   M A I N L I N E
//
//   Initially CTS is set false and the program waits for
//   RTS to become true before activating the echo loop.
//   When RTS become true, CTS follows, which allows the
//   DTE to send data. The echo loop remains active as
//   long as RTS remains true. When RTS becomes false the
//   echo-loop is terminated and the PIC reset to its initial
//   state, waiting for RTS.
//
// ===============================================================
extern void main(void) {

  char   i, k, l;                               // counter(s)
  char   buffer[20];                            // local I/O buffer

  setup();                                      // init PIC

  for (;;) {                                    // forever
    CTSrev = TRUE;                              // CTS FALSE
    while (RTSrev == TRUE)                      // wait for rise of RTS (DTE)
      ;
    CTSrev = FALSE;                             // CTS TRUE

    xmtoffset = 0;                              // (re-)init ..
    putoffset = 0;                              //  .. input and ..
    rcvoffset = 0;                              //   .. output ..
    getoffset = 0;                              //    .. buffer offsets

    while (RTSrev == FALSE) {                   // RTS TRUE
      l = getdata(buffer, sizeof(buffer));      // get input
      if (l > 0)                                // something received
        putdata(buffer, l);                     // echo the input
      else                                      // nothing
        msdelay(10);                            // do 'low priority' work
      }

    }

  }

+

Questions:


file: /Techref/microchip/16F/628/uartinttst-rh.htm, 15KB, , updated: 2008/1/13 02:52, local time: 2022/6/27 10:36, owner: RH-planet-b,
TOP NEW HELP FIND: 
18.232.177.219:LOG IN

 ©2022 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
Please DO link to this page! Digg it! / MAKE!

<A HREF="http://www.massmind.org/techref/microchip/16F/628/uartinttst-rh.htm"> Rob Hamerling's 57.6kbps interrupt driven 16F628 test circuit and program</A>

After you find an appropriate page, you are invited to your to this massmind site! (posts will be visible only to you before review) Just type a nice message (short messages are blocked as spam) in the box and press the Post button. (HTML welcomed, but not the <A tag: Instead, use the link box to link to another page. A tutorial is available Members can login to post directly, become page editors, and be credited for their posts.


Link? Put it here: 
if you want a response, please enter your email address: 
Attn spammers: All posts are reviewed before being made visible to anyone other than the poster.
Did you find what you needed?

 

Welcome to massmind.org!

 

Welcome to www.massmind.org!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  .