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 XC_HEADER_TEMPLATE_H

#define        XC_HEADER_TEMPLATE_H

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

#include <stdbool.h>

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

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

};

RXREAD RX0, RX1, RX2, RX3, RX4;

/**

 <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(250);

        port->OUT = 0x0C;

        _delay_ms(250);

        port->OUT = 0x00;

    }

}

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

//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>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort0(uint32_t bauds, bool enableDebug)

{

    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

}

/**

 <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

{

    USART0.TXDATAL = b;

}

/**

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

{

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

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

    RX0._rxBuf[RX0.bytesAvailable] = RX0._rxReicv; //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

}

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

//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>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort1(uint32_t bauds, bool enableDebug)

{

    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

}

/**

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

}

/**

 <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

}

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

//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>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort2(uint32_t bauds, bool enableDebug)

{

    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

}

/**

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

}

/**

 <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

}

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

//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>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort3(uint32_t bauds, bool enableDebug)

{

    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

}

/**

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

}

/**

 <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

}

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

//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>Don't forget to call sei() function after called all initPortx() functions !</p></b>

 */

void initPort4(uint32_t bauds, bool enableDebug)

{

    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

}

/**

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

}

/**

 <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

}

#ifdef        __cplusplus

}

#endif /* __cplusplus */

#endif        /* XC_HEADER_TEMPLATE_H */