RS232-MUX

/*

 * File:   main.c

 * Author: eniro

 * Version : 0.9

 *

 * Created on March 25, 2024, 3:51 PM

 */

/*

 TODO LIST :

 * 

 * 

 * Remap all pins !!!

 * 

 * Select UART1 as master port

 * 

 * Rename VCOMA/2/3/4 as VCOMA/B/C/D ?

 */

#define F_CPU 24000000UL

#include <xc.h>

#include <math.h>

#include <stdlib.h>

#include <util/delay.h>

#include <avr/interrupt.h>

#include <avr/eeprom.h>

#include "hardware_uart.h"

#include "hardware_timer.h"

#include "hardware_TL16C754C.h"

#include "hardware_config.h"

#include "frame_definitions.h"

#include "parameters.h"

//USART setup

//To calculate BAUD value register -> BAUD = 64*FCLK/(16*FBAUDS)

#define UART_BAUD_VALUE     833 // 10000 is equivalent as 9600 bauds (on 24MHz clock) according to datasheet

#define USART0_REG          0x3 

#define BOOT_MSG            "RS232-MUX\r\n"

//OSC. setup

#define FREQSEL     0x9

#define _FREQSEL_REG_WR     ((FREQSEL) << 2)

#define _USART0_REG_WR      (USART0_REG & 0x7)

enum portIndex {

    PORT_VCOMA_INDEX = 0,

    PORT_VCOMB_INDEX,

    PORT_VCOMC_INDEX,

    PORT_VCOMD_INDEX,

    PORT_MCOM_INDEX,

};

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

//Prototypes

void bootSequence(void);

void MCOM_sendframe(uint8_t *data, uint8_t n, uint8_t port);

void VCOM_sendframe(uint8_t *data, uint8_t n);

void senseDebugLeds(bool *hasWritten, bool *hasRead);

uint8_t getPriority(uint8_t chosen_com, uint8_t *ports_list, uint8_t n);

//reset watchdog counter

#define WATCHDOG_RESET      asm("WDR")

uint8_t global_debugBuffer[256];

uint8_t global_n = 0;

uint8_t global_parity;

#ifdef USE_PORT_1

#define INIT_PORT(w,x,y,z)               initPort1(w,x,y,z)

#define TX_WRITE(x)                     txWrite1(x)

#define RX_READ                         rxRead1()

#define PORT_AVAILABLE                  portAvailable1()

#else

#ifdef USE_PORT_2

#define INIT_PORT(w,x,y,z)               initPort2(w,x,y,z)

#define TX_WRITE(x)                     txWrite2(x)

#define RX_READ                         rxRead2()

#define PORT_AVAILABLE                  portAvailable2()

#else

#ifdef USE_PORT_3

#define INIT_PORT(w,x,y,z)               initPort3(w,x,y,z)

#define TX_WRITE(x)                     txWrite3(x)

#define RX_READ                         rxRead3()

#define PORT_AVAILABLE                  portAvailable3()

#else

#ifdef USE_PORT_4

#define INIT_PORT(w,x,y,z)               initPort4(w,x,y,z)

#define TX_WRITE(x)                     txWrite4(x)

#define RX_READ                         rxRead4()

#define PORT_AVAILABLE                  portAvailable4()

#else

#error "Please choose an uart port..."

#endif

#endif

#endif

#endif

int main(void) {

    uint8_t ctrlReg;

    uint8_t masterBuffer[64], bufferA[64], bufferB[64], bufferC[64], bufferD[64];

    uint8_t VCOMAIndex = 0, VCOMBIndex = 0, VCOMCIndex = 0, VCOMDIndex = 0, MCOMIndex;

    uint16_t MCOM_counter = 0;

    uint16_t VCOMA_counter = 0;

    uint16_t VCOMB_counter = 0;

    uint16_t VCOMC_counter = 0;

    uint16_t VCOMD_counter = 0;

    uint8_t debug;

    bool writtenStatus = false;

    bool readStatus[] = {false, false, false, false, false};

    //local timer counter for local process (blink led, ect...)

    uint8_t vcom_priority[] = {0, 0, 0, 0}; //VCOM priority to send on master port

    uint8_t vcom_choose = PORT_VCOMA_INDEX;

    setWait(5000);

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

    {

        bufferA[i] = 0;

    }

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

    {

        bufferB[i] = 0;

    }

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

    {

        bufferC[i] = 0;

    }

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

    {

        bufferD[i] = 0;

    }

    _PROTECTED_WRITE(CLKCTRL.OSCHFCTRLA, _FREQSEL_REG_WR); //switch to 24 MHz

    //Enable pins (Port direction)

    ADDR_ENABLE;        //Address pins

    ENABLE_WR_RD_PINS;  //Read and Write pins

    ENABLE_CS_PINS;     //Chip select pins

    ENABLE_RESET_PIN;   //Reset pin

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

    //Remember to put high level on cs pins to disable devices...

    SETCSA;

    SETCSB;

    SETCSC;

    SETCSD;

    //Also don't forget IOR and IOW

    SETWR;

    SETRD;

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

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

    //init TL16C IC

    SETRST; 

    //_delay_ms(10);

    setWait(100);

    CLRRST;

    setWait(5);

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

    //Init virtual COM ports

    //TODO : Set EEPROM CFG here

    initPortA(DL_9600_BAUDS, F8BIT_MODE, TL16C_NO_PARITY, ONE_STOPBIT);

    initPortB(DL_9600_BAUDS, F8BIT_MODE, TL16C_NO_PARITY, ONE_STOPBIT);

    initPortC(DL_9600_BAUDS, F8BIT_MODE, TL16C_NO_PARITY, ONE_STOPBIT);

    initPortD(DL_9600_BAUDS, F8BIT_MODE, TL16C_NO_PARITY, ONE_STOPBIT);

    //Master Port

    INIT_PORT(UART_BAUD_VALUE, F8BIT_MODE, ONE_STOPBIT, AVR32_NO_PARITY);

    setWait(500);

    ctrlReg = 0;

    timerInit(60000); //10 ms interrupt

    sei(); //never forget to enable global interrupt mask !

    PORTA.DIR = 0x3F;

    while(1)

    {

        if(vcom_choose > 3)

        {

                asm("nop");

                asm("nop");

                asm("nop");

                asm("nop");

        }

        debug++;

        if(debug == 0x07)

            asm("nop");

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

        //Read UART A

        if(portA_available()) //Check if one byte available

        {

            readStatus[PORT_VCOMA_INDEX] = true;

            bufferA[VCOMAIndex] = rxReadA(); 

            VCOMAIndex++; 

            //if(VCOMAIndex > 64)

            //    VCOMAIndex = 0;

            VCOMA_counter = 0; //for frame timeout

        }

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

        //Read UART B

        if(portB_available()) //Check if one byte available

        {

            readStatus[PORT_VCOMB_INDEX] = true;

            bufferB[VCOMBIndex] = rxReadB();

            VCOMBIndex++; 

            //if(VCOMBIndex > 64)

            //    VCOMBIndex = 0;

            VCOMB_counter = 0; //for frame timeout  

        }

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

        //Read UART C

        if(portC_available()) //Check if one byte available

        {

            readStatus[PORT_VCOMC_INDEX] = true;

            bufferC[VCOMCIndex] = rxReadC();

            VCOMCIndex++; 

            //if(VCOMCIndex > 64)

            //    VCOMCIndex = 0;

            VCOMC_counter = 0; //for frame timeout 

        }

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

        //Read UART D

        if(portD_available()) //Check if one byte available

        {

            readStatus[PORT_VCOMD_INDEX] = true;

            bufferD[VCOMDIndex] = rxReadD();

            VCOMDIndex++; 

            //if(VCOMDIndex > 64)

            //    VCOMDIndex = 0;

            VCOMD_counter = 0; //for frame timeout

        }

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

        //Read UART Master

        if(PORT_AVAILABLE > 0) //check if we have bytes to read

        {

            readStatus[PORT_MCOM_INDEX] = true;

            masterBuffer[MCOMIndex] = RX_READ; //store byte into buffer

            MCOMIndex++; //increment to next byte

            //if(MCOMIndex > 64)

            //    MCOMIndex = 0;

            MCOM_counter = 0; //refresh timeout counter

        }

        //Timed process (for leds, etc...)

        if(getTimerFlag())

        {

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

            //Timeout process

            //For master port

            if(MCOMIndex > 0)

                MCOM_counter++;

            //For virtual port 1

            if(VCOMAIndex > 0)

                VCOMA_counter++;

            //For virtual port 2

            if(VCOMBIndex > 0)

                VCOMB_counter++;

            //For virtual port 3

            if(VCOMCIndex > 0)

                VCOMC_counter++;

            //For virtual port 4

            if(VCOMDIndex > 0)

                VCOMD_counter++;

            senseDebugLeds(&writtenStatus, readStatus);

            clearTimerFlag();

        }

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

        //When buf is ready from master

        if(MCOM_counter > SERIAL_PORT_TIMEOUT_COUNT || MCOMIndex >= 64)

        {         

            //Send buffer to VCOM

            VCOM_sendframe(masterBuffer, MCOMIndex);

            MCOMIndex = 0; //reset index buffer

            MCOM_counter = 0; //reset counter

        }

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

        //When buf is ready from VCOMA

        if(vcom_choose == PORT_VCOMA_INDEX)

        {

            if(VCOMA_counter > SERIAL_PORT_TIMEOUT_COUNT || VCOMAIndex >= 64)

            {

                vcom_choose = getPriority(vcom_choose, vcom_priority, MAX_VCOM_PORTS); //Calculate next port to send

                if(vcom_choose > 3)

                {

                    asm("nop");

                    asm("nop");

                    asm("nop");

                    asm("nop");

                }

                writtenStatus = true;//Say a wrote has been made

                //Send buffer to VCOM

                MCOM_sendframe(bufferA, VCOMAIndex, PORT_VCOMA_INDEX);

                VCOMAIndex = 0; //reset index buffer

                VCOMA_counter = 0; //reset counter

            }

        }

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

        //When buf is ready from VCOMB

        if(vcom_choose == PORT_VCOMB_INDEX)

        {

            if(VCOMB_counter > SERIAL_PORT_TIMEOUT_COUNT || VCOMBIndex >= 64)

            {

                vcom_choose = getPriority(vcom_choose, vcom_priority, MAX_VCOM_PORTS); //Calculate next port to send

                if(vcom_choose > 3)

                {

                    asm("nop");

                    asm("nop");

                    asm("nop");

                    asm("nop");

                }

                writtenStatus = true;//Say a wrote has been made

                //Send buffer to VCOM

                MCOM_sendframe(bufferB, VCOMBIndex, PORT_VCOMB_INDEX);

                VCOMBIndex = 0; //reset index buffer

                VCOMB_counter = 0; //reset counter

            }

        }

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

        //When buf is ready from VCOMC

        if(vcom_choose == PORT_VCOMC_INDEX)

        {

            if(VCOMC_counter > SERIAL_PORT_TIMEOUT_COUNT || VCOMCIndex >= 64)

            {

                vcom_choose = getPriority(vcom_choose, vcom_priority, MAX_VCOM_PORTS); //Calculate next port to send

                if(vcom_choose > 3)

                {

                    asm("nop");

                    asm("nop");

                    asm("nop");

                    asm("nop");

                }

                writtenStatus = true;//Say a wrote has been made

                //Send buffer to VCOM

                MCOM_sendframe(bufferC, VCOMCIndex, PORT_VCOMC_INDEX);

                VCOMCIndex = 0; //reset index buffer

                VCOMC_counter = 0; //reset counter

            }

        }

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

        //When buf is ready from VCOMD

        if(vcom_choose == PORT_VCOMD_INDEX)

        {

            if(VCOMD_counter > SERIAL_PORT_TIMEOUT_COUNT || VCOMDIndex >= 64)

            {

                vcom_choose = getPriority(vcom_choose, vcom_priority, MAX_VCOM_PORTS); //Calculate next port to send

                if(vcom_choose > 3)

                {

                    asm("nop");

                    asm("nop");

                    asm("nop");

                    asm("nop");

                }

                writtenStatus = true; //Say a wrote has been made

                //Send buffer to VCOM

                MCOM_sendframe(bufferD, VCOMDIndex, PORT_VCOMD_INDEX);

                VCOMDIndex = 0; //reset index buffer

                VCOMD_counter = 0; //reset counter

            }

        }

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

        //Priority check

        //Check if buffer is empty, then put port at lowest priority !

        if(VCOMAIndex == 0) //no buffer ?

        {

            vcom_priority[PORT_VCOMA_INDEX] = 0; //no priority

        }

        if(VCOMBIndex == 0) //no buffer ?

        {

            vcom_priority[PORT_VCOMB_INDEX] = 0; //no priority

        }

        if(VCOMCIndex == 0) //no buffer ?

        {

            vcom_priority[PORT_VCOMC_INDEX] = 0; //no priority

        }

        if(VCOMDIndex == 0) //no buffer ?

        {

            vcom_priority[PORT_VCOMD_INDEX] = 0; //no priority

        }

    }

    return 0;

}

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

//Functions / macros

//Send a frame from virtual port to master port

void MCOM_sendframe(uint8_t *data, uint8_t n, uint8_t port)

{

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

    //Send frame

    TX_WRITE(0x02); //STX

    TX_WRITE(port + CESAR_SHIFT); //Which virtual port called master port ?

    TX_WRITE(FRAME_ADDR_1); //ADDR

    TX_WRITE(FRAME_ADDR_2); //ADDR

    for(uint8_t i = 0; i < n; i++) //DATA

        TX_WRITE(data[i]);

    TX_WRITE(LF_CHAR); //End of frame

    TX_WRITE(CR_CHAR); //End of frame

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

}

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

//Send a frame from master port to virtual port (that calculate whose port to send ?)

void VCOM_sendframe(uint8_t *data, uint8_t n)

{

    uint16_t addrFunctions[] = {&txWriteA, &txWriteB, &txWriteC, &txWriteD }; //list of available functions addresses

    void (*localTxWrite)(); //function pointer

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

    //To debugger read section

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

        global_debugBuffer[i] = data[i];

    if(global_n == 0x02)

    {

        asm("nop");

    }

    if(global_debugBuffer[1] == 0x03)

    {

        asm("nop");

    }

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

    //At first, check if first byte is the start of text

    if(data[0] == STX)

    {

        if(data[2] == FRAME_ADDR_1 && data[3] == FRAME_ADDR_2) //check if we have the MUX address identifier

        {    

            if(data[n-1] == CR_CHAR) //check the end of text (second byte)

            {

                if(data[n-2] == LF_CHAR) //check the end of text (first byte)

                {

                    data[1]-=CESAR_SHIFT; //convert port index to buffer equivalent

                    localTxWrite = addrFunctions[(data[1] < 3) ? data[1] : 3 ]; //data[3]

                    for(int i = 4; i < n-2; i++) //send frame without (STX + FRAME_ADDR_B1 + FRAME_ADDR_B2 + LF_CHAR + CR_CHAR)

                    {

                        localTxWrite(data[i]);

                    }

                }

            }

        }

    }

}

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

//Get VCOM port priority to avoid filling hardware buffer and lost data...

uint8_t getPriority(uint8_t chosen_com, uint8_t *ports_list, uint8_t n)

{

    uint8_t i = 0; //a little bit useful for timing

    for(i = 0; i < n; i++) //at first increment priority

        ports_list[i]++;

    ports_list[chosen_com] = 0; //reset priority on this port

    chosen_com = 0; //load first port

    for(i = 1; i < n; i++) //calculate priority

    {

        if(ports_list[i] > ports_list[chosen_com]) //priority level larger than actual port ?

            chosen_com = i; //then choose this port

    }

    return chosen_com; //port result according to priority

}

void bootSequence(void)

{

    debugLedsTest();

}

/**

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

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

 */

void debugLedsTest(void)

{

    PORTA.OUT = 1;

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

    {

        PORTA.OUT <<= 1;

        _delay_ms(125);

    }

    PORTA.OUT = 0;

}

/**

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

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

 */

void senseDebugLeds(bool *hasWritten, bool *hasRead)

{

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

    //Check Master Port

    if(*hasWritten)

    {

        PORTA.OUT |= 0x20;

        *hasWritten = false;

    }

    else

        PORTA.OUT &= ~(0x20);

    if(hasRead[PORT_MCOM_INDEX])

    {

        PORTA.OUT |= 0x10;

        hasRead[PORT_MCOM_INDEX] = false;

    }

    else

        PORTA.OUT &= ~(0x10);

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

    //Check VCOMA

    if(hasRead[PORT_VCOMA_INDEX])

    {

        PORTA.OUT |= 0x01;

        hasRead[PORT_VCOMA_INDEX] = false;

    }

    else

        PORTA.OUT &= ~(0x01);

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

    //Check VCOMB

    if(hasRead[PORT_VCOMB_INDEX])

    {

        PORTA.OUT |= 0x02;

        hasRead[PORT_VCOMB_INDEX] = false;

    }

    else

        PORTA.OUT &= ~(0x02);

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

    //Check VCOMC

    if(hasRead[PORT_VCOMC_INDEX])

    {

        PORTA.OUT |= 0x04;

        hasRead[PORT_VCOMC_INDEX] = false;

    }

    else

        PORTA.OUT &= ~(0x04);

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

    //Check VCOMD

    if(hasRead[PORT_VCOMD_INDEX])

    {

        PORTA.OUT |= 0x08;

        hasRead[PORT_VCOMD_INDEX] = false;

    }

    else

        PORTA.OUT &= ~(0x08);

}