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_uart.h

 * Author: Enzo Niro

 * Comments: Library made for RS232 MUX board

 * Revision history: V1.0 

 */

#ifndef RS232_HARDWAREUART_H

#define        RS232_HARDWAREUART_H

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

#include <stdbool.h>

#include <avr/interrupt.h>

#include <avr/eeprom.h>

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

//Definitions

//Values registers

#define F5BIT_MODE           0x00

#define F6BIT_MODE           0x01

#define F7BIT_MODE           0x02

#define F8BIT_MODE           0x03

#define F9LBIT_MODE          0x06

#define F9HBIT_MODE          0x07

#define NO_PARITY           0x00

#define EVEN_PARITY         0x02

#define ODD_PARITY          0x03

#define ONE_STOPBIT         0x00

#define TWO_STOPBITS        0x01

//EEPROM addresses

#define ADDR_BAUD_2400           0x0

#define ADDR_BAUD_4800           0x1

#define ADDR_BAUD_9600           0x2

#define ADDR_BAUD_19200          0x3

#define ADDR_BAUD_38400          0x4

#define ADDR_BAUD_57600          0x5

#define ADDR_BAUD_115200         0x6

#define ADDR_PARITY_NONE         0x0

#define ADDR_PARITY_EVEN         0x1

#define ADDR_PARITY_ODD          0x2

#define ADDR_DATA_F5             0x0

#define ADDR_DATA_F6             0x1

#define ADDR_DATA_F7             0x2

#define ADDR_DATA_F8             0x3

#define ADDR_DATA_F9L            0x4

#define ADDR_DATA_F9H            0x5

#define ADDR_STOP_ONE            0x0

#define ADDR_STOP_TWO            0x1

#define DEFAULT_ADDR_BAUD        ADDR_BAUD_9600

#define DEFAULT_ADDR_PARITY      ADDR_PARITY_NONE

#define DEFAULT_ADDR_DATA        ADDR_DATA_F8

#define DEFAULT_ADDR_STOP        ADDR_STOP_ONE

#define DEFAULT_VALUE_DEBUG_LED  0x1F

#define EEPROM_DEBUG_LED_ADDR   0x8

//According to AVR32DA48 pins

#define USART0_PORT_PINS    0x01

#define USART0_DEBUG_LED    0x0C

#define USART1_PORT_PINS    0x01

#define USART1_DEBUG_LED    0x0C

#define USART2_PORT_PINS    0x01

#define USART2_DEBUG_LED    0x0C

#define USART3_PORT_PINS    0x01

#define USART3_DEBUG_LED    0x0C

#define USART4_PORT_PINS    0x01

#define USART4_DEBUG_LED    0x0C

//Port index for debug leds

#define USART0_INDEX    0

#define USART1_INDEX    1

#define USART2_INDEX    2

#define USART3_INDEX    3

#define USART4_INDEX    4

#ifdef        __cplusplus

extern "C" {

#endif /* __cplusplus */

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

//Global Vars

typedef struct RXREAD RXREAD;

struct RXREAD

{

    uint8_t _rxReicv; // temp byte

    uint8_t _rxBuf[256]; //back end serial buffer

    uint16_t bytesAvailable; //show if bytes available...

};

typedef struct eepromPort eepromPort;

struct eepromPort

{

    uint8_t regA; // register A for speed and parity configuration

    uint8_t regB; // register B for Data structure and stop bits

};

typedef struct cfgPort cfgPort;

struct cfgPort

{

    uint16_t baud; // Port speed

    uint8_t parity; // Parity for frame structure

    uint8_t dataByte; // Data byte structure

    uint8_t stopBit; // Stop bits for frame structure

    uint8_t debugLed;

};

//EEPROM data structure (for reading registers)

eepromPort eepromVCOM[4], eepromDebugLeds;

//RX structure for reading buffers from serial ports

volatile RXREAD _RX0, _RX1, _RX2, _RX3, _RX4;

volatile bool _hasWritten[] = {false, false, false, false, false};

volatile bool _hasRead[] = {false, false, false, false, false};

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

//Functions

/**

 <p><b>void getEEPROMCfg(void)</b></p>

 <p><b>Read eeprom values stored for all serial ports</b></p>

 */

void getEEPROMCfg(void)

{

    uint8_t i = 0, j = 0;

    while(j < 8)

    {

        //Read at first bytes

        eepromVCOM[i].regA = eeprom_read_byte(j);

        eepromVCOM[i].regB = eeprom_read_byte(j+1);

        //Then check if writing default values is necessary

        if(eepromVCOM[i].regA == 0xFF)

        {

            eepromVCOM[i].regA = (DEFAULT_ADDR_BAUD << 4) | (DEFAULT_ADDR_PARITY);

            eeprom_write_byte(j, (DEFAULT_ADDR_BAUD << 4) | (DEFAULT_ADDR_PARITY));

        }

        if(eepromVCOM[i].regB == 0xFF)

        {

            eepromVCOM[i].regB = (DEFAULT_ADDR_DATA << 4) | (DEFAULT_ADDR_STOP);

            eeprom_write_byte(j+1, (DEFAULT_ADDR_DATA << 4) | (DEFAULT_ADDR_STOP));

        }

        i++;

        j+=2;

    }

    //And finally, check debug leds value

    eepromDebugLeds.regA = eeprom_read_byte(EEPROM_DEBUG_LED_ADDR);

    if(eepromDebugLeds.regA == 0xFF)

    {

        eepromDebugLeds.regA = DEFAULT_VALUE_DEBUG_LED;

        eeprom_write_byte(EEPROM_DEBUG_LED_ADDR, DEFAULT_VALUE_DEBUG_LED);

    }

}

/**

 <p><b>uint8_t getDebugLedsConfiguration(void)</b></p>

 <p><b>Get leds configuration for debug (TX/RX) of each serial port</b></p>

 <p><b>             Return : uint8_t -> state of each leds [VCOM4 VCOM3 VCOM2 VCOM1 MCOM]</b></p>

 */

uint8_t getDebugLedsConfiguration(void)

{

    return eepromDebugLeds.regA;

}

/**

 <p><b>void readConfiguration(cfgPort *cfg, uint8_t n)</b></p>

 <p><b>Get configuration with eeprom read values</b></p>

 <p><b>             cfgPort -> Serial port configuration</b></p>

 <p><b>             n -> Serial port to configure</b></p>

 */

void readConfiguration(cfgPort *cfg, uint8_t n)

{

    //BAUD value register for these frequencies in this order :

    //2400, 4800, 9600, 19200, 38400, 57600, 115200

    uint16_t speedCfg[] = { 40000, 20000, 10000, 5000, 2500, 1667, 833 };

    uint8_t parityCfg[] = { NO_PARITY, EVEN_PARITY, ODD_PARITY };

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

    uint8_t stopCfg[] = { ONE_STOPBIT, TWO_STOPBITS };

    cfg->baud = speedCfg[(eepromVCOM[n].regA >> 4)];

    cfg->parity = parityCfg[(eepromVCOM[n].regA & 0xF)];

    cfg->dataByte = dataCfg[(eepromVCOM[n].regB >> 4)];

    cfg->stopBit = stopCfg[(eepromVCOM[n].regB & 0xF)];

}

/**

 <p><b>void debugLedsTest(void)</b></p>

 <p><b>Debug leds test sequence</b></p>

 */

void debugLedsTest(void)

{

    PORT_t *port;

    uint16_t addrPorts[] = {&PORTA, &PORTB, &PORTC, &PORTE, &PORTF };

    for(int i = 0; i < 5; i++)

    {

        port = addrPorts[i];

        port->OUT = 0x04;

        _delay_ms(125);

        port->OUT = 0x0C;

        _delay_ms(125);

        port->OUT = 0x00;

    }

}

/**

 <p><b>void senseDebugLeds(void)</b></p>

 <p><b>Call this to update leds status</b></p>

 */

void senseDebugLeds(void)

{

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

    //Check Master Port

    if(_hasWritten[USART0_INDEX])

    {

        PORTA.OUT |= 0x04;

        _hasWritten[USART0_INDEX] = false;

    }

    else

        PORTA.OUT &= 0xFB;

    if(_hasRead[USART0_INDEX])

    {

        PORTA.OUT |= 0x08;

        _hasRead[USART0_INDEX] = false;

    }

    else

        PORTA.OUT &= 0xF7;

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

    //Check VCOM1

    if(_hasWritten[USART3_INDEX])

    {

        PORTC.OUT |= 0x04;

        _hasWritten[USART3_INDEX] = false;

    }

    else

        PORTC.OUT &= 0xFB;

    if(_hasRead[USART3_INDEX])

    {

        PORTC.OUT |= 0x08;

        _hasRead[USART3_INDEX] = false;

    }

    else

        PORTC.OUT &= 0xF7;

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

    //Check VCOM2

    if(_hasWritten[USART1_INDEX])

    {

        PORTF.OUT |= 0x04;

        _hasWritten[USART1_INDEX] = false;

    }

    else

        PORTF.OUT &= 0xFB;

    if(_hasRead[USART1_INDEX])

    {

        PORTF.OUT |= 0x08;

        _hasRead[USART1_INDEX] = false;

    }

    else

        PORTF.OUT &= 0xF7;

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

    //Check VCOM3

    if(_hasWritten[USART4_INDEX])

    {

        PORTB.OUT |= 0x04;

        _hasWritten[USART4_INDEX] = false;

    }

    else

    {

        PORTB.OUT &= 0xFB;

    }

    if(_hasRead[USART4_INDEX])

    {

        PORTB.OUT |= 0x08;

        _hasRead[USART4_INDEX] = false;

    }

    else

        PORTB.OUT &= 0xF7;

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

    //Check VCOM4

    if(_hasWritten[USART2_INDEX])

    {

        PORTE.OUT |= 0x04;

        _hasWritten[USART2_INDEX] = false;

    }

    else

        PORTE.OUT &= 0xFB;

    if(_hasRead[USART2_INDEX])

    {

        PORTE.OUT |= 0x08;

        _hasRead[USART2_INDEX] = false;

    }

    else

        PORTE.OUT &= 0xF7;

}

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

//For Master port (USART0)

/**

 <p><b>void initPort0(uint32_t bauds)</b></p>

 <p><b>Init MASTER PORT</b></p>

 <p><b>Parameters : uint8_t bauds -> Set bauds speed</b></p>

 <p><b>             bool enableDebug -> Enable debug leds</b></p>

 <p><b>             uint8_t chSize -> Data bits</b></p>

 <p><b>             uint8_t stopBit -> How many stop bits</b></p>

 <p><b>             uint8_t parity -> Parity type (ODD, EVEN, DISABLED)</b></p>

 <p><b>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort0(uint32_t bauds, bool enableDebug, uint8_t chSize, bool stopBit, uint8_t parity)

{

    if(enableDebug)

        PORTA.DIR = USART0_PORT_PINS | USART0_DEBUG_LED; //Set TX/RX IO and RX/TX debug leds for USART0

    else

        PORTA.DIR = USART0_PORT_PINS; //Set TX/RX IO

    USART0.BAUD = bauds; 

    USART0.CTRLA = 0x00; //disable RX complete interrupt

    USART0.CTRLB = 0xD0; //Enable TX and RX sending

    USART0.CTRLC = (parity << 4) | (stopBit << 3) | chSize;

}

/**

 <p><b>void txWrite0(uint8_t b)</b></p>

 <p><b>Write a byte throught MASTER PORT</b></p>

 <p><b>Parameters : uint8_t b -> Byte to write</b></p>

 */

void txWrite0(uint8_t b) //write one byte

{

    while((USART0.STATUS & 0x20) != 0x20);

    USART0.TXDATAL = b;

    _hasWritten[USART0_INDEX] = true;

    while((USART0.STATUS & 0x40) != 0x40); //check when we transmit all the bits

    USART0.STATUS = 0x40; //clear the flag for next transmission

}

/**

 <p><b>uint8_t rxRead0(void)</b></p>

 <p><b>Read a byte from MASTER PORT</b></p>

 <p><b>Return : uint8_t result -> Byte to read</b></p>

 */

uint8_t rxRead0(void) //Read one byte from buffer

{

    uint8_t result = _RX0._rxBuf[0]; //get byte in order (FIFO)

    for(uint8_t j = 0; j < 255; j++) //shift bytes

    {

        _RX0._rxBuf[j] = _RX0._rxBuf[j+1];

    }

    if(_RX0.bytesAvailable > 0)

        _RX0.bytesAvailable--; //remove 1 byte

    return result;

}

/**

 <p><b>uint16_t portAvailable0(void)</b></p>

 <p><b>Get number of bytes available into the MASTER PORT's buffer</b></p>

 <p><b>Return : uint16_t bytesAvailable -> Number of bytes</b></p>

 */

uint16_t portAvailable0(void)

{

    return _RX0.bytesAvailable;

}

ISR(USART0_RXC_vect)

{

    //_RX0._rxReicv = USART0.RXDATAL; //read buffer

    _RX0._rxBuf[_RX0.bytesAvailable] = USART0.RXDATAL; //Add one byte to the buffer

    //_RX0._rxReicv = 0x00; //clear value

    if(_RX0.bytesAvailable < 255) //ensure not to overflow buffer size...

        _RX0.bytesAvailable++; //a new byte is available into the buffer

        //PORTA.OUT ^= 0x3; //debug led

    _hasRead[USART0_INDEX] = true;

}

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

//For Virtual port 1 (USART3)

/**

 <p><b>void initPort1(uint32_t bauds)</b></p>

 <p><b>Init MASTER PORT</b></p>

 <p><b>Parameters : uint8_t bauds -> Set bauds speed</b></p>

 <p><b>             bool enableDebug -> Enable debug leds</b></p>

 <p><b>             uint8_t chSize -> Data bits</b></p>

 <p><b>             uint8_t stopBit -> How many stop bits</b></p>

 <p><b>             uint8_t parity -> Parity type (ODD, EVEN, DISABLED)</b></p>

 <p><b>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort1(uint32_t bauds, bool enableDebug, uint8_t chSize, bool stopBit, uint8_t parity)

{

    if(enableDebug)

        PORTB.DIR = USART3_PORT_PINS | USART3_DEBUG_LED; //Set TX/RX IO and RX/TX debug leds for USART0

    else

        PORTB.DIR = USART3_PORT_PINS; //Set TX/RX IO

    USART3.BAUD = bauds; 

    USART3.CTRLA = 0x80; //enable RX complete interrupt

    USART3.CTRLB = 0xD0; //Enable TX and RX sending

    USART3.CTRLC = (parity << 4) | (stopBit << 3) | chSize; //set serial port cfg

}

/**

 <p><b>void txWrite1(uint8_t b)</b></p>

 <p><b>Write a byte throught VCOM1</b></p>

 <p><b>Parameters : uint8_t b -> Byte to write</b></p>

 */

void txWrite1(uint8_t b) //Write one byte

{

    USART3.TXDATAL = b;

    _hasWritten[USART3_INDEX] = true;

    while((USART3.STATUS & 0x40) != 0x40); //check when we transmit all the bits

    USART3.STATUS = 0x40; //clear the flag for next transmission

}

/**

 <p><b>uint8_t rxRead1(void)</b></p>

 <p><b>Read a byte from VCOM1</b></p>

 <p><b>Return : uint8_t result -> Byte to read</b></p>

 */

uint8_t rxRead1(void) //Read one byte from buffer

{

    uint8_t result = _RX1._rxBuf[0]; //get byte in order (FIFO)

    for(uint8_t j = 0; j < 255; j++) //shift bytes

    {

        _RX1._rxBuf[j] = _RX1._rxBuf[j+1];

    }

    if(_RX1.bytesAvailable > 0)

        _RX1.bytesAvailable--; //remove 1 byte

    return result;

}

/**

 <p><b>uint16_t portAvailable1(void)</b></p>

 <p><b>Get number of bytes available into the VCOM1 PORT's buffer</b></p>

 <p><b>Return : uint16_t bytesAvailable -> Number of bytes</b></p>

 */

uint16_t portAvailable1(void)

{

    return _RX1.bytesAvailable;

}

ISR(USART3_RXC_vect)

{

    //while((USART0.RXDATAH & 0x80) == 0x80);

    _RX1._rxReicv = USART3.RXDATAL; //read buffer

    _RX1._rxBuf[_RX1.bytesAvailable] = _RX1._rxReicv; //Add one byte to the buffer

    _RX1._rxReicv = 0x00; //clear value

    if(_RX1.bytesAvailable < 255) //ensure not to overflow buffer size...

        _RX1.bytesAvailable++; //a new byte is available into the buffer

        //PORTA.OUT ^= 0x3; //debug led

    _hasRead[USART3_INDEX] = true;

}

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

//For Virtual port 2 (USART1)

/**

 <p><b>void initPort2(uint32_t bauds)</b></p>

 <p><b>Init MASTER PORT</b></p>

 <p><b>Parameters : uint8_t bauds -> Set bauds speed</b></p>

 <p><b>             bool enableDebug -> Enable debug leds</b></p>

 <p><b>             uint8_t chSize -> Data bits</b></p>

 <p><b>             uint8_t stopBit -> How many stop bits</b></p>

 <p><b>             uint8_t parity -> Parity type (ODD, EVEN, DISABLED)</b></p>

 <p><b>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort2(uint32_t bauds, bool enableDebug, uint8_t chSize, bool stopBit, uint8_t parity)

{

    if(enableDebug)

        PORTC.DIR = USART1_PORT_PINS | USART1_DEBUG_LED; //Set TX/RX IO and RX/TX debug leds for USART0

    else

        PORTC.DIR = USART1_PORT_PINS; //Set TX/RX IO

    USART1.BAUD = bauds; 

    USART1.CTRLA = 0x80; //enable RX complete interrupt

    USART1.CTRLB = 0xD0; //Enable TX and RX sending

    USART1.CTRLC = (parity << 4) | (stopBit << 3) | chSize; //set serial port cfg

}

/**

 <p><b>void txWrite2(uint8_t b)</b></p>

 <p><b>Write a byte throught VCOM2</b></p>

 <p><b>Parameters : uint8_t b -> Byte to write</b></p>

 */

void txWrite2(uint8_t b) //Virtual Port 2

{

    USART1.TXDATAL = b;

    _hasWritten[USART1_INDEX] = true;

    while((USART1.STATUS & 0x40) != 0x40); //check when we transmit all the bits

    USART1.STATUS = 0x40; //clear the flag for next transmission

}

/**

 <p><b>uint8_t rxRead2(void)</b></p>

 <p><b>Read a byte from VCOM2</b></p>

 <p><b>Return : uint8_t result -> Byte to read</b></p>

 */

uint8_t rxRead2(void) //Read one byte from buffer

{

    uint8_t result = _RX2._rxBuf[0]; //get byte in order (FIFO)

    for(uint8_t j = 0; j < 255; j++) //shift bytes

    {

        _RX2._rxBuf[j] = _RX2._rxBuf[j+1];

    }

    if(_RX2.bytesAvailable > 0)

        _RX2.bytesAvailable--; //remove 1 byte

    return result;

}

/**

 <p><b>uint16_t portAvailable2(void)</b></p>

 <p><b>Get number of bytes available into the VCOM2 PORT's buffer</b></p>

 <p><b>Return : uint16_t bytesAvailable -> Number of bytes</b></p>

 */

uint16_t portAvailable2(void)

{

    return _RX2.bytesAvailable;

}

ISR(USART1_RXC_vect)

{

    //while((USART0.RXDATAH & 0x80) == 0x80);

    _RX2._rxReicv = USART1.RXDATAL; //read buffer

    _RX2._rxBuf[_RX2.bytesAvailable] = _RX2._rxReicv; //Add one byte to the buffer

    _RX2._rxReicv = 0x00; //clear value

    if(_RX2.bytesAvailable < 255) //ensure not to overflow buffer size...

        _RX2.bytesAvailable++; //a new byte is available into the buffer

        //PORTA.OUT ^= 0x3; //debug led

    _hasRead[USART1_INDEX] = true;

}

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

//For Virtual port 3 (USART4)

/**

 <p><b>void initPort3(uint32_t bauds)</b></p>

 <p><b>Init MASTER PORT</b></p>

 <p><b>Parameters : uint8_t bauds -> Set bauds speed</b></p>

 <p><b>             bool enableDebug -> Enable debug leds</b></p>

 <p><b>             uint8_t chSize -> Data bits</b></p>

 <p><b>             uint8_t stopBit -> How many stop bits</b></p>

 <p><b>             uint8_t parity -> Parity type (ODD, EVEN, DISABLED)</b></p>

 <p><b>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort3(uint32_t bauds, bool enableDebug, uint8_t chSize, bool stopBit, uint8_t parity)

{

    if(enableDebug)

        PORTE.DIR = USART4_PORT_PINS | USART4_DEBUG_LED; //Set TX/RX IO and RX/TX debug leds for USART0

    else

        PORTE.DIR = USART4_PORT_PINS; //Set TX/RX IO

    USART4.BAUD = bauds; 

    USART4.CTRLA = 0x80; //enable RX complete interrupt

    USART4.CTRLB = 0xD0; //Enable TX and RX sending

    USART4.CTRLC = (parity << 4) | (stopBit << 3) | chSize; //set serial port cfg

}

/**

 <p><b>void txWrite3(uint8_t b)</b></p>

 <p><b>Write a byte throught VCOM3</b></p>

 <p><b>Parameters : uint8_t b -> Byte to write</b></p>

 */

void txWrite3(uint8_t b) //Write one byte

{

    USART4.TXDATAL = b;

    _hasWritten[USART4_INDEX] = true;

    while((USART4.STATUS & 0x40) != 0x40); //check when we transmit all the bits

    USART4.STATUS = 0x40; //clear the flag for next transmission

}

/**

 <p><b>uint8_t rxRead3(void)</b></p>

 <p><b>Read a byte from VCOM3</b></p>

 <p><b>Return : uint8_t result -> Byte to read</b></p>

 */

uint8_t rxRead3(void) //Read one byte from buffer

{

    uint8_t result = _RX3._rxBuf[0]; //get byte in order (FIFO)

    for(uint8_t j = 0; j < 255; j++) //shift bytes

    {

        _RX3._rxBuf[j] = _RX3._rxBuf[j+1];

    }

    if(_RX3.bytesAvailable > 0)

        _RX3.bytesAvailable--; //remove 1 byte

    return result;

}

/**

 <p><b>uint16_t portAvailable3(void)</b></p>

 <p><b>Get number of bytes available into the VCOM3 PORT's buffer</b></p>

 <p><b>Return : uint16_t bytesAvailable -> Number of bytes</b></p>

 */

uint16_t portAvailable3(void)

{

    return _RX3.bytesAvailable;

}

ISR(USART4_RXC_vect)

{

    //while((USART0.RXDATAH & 0x80) == 0x80);

    _RX3._rxReicv = USART4.RXDATAL; //read buffer

    _RX3._rxBuf[_RX3.bytesAvailable] = _RX3._rxReicv; //Add one byte to the buffer

    _RX3._rxReicv = 0x00; //clear value

    if(_RX3.bytesAvailable < 255) //ensure not to overflow buffer size...

        _RX3.bytesAvailable++; //a new byte is available into the buffer

        //PORTA.OUT ^= 0x3; //debug led

    _hasRead[USART4_INDEX] = true;

}

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

//For Virtual port 4 (USART2)

/**

 <p><b>void initPort4(uint32_t bauds)</b></p>

 <p><b>Init MASTER PORT</b></p>

 <p><b>Parameters : uint8_t bauds -> Set bauds speed</b></p>

 <p><b>             bool enableDebug -> Enable debug leds</b></p>

 <p><b>             uint8_t chSize -> Data bits</b></p>

 <p><b>             uint8_t stopBit -> How many stop bits</b></p>

 <p><b>             uint8_t parity -> Parity type (ODD, EVEN, DISABLED)</b></p>

 <p><b>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort4(uint32_t bauds, bool enableDebug, uint8_t chSize, bool stopBit, uint8_t parity)

{

    if(enableDebug)

        PORTF.DIR = USART2_PORT_PINS | USART2_DEBUG_LED; //Set TX/RX IO and RX/TX debug leds for USART0

    else

        PORTF.DIR = USART2_PORT_PINS; //Set TX/RX IO

    USART2.BAUD = bauds; 

    USART2.CTRLA = 0x80; //enable RX complete interrupt

    USART2.CTRLB = 0xD0; //Enable TX and RX sending

    USART2.CTRLC = (parity << 4) | (stopBit << 3) | chSize; //set serial port cfg

}

/**

 <p><b>void txWrite4(uint8_t b)</b></p>

 <p><b>Write a byte throught VCOM4</b></p>

 <p><b>Parameters : uint8_t b -> Byte to write</b></p>

 */

void txWrite4(uint8_t b) //Virtual Port 4

{

    USART2.TXDATAL = b;

    _hasWritten[USART2_INDEX] = true;

    while((USART2.STATUS & 0x40) != 0x40); //check when we transmit all the bits

    USART2.STATUS = 0x40; //clear the flag for next transmission

}

/**

 <p><b>uint8_t rxRead4(void)</b></p>

 <p><b>Read a byte from VCOM4</b></p>

 <p><b>Return : uint8_t result -> Byte to read</b></p>

 */

uint8_t rxRead4(void) //Read one byte from buffer

{

    uint8_t result = _RX4._rxBuf[0]; //get byte in order (FIFO)

    for(uint8_t j = 0; j < 255; j++) //shift bytes

    {

        _RX4._rxBuf[j] = _RX4._rxBuf[j+1];

    }

    if(_RX4.bytesAvailable > 0)

        _RX4.bytesAvailable--; //remove 1 byte

    return result;

}

/**

 <p><b>uint16_t portAvailable4(void)</b></p>

 <p><b>Get number of bytes available into the VCOM4 PORT's buffer</b></p>

 <p><b>Return : uint16_t bytesAvailable -> Number of bytes</b></p>

 */

uint16_t portAvailable4(void)

{

    return _RX4.bytesAvailable;

}

ISR(USART2_RXC_vect)

{

    //while((USART0.RXDATAH & 0x80) == 0x80);

    _RX4._rxReicv = USART2.RXDATAL; //read buffer

    _RX4._rxBuf[_RX4.bytesAvailable] = _RX4._rxReicv; //Add one byte to the buffer

    _RX4._rxReicv = 0x00; //clear value

    if(_RX4.bytesAvailable < 255) //ensure not to overflow buffer size...

        _RX4.bytesAvailable++; //a new byte is available into the buffer

        //PORTA.OUT ^= 0x3; //debug led

    _hasRead[USART2_INDEX] = true;

}

#ifdef        __cplusplus

}

#endif /* __cplusplus */

#endif        /* XC_HEADER_TEMPLATE_H */