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 

 */

/*

 TODO list:

 * Put TXDATAH in write when F9BIT mode enabled ?

 */

#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

//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 */

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

//prototypes

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

void txWrite0(uint8_t b); //write one byte

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

uint8_t portAvailable0(void);

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

void txWrite1(uint8_t b); //write one byte

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

uint8_t portAvailable1(void);

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

void txWrite2(uint8_t b); //write one byte

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

uint8_t portAvailable2(void);

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

void txWrite3(uint8_t b); //write one byte

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

uint8_t portAvailable3(void);

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

void txWrite4(uint8_t b); //write one byte

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

uint8_t portAvailable4(void);

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

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

//Global Vars

typedef struct RXREAD RXREAD;

struct RXREAD

{

    uint8_t _rxReicv; // temp byte

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

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

    uint8_t _tempBytes;

};

//RX structure for reading buffers from serial ports

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

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

//Functions

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

//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, 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 = 0x80; //enable 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;

    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

{    

    if(_RX0.bytesAvailable > 0)

        _RX0.bytesAvailable--;

    return _RX0._rxBuf[_RX0.bytesAvailable];

    //_hasRead[USART0_INDEX] = true;

    //return USART0.RXDATAL;

}

/**

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

 */

uint8_t portAvailable0(void)

{

    return _RX0.bytesAvailable;

    //return ((USART0.RXDATAH & 0x80) >> 7);

}

ISR(USART0_RXC_vect)

{

    //USART0.CTRLA = 0x80;

    //_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

}

/*ISR(USART0_DRE_vect)

{

    _RX0.bytesAvailable = _RX0._tempBytes;

    USART0.CTRLA = 0x80; //Clear DRE interrupt

    _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, 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

    */

    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

{

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

    USART3.TXDATAL = b;

    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

{

    if(_RX1.bytesAvailable > 0)

        _RX1.bytesAvailable--;

    return _RX1._rxBuf[_RX1.bytesAvailable];

    /*_hasRead[USART3_INDEX] = true;

    return USART3.RXDATAL;*/

}

/**

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

 */

uint8_t portAvailable1(void)

{

    return _RX1.bytesAvailable;

    //return ((USART3.STATUS & 0x80) >> 7);

}

ISR(USART3_RXC_vect)

{

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

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

    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

}

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

//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, 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

    */

    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

{

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

    USART1.TXDATAL = b;

    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

{

    if(_RX2.bytesAvailable > 0)

        _RX2.bytesAvailable--;

    return _RX2._rxBuf[_RX2.bytesAvailable];

    /*_hasRead[USART1_INDEX] = true;

    return USART1.RXDATAL;*/

}

/**

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

 */

uint8_t portAvailable2(void)

{

    return _RX2.bytesAvailable;

}

ISR(USART1_RXC_vect)

{

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

    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

}

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

//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, 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

    */

    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

{

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

    USART4.TXDATAL = b;

    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

{

    if(_RX3.bytesAvailable > 0)

        _RX3.bytesAvailable--;

    return _RX3._rxBuf[_RX3.bytesAvailable];

    /*_hasRead[USART4_INDEX] = true;

    return USART4.RXDATAL;*/

}

/**

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

 */

uint8_t portAvailable3(void)

{

    return _RX3.bytesAvailable;

}

ISR(USART4_RXC_vect)

{

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

    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

}

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

//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, 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

    */

    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

{

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

    USART2.TXDATAL = b;

    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

{

    if(_RX4.bytesAvailable > 0)

        _RX4.bytesAvailable--;

    return _RX4._rxBuf[_RX4.bytesAvailable];

    /*_hasRead[USART2_INDEX] = true;

    return USART2.RXDATAL;*/

}

/**

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

 */

uint8_t portAvailable4(void)

{

    return _RX4.bytesAvailable;

}

ISR(USART2_RXC_vect)

{

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

    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

}

#ifdef        __cplusplus

}

#endif /* __cplusplus */

#endif        /* XC_HEADER_TEMPLATE_H */