Subversion Repositories gecko3

/* GECKO3COM
 *
 * Copyright (C) 2008 by
 *   ___    ____  _   _
 *  (  _`\ (  __)( ) ( )   
 *  | (_) )| (_  | |_| |   Berne University of Applied Sciences
 *  |  _ <'|  _) |  _  |   School of Engineering and
 *  | (_) )| |   | | | |   Information Technology
 *  (____/'(_)   (_) (_)
 *
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details. 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/********************************************************************/
/** \file ser.c
 *********************************************************************
 * This file contains a simple interrupt driven serial driver with
 * buffer (no check for overflow!!!).
 *********************************************************************
 * \note:
 * Remember to enable all interrupts (EA=1) outside of this module!!
 ********************************************************************/
 
#include "fx2regs.h"
#include "ser.h"
#include "isr.h"
 
/** enable non blocking operation of the ser_getc function */
#define NON_BLOCKING
 
/** Transmit buffer write pointer */
unsigned char __xdata ser_txIndexIn;
/** Transmit butter read pointer */
unsigned char __xdata ser_txIndexOut;
/** Receive buffer write pointer */
unsigned char __xdata ser_rxIndexIn;
/** Receive buffer read pointer */
unsigned char __xdata ser_rxIndexOut;
 
/** Transmitt buffer */
unsigned char __xdata ser_txBuffer[0x100];
/** Receive buffer */
unsigned char __xdata ser_rxBuffer[0x100];
 
/** Transmitt Busy flag */
static __bit ser_txBusy;
 
/************************************************************************/
/**  Initializes the UART
 * Initializes the UART for the serial Port 0 with 115,2 Kbaud, 1 start,
 * 1 stop and no parity bit.
 *************************************************************************
 * \param[in]  
 * \param[out] 
 * \return     
 *************************************************************************
 * \author     Christoph Zimmermann, SDCC Team
 * \date       21.Nov.2008 
 ************************************************************************/
void
ser_init(void)
{
  ES0 = 0;
 
  ser_txBusy     = 0;
 
  ser_txIndexIn  = 0;
  ser_txIndexOut = 0;
  ser_rxIndexIn  = 0;
  ser_rxIndexOut = 0;
 
  UART230 = 0x01; /*enable high speed baud rate generator, 115,2 kbaud*/
 
  /*T2CON = 0x30;*/ /*select timer 2 as baudrate generator*/
  /* Baudrate = 19200, oscillator frq. of my processor is 21.4772 MHz */
  /*RCAP2H = 0xFF;*/
  /*RCAP2L = 0xDD;*/
  /* enable counter */
  /*T2CON = 0x34;*/
 
  SCON0 = 0x50; /*Serial Port 0 in Mode 1 (async,1 start, 1 stop, no parity)*/
 
  if (TI) {
    TI = 0;
  }
  if (RI) {
    RI = 0;
  }
 
  hook_sv(SV_SERIAL_0, (unsigned short) isr_SERIAL_0);
 
  ES0=1;  
}
 
/************************************************************************/
/** \brief Interrupt service routine for RS232 handling
 * if there is data to send it copies the next char from the send buffer
 * to the uart
 * if data is received it will be copyied to the receive buffer.
 *************************************************************************
 *  \author     Christoph Zimmermann, SDCC Team
 *  \date       21.Nov.2008 
 ************************************************************************/
void
isr_SERIAL_0(void) interrupt
{
  ES0=0;
 
  if (RI) {
    RI = 0;
    ser_rxBuffer[ser_rxIndexIn++] = SBUF0;
  }
 
  if (TI) {
    TI = 0;
    if (ser_txIndexIn == ser_txIndexOut) {
      ser_txBusy = 0;
    }
    else {
      SBUF0 = ser_txBuffer[ser_txIndexOut++];
    }
  }
 
  ES0=1;
}
 
/************************************************************************/
/**  \brief sends one char over the serial line
 *************************************************************************
 * \param[in] c  character to send
 *************************************************************************
 * \author     Christoph Zimmermann, SDCC Team
 * \date       21.Nov.2008 
 ************************************************************************/
void 
ser_putc(unsigned char c)
{
  ES0=0;
 
  if (ser_txBusy) {
    ser_txBuffer[ser_txIndexIn++] = c;
  }
  else {
    ser_txBusy = 1;
    SBUF0 = c;
  }
 
  ES0=1;
}
 
/************************************************************************/
/**  \brief receives one char from the serial line
 *************************************************************************
 * \return  receive character
 *************************************************************************
 * \author     Christoph Zimmermann, SDCC Team
 * \date       21.Nov.2008 
 ************************************************************************/
unsigned char
ser_getc(void)
{
  char tmp;
 
#ifdef NON_BLOCKING
  if (ser_rxIndexIn != ser_rxIndexOut) {
    tmp = ser_rxBuffer[ser_rxIndexOut++];
  }
  else {
    tmp = 0;
  }
#endif
 
  return(tmp);
}
 
/************************************************************************/
/**  \brief sends a string of characters over the serial line
 *************************************************************************
 * \param[in]  string to send
 *************************************************************************
 * \author     Christoph Zimmermann, SDCC Team
 * \date       21.Nov.2008 
 ************************************************************************/
void
ser_printString(char *String)
{
  while (*String) {
    ser_putc(*String++);
  }
}
 
/************************************************************************/
/**  \brief function to check if there is a new character to read
 *************************************************************************
 * \return  returns 1 if a new character is available else 0
 *************************************************************************
 * \author     Christoph Zimmermann, SDCC Team
 * \date       21.Nov.2008 
 ************************************************************************/
char
ser_charAvail(void)
{
  char ret = 0;
 
  if (ser_rxIndexIn != ser_rxIndexOut) {
    ret = 1;
  }
 
  return(ret);
}
 
/*********************End of File************************************/