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.9

 */

#ifndef RS232_HARDWARETL16_H

#define        RS232_HARDWARETL16_H

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

#include "hardware_config.h"

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

//Bytes array

uint8_t _TL16C_invertAddr[] = {

    0x00, 0x04, 0x02, 0x06, 0x01, 0x05, 0x03, 0x07

};

uint8_t _TL16C_invertData[] = {

    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,

    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,

    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,

    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,

    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,

    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,

    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,

    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,

    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,

    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,

    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,

    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,

    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,

    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,

    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,

    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,

    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,

    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,

    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,

    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,

    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,

    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,

    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,

    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,

    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,

    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,

    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,

    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,

    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,

    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,

    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,

    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,

};

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

//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 = _TL16C_invertData[x]

#define DATADIR(x)          PORTD.DIR = _TL16C_invertData[x]

#define DATAREAD            _TL16C_invertData[PORTD.IN]

//Address pins

#define ADDRWRITE(x)        PORTE.OUT = _TL16C_invertAddr[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)

{

    uint16_t speedCfg[] = { DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS };

    uint8_t parityCfg[] = { TL16C_NO_PARITY, TL16C_EVEN_PARITY, TL16C_ODD_PARITY };

    uint8_t dataCfg[] = { F5BIT_MODE, F6BIT_MODE, F7BIT_MODE, F8BIT_MODE };

    uint8_t stopCfg[] = { ONE_STOPBIT, TWO_STOPBITS };

    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(speedCfg[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 |= dataCfg[dataBits]; //set 8bits mode

    regVal |= stopCfg[stopBit] << 2; //set stop bits

    regVal |= parityCfg[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)

{

    uint16_t speedCfg[] = { DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS };

    uint8_t parityCfg[] = { TL16C_NO_PARITY, TL16C_EVEN_PARITY, TL16C_ODD_PARITY };

    uint8_t dataCfg[] = { F5BIT_MODE, F6BIT_MODE, F7BIT_MODE, F8BIT_MODE };

    uint8_t stopCfg[] = { ONE_STOPBIT, TWO_STOPBITS };

    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(speedCfg[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 |= dataCfg[dataBits]; //set 8bits mode

    regVal |= stopCfg[stopBit] << 2; //set stop bits

    regVal |= parityCfg[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)

{

    uint16_t speedCfg[] = { DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS };

    uint8_t parityCfg[] = { TL16C_NO_PARITY, TL16C_EVEN_PARITY, TL16C_ODD_PARITY };

    uint8_t dataCfg[] = { F5BIT_MODE, F6BIT_MODE, F7BIT_MODE, F8BIT_MODE };

    uint8_t stopCfg[] = { ONE_STOPBIT, TWO_STOPBITS };

    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(speedCfg[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 |= dataCfg[dataBits]; //set 8bits mode

    regVal |= stopCfg[stopBit] << 2; //set stop bits

    regVal |= parityCfg[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)

{

    uint16_t speedCfg[] = { DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS };

    uint8_t parityCfg[] = { TL16C_NO_PARITY, TL16C_EVEN_PARITY, TL16C_ODD_PARITY };

    uint8_t dataCfg[] = { F5BIT_MODE, F6BIT_MODE, F7BIT_MODE, F8BIT_MODE };

    uint8_t stopCfg[] = { ONE_STOPBIT, TWO_STOPBITS };

    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(speedCfg[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 |= dataCfg[dataBits]; //set 8bits mode

    regVal |= stopCfg[stopBit] << 2; //set stop bits

    regVal |= parityCfg[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 = DATAREAD; //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 = DATAREAD; //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 = DATAREAD; //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 = DATAREAD; //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 */