RS232-MUX

/* Microchip Technology Inc. and its subsidiaries.  You may use this software 

 * and any derivatives exclusively with Microchip products. 

 * 

 * THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS".  NO WARRANTIES, WHETHER 

 * EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED 

 * WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A 

 * PARTICULAR PURPOSE, OR ITS INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION 

 * WITH ANY OTHER PRODUCTS, OR USE IN ANY APPLICATION. 

 *

 * IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, 

 * INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND 

 * WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS 

 * BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE.  TO THE 

 * FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS 

 * IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF 

 * ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.

 *

 * MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE 

 * TERMS. 

 */

/* 

 * File: hardware_TL16C754C.h  

 * Author: Enzo Niro

 * Comments: Library for MUX232 to handle TL16C754C chip

 * Revision history: 1.0

 */

#ifndef RS232_HARDWARETL16_H

#define        RS232_HARDWARETL16_H

#include <xc.h> // include processor files - each processor file is guarded. 

//////////////////////////////////////

//prototypes functions

//////////////////////////

//High level functions

void initPortA(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void initPortB(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void initPortC(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void initPortD(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

//Send bytes throught serial port

void txWriteA(uint8_t b);

void txWriteB(uint8_t b);

void txWriteC(uint8_t b);

void txWriteD(uint8_t b);

//Receive bytes from serial port

uint8_t rxReadA(void);

uint8_t rxReadB(void);

uint8_t rxReadC(void);

uint8_t rxReadD(void);

//RX buffer control

//available functions

bool portA_available();

bool portB_available();

bool portC_available();

bool portD_available();

//parity functions

bool getParitySetA();

bool getParitySetB();

bool getParitySetC();

bool getParitySetD();

/*

 TODO : Implement functions...

 */

//////////////////////////

//Low level functions

void writePortA(uint8_t reg, uint8_t addr);

void writePortB(uint8_t reg, uint8_t addr);

void writePortC(uint8_t reg, uint8_t addr);

void writePortD(uint8_t reg, uint8_t addr);

uint8_t readPortA(uint8_t addr);

uint8_t readPortB(uint8_t addr);

uint8_t readPortC(uint8_t addr);

uint8_t readPortD(uint8_t addr);

void setWait(uint16_t cnt); //fast delay

//////////////////////////////////////////////////////////

//Values definitions (not supposed to use it directly)

#define DLAB_ERF_EN_BIT     0x80

#define LCR_REG             0x3 //Static register

///////////////////////////////////////////

// READ Registers

#define RHR_REG         0x0

#define IIR_REG         0x2

#define LSR_REG         0x5

#define MSR_REG         0x6

#define FIFORDY_REG     0x7

///////////////////////////////////////////

// WRITE Registers

#define THR_REG     0x0

#define FCR_REG     0x2

///////////////////////////////////////////

// READ/WRITE Registers

#define IER_REG         0x1

#define LCR_REG         0x3

#define MCR_REG         0x4

#define SPR_REG         0x7

#define DLL_REG         0x0

#define DLH_REG         0x1

#define EFR_REG         0x2

#define XON1_REG        0x4

#define XON2_REG        0x5

#define XOFF1_REG       0x6

#define XOFF2_REG       0x7

#define TCR_REG         0x6

#define TLR_REG         0x7

///////////////////////////////////////////////////////

//CTRL, ADDR and DATA buses

//Data pins

#define DATAWRITE(x)        PORTD.OUT = x

#define DATADIR(x)          PORTD.DIR = x

#define DATAREAD            PORTD.IN

//Address pins

#define ADDRWRITE(x)        PORTE.OUT = x

#define ADDR_ENABLE         PORTE.DIR |= 0x07

//Controls pins

#define ENABLE_POW_SUPPLY_PIN   PORTF.DIR |= 0x01

#define ENABLE_WR_RD_PINS       PORTB.DIR |= 0x30

#define ENABLE_CS_PINS          PORTB.DIR |= 0x0F

#define ENABLE_RESET_PIN        PORTE.DIR |= 0x08

#define POWER_ON                PORTF.OUT |= 0x01

#define POWER_OFF               PORTF.OUT &= ~(0x01)

#define SETRST                  PORTE.OUT |= 0x08

#define SETWR                   PORTB.OUT |= 0x10

#define SETRD                   PORTB.OUT |= 0x20

#define SETCSA                  PORTB.OUT |= 0x01

#define SETCSB                  PORTB.OUT |= 0x02

#define SETCSC                  PORTB.OUT |= 0x04

#define SETCSD                  PORTB.OUT |= 0x08

#define CLRRST                  PORTE.OUT &= ~(0x08)

#define CLRWR                   PORTB.OUT &= ~(0x10)

#define CLRRD                   PORTB.OUT &= ~(0x20)

#define CLRCSA                  PORTB.OUT &= ~(0x01)

#define CLRCSB                  PORTB.OUT &= ~(0x02)

#define CLRCSC                  PORTB.OUT &= ~(0x04)

#define CLRCSD                  PORTB.OUT &= ~(0x08)

///////////////////////////////////////////////////////////////////////////////

//Private vars

bool _portA_parity_set;

bool _portB_parity_set;

bool _portC_parity_set;

bool _portD_parity_set;

///////////////////////////////////////////////////////////////////////////////

//Functions

//////////////////////////////////////

//High level functions

void initPortA(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal = 0; //temp value for reading register and change it's value without clearing it

    _portA_parity_set = (parity > 0); //Parity set (even or odd) ?

    //Read register first...

    regVal = readPortA(LCR_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortA(regVal, LCR_REG); //switch Mode

    //_delay_ms(1);

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortA(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    //_delay_ms(1);

    setWait(20);

    //writePortA(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    writePortA(busSpeed, DLL_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = readPortA(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    //regVal |= dataBits > 3 ? TL16C_WORD_8BITS : wordValues[dataBits]; //set 8bits mode

    //regVal |= (stopBit > 1 ? TL16C_STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    //regVal |= (parity > 2 ? TL16C_PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    regVal |= dataBits; //set 8bits mode

    regVal |= stopBit << 2; //set stop bits

    regVal |= parity << 3; //set stop bits

    writePortA(regVal, LCR_REG);

    //_delay_ms(1);

    setWait(20);

    writePortA(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

void initPortB(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal = 0; //temp value for reading register and change it's value without clearing it

    _portB_parity_set = (parity > 0); //Parity set (even or odd) ?

    //Read register first...

    regVal = readPortB(LCR_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortB(regVal, LCR_REG); //switch Mode

    //_delay_ms(1);

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortB(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    //_delay_ms(1);

    setWait(20);

    //writePortA(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    writePortB(busSpeed, DLL_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = readPortB(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    //regVal |= dataBits > 3 ? TL16C_WORD_8BITS : wordValues[dataBits]; //set 8bits mode

    //regVal |= (stopBit > 1 ? TL16C_STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    //regVal |= (parity > 2 ? TL16C_PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    regVal |= dataBits; //set 8bits mode

    regVal |= stopBit << 2; //set stop bits

    regVal |= parity << 3; //set stop bits

    writePortB(regVal, LCR_REG);

    //_delay_ms(1);

    setWait(20);

    writePortB(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

void initPortC(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal = 0; //temp value for reading register and change it's value without clearing it

    _portC_parity_set = (parity > 0); //Parity set (even or odd) ?

    //Read register first...

    regVal = readPortC(LCR_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortC(regVal, LCR_REG); //switch Mode

    //_delay_ms(1);

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortC(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    //_delay_ms(1);

    setWait(20);

    //writePortA(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    writePortC(busSpeed, DLL_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = readPortC(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    //regVal |= dataBits > 3 ? TL16C_WORD_8BITS : wordValues[dataBits]; //set 8bits mode

    //regVal |= (stopBit > 1 ? TL16C_STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    //regVal |= (parity > 2 ? TL16C_PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    regVal |= dataBits; //set 8bits mode

    regVal |= stopBit << 2; //set stop bits

    regVal |= parity << 3; //set stop bits

    writePortC(regVal, LCR_REG);

    //_delay_ms(1);

    setWait(20);

    writePortC(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

void initPortD(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal = 0; //temp value for reading register and change it's value without clearing it

    _portD_parity_set = (parity > 0); //Parity set (even or odd) ?

    //Read register first...

    regVal = readPortD(LCR_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortD(regVal, LCR_REG); //switch Mode (and clear default cfg...)

    //_delay_ms(1);

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortD(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    //_delay_ms(1);

    setWait(20);

    //writePortA(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    writePortD(busSpeed, DLL_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = readPortD(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    //regVal |= dataBits > 3 ? TL16C_WORD_8BITS : wordValues[dataBits]; //set 8bits mode

    //regVal |= (stopBit > 1 ? TL16C_STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    //regVal |= (parity > 2 ? TL16C_PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    regVal |= dataBits; //set 8bits mode

    regVal |= stopBit << 2; //set stop bits

    regVal |= parity << 3; //set stop bits

    writePortD(regVal, LCR_REG);

    //_delay_ms(1);

    setWait(20);

    writePortD(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

//////////////////////////////////////////////

//UART send/reiceive

void txWriteA(uint8_t b)

{

    writePortA(b, THR_REG); //write to Transmit Holding (that goes into TX FIFO buffer)

}

void txWriteB(uint8_t b)

{

    writePortB(b, THR_REG); //write to Transmit Holding (that goes into TX FIFO buffer)

}

void txWriteC(uint8_t b)

{

    writePortC(b, THR_REG); //write to Transmit Holding (that goes into TX FIFO buffer)

}

void txWriteD(uint8_t b)

{

    writePortD(b, THR_REG); //write to Transmit Holding (that goes into TX FIFO buffer)

}

uint8_t rxReadA(void)

{

    return readPortA(RHR_REG); //read Receive Holding (from RX FIFO buffer)

}

uint8_t rxReadB(void)

{

    return readPortB(RHR_REG); //read Receive Holding (from RX FIFO buffer)

}

uint8_t rxReadC(void)

{

    return readPortC(RHR_REG); //read Receive Holding (from RX FIFO buffer)

}

uint8_t rxReadD(void)

{

    return readPortD(RHR_REG); //read Receive Holding (from RX FIFO buffer)

}

////////////////////////////////////////

//RX buf state functions

bool portA_available()

{

    return (readPortA(LSR_REG) & 0x01); //check if RX FIFO buffer has at least one byte available

}

bool portB_available()

{

    return (readPortB(LSR_REG) & 0x01); //check if RX FIFO buffer has at least one byte available

}

bool portC_available()

{

    return (readPortC(LSR_REG) & 0x01); //check if RX FIFO buffer has at least one byte available

}

bool portD_available()

{

    return (readPortD(LSR_REG) & 0x01); //check if RX FIFO buffer has at least one byte available

}

///////////////////////////////////////////////////////////////////////

//Parity configuration status

//get status if port has been configured with a parity into the frame

bool getParitySetA()

{

    return _portA_parity_set;

}

bool getParitySetB()

{

    return _portB_parity_set;

}

bool getParitySetC()

{

    return _portC_parity_set;

}

bool getParitySetD()

{

    return _portD_parity_set;

}

//Get parity/stopbit error status when frame received on port

bool getErrorStatusA()

{

    return ((readPortA(LSR_REG) & 0x80) == 0x80);

}

bool getErrorStatusB()

{

    return ((readPortB(LSR_REG) & 0x80) == 0x80);

}

bool getErrorStatusC()

{

    return ((readPortC(LSR_REG) & 0x80) == 0x80);

}

bool getErrorStatusD()

{

    return ((readPortD(LSR_REG) & 0x80) == 0x80);

}

///////////////////////////////////////////////////////

//write functions

void writePortA(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSA; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSA; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

void writePortB(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSB; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSB; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

void writePortC(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSC; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSC; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

void writePortD(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSD; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSD; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

///////////////////////////////////////////////////////

//read functions

uint8_t readPortA(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSA; //enable uartA call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSA; //hang up uartA call

    return result;

}

uint8_t readPortB(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSB; //enable uartB call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSB; //hang up uartB call

    return result;

}

uint8_t readPortC(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSC; //enable uartC call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSC; //hang up uartC call

    return result;

}

uint8_t readPortD(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSD; //enable uartD call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSD; //hang up uartD call

    return result;

}

///////////////////////////////////////////

//Miscellaneous functions

void setWait(uint16_t cnt)

{

    uint16_t k = 0;

    while(k < cnt)

    {

        asm("nop");

        k++;

    }

}

#endif        /* XC_HEADER_TEMPLATE_H */