RS232-MUX

/*

 * File:   main.c

 * Author: eniro

 * Version : 2.0

 *

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

 */

/*

 TODO LIST :

 *  

 */

#define F_CPU 24000000UL

#include <xc.h>

#include <stdio.h>

#include <string.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"

#include "pins.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 setRAMCfg(cfgPort *cfg, uint8_t *localBuffer);

void MCOM_scanframe(uint8_t *data, uint8_t n, cfgPort *localPort);

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

void readCFG(bool EEPROM_read, cfgPort *localPort);

bool stringComp(uint8_t *str1, uint8_t *str2, uint8_t n, uint8_t m);

#define WATCHDOG_RESET      asm("WDR") //reset watchdog counter

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

//Little Keep save old configuration accessible everywhere (Not good as it is)

cfgPort OLD_CFG[4];

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

#ifdef USE_PORT_1 //USART3

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

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

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

#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

#define DEBUG_LED   0x4

int main(void) {

    cfgPort VCOM_cfg[4];

    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 mainLedCounter = 0;

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

    bool writtenStatus = false; //put write status on master port

    bool readStatus[] = {false, false, false, false, false}; // put read status on all ports

    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

    //_delay_ms(3000);

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

    setWait(20000);

    //Debug

    //char chrDebug[50];

    //sprintf(chrDebug, "%x %x %x %x %x %x %x %x\r\n", eeprom_read_byte(0),eeprom_read_byte(1),eeprom_read_byte(2),eeprom_read_byte(3),eeprom_read_byte(4),eeprom_read_byte(5),eeprom_read_byte(6),eeprom_read_byte(7));

    getEEPROMCfg(); //at first read EEPROM configuration

    readConfiguration(&VCOM_cfg[PORT_VCOMA_INDEX], PORT_VCOMA_INDEX); //Then read configuration for VCOMA

    readConfiguration(&VCOM_cfg[PORT_VCOMB_INDEX], PORT_VCOMB_INDEX); //Then read configuration for VCOMB

    readConfiguration(&VCOM_cfg[PORT_VCOMC_INDEX], PORT_VCOMC_INDEX); //Then read configuration for VCOMC

    readConfiguration(&VCOM_cfg[PORT_VCOMD_INDEX], PORT_VCOMD_INDEX); //Then read configuration for VCOMD

    //Read for old cfg (in case we want to read EEPROM...)

    readConfiguration(&OLD_CFG[PORT_VCOMA_INDEX], PORT_VCOMA_INDEX); //Then read configuration for VCOMA

    readConfiguration(&OLD_CFG[PORT_VCOMB_INDEX], PORT_VCOMB_INDEX); //Then read configuration for VCOMB

    readConfiguration(&OLD_CFG[PORT_VCOMC_INDEX], PORT_VCOMC_INDEX); //Then read configuration for VCOMC

    readConfiguration(&OLD_CFG[PORT_VCOMD_INDEX], PORT_VCOMD_INDEX); //Then read configuration for VCOMD

    //Init Virtual Ports

    initPortA(VCOM_cfg[PORT_VCOMA_INDEX].baud, VCOM_cfg[PORT_VCOMA_INDEX].dataByte, VCOM_cfg[PORT_VCOMA_INDEX].parity, VCOM_cfg[PORT_VCOMA_INDEX].stopBit);

    initPortB(VCOM_cfg[PORT_VCOMB_INDEX].baud, VCOM_cfg[PORT_VCOMB_INDEX].dataByte, VCOM_cfg[PORT_VCOMB_INDEX].parity, VCOM_cfg[PORT_VCOMB_INDEX].stopBit);

    initPortC(VCOM_cfg[PORT_VCOMC_INDEX].baud, VCOM_cfg[PORT_VCOMC_INDEX].dataByte, VCOM_cfg[PORT_VCOMC_INDEX].parity, VCOM_cfg[PORT_VCOMC_INDEX].stopBit);

    initPortD(VCOM_cfg[PORT_VCOMD_INDEX].baud, VCOM_cfg[PORT_VCOMD_INDEX].dataByte, VCOM_cfg[PORT_VCOMD_INDEX].parity, VCOM_cfg[PORT_VCOMD_INDEX].stopBit);

    //Master Port

    INIT_PORT(UART_BAUD_VALUE, F8BIT_MODE, ONE_STOPBIT, AVR32_NO_PARITY);

    //Boot led

    PORTC.DIR |= DEBUG_LED;

    SET_DEBUG_LED;

    setWait(500);

    CLR_DEBUG_LED;

    /*for(int i = 0; i < 25; i++)

    {

        TX_WRITE(chrDebug[i]);

    }*/

    timerInit(60000); //10 ms interrupt

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

    PORTA.DIR = 0x3F;

    bootSequence();

    while(1)

    {

        //WDT refresh (avoid program freeze when on crash...)

        WATCHDOG_RESET;

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

        //Read UART A

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

        {

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

            //Frame check

            VCOM_can_read[PORT_VCOMA_INDEX] = true;

            if(getParitySetA()) //if parity set

            {

                if(getErrorStatusA()) //if parity failed (or stop bit also)

                {

                    VCOM_can_read[PORT_VCOMA_INDEX] = false; 

                }

            }

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

            if(VCOM_can_read[PORT_VCOMA_INDEX]) //if we can read according to parity

            {

                readStatus[PORT_VCOMA_INDEX] = true;

                bufferA[VCOMAIndex] = rxReadA(); 

                VCOMAIndex++; 

                VCOMA_counter = 0; //for frame timeout

            }

            else //if read failed

            {

                rxReadA(); //flush serial

            }     

        }

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

        //Read UART B

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

        {

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

            //Frame check

            VCOM_can_read[PORT_VCOMB_INDEX] = true;

            if(getParitySetB()) //if parity set

            {

                if(getErrorStatusB()) //if parity failed (or stop bit also)

                {

                    VCOM_can_read[PORT_VCOMB_INDEX] = false; 

                }

            }

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

            if(VCOM_can_read[PORT_VCOMB_INDEX]) //if we can read according to parity

            {

                readStatus[PORT_VCOMB_INDEX] = true;

                bufferB[VCOMBIndex] = rxReadB();

                VCOMBIndex++; 

                //if(VCOMBIndex > 64)

                //    VCOMBIndex = 0;

                VCOMB_counter = 0; //for frame timeout  

            }

            else //if read failed

            {

                rxReadB(); //flush serial

            } 

        }

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

        //Read UART C

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

        {

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

            //Frame check

            VCOM_can_read[PORT_VCOMC_INDEX] = true;

            if(getParitySetC()) //if parity set

            {

                if(getErrorStatusC()) //if parity failed (or stop bit also)

                {

                    VCOM_can_read[PORT_VCOMC_INDEX] = false; 

                }

            }

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

            if(VCOM_can_read[PORT_VCOMC_INDEX]) //if we can read according to parity

            {

                readStatus[PORT_VCOMC_INDEX] = true;

                bufferC[VCOMCIndex] = rxReadC();

                VCOMCIndex++; 

                //if(VCOMBIndex > 64)

                //    VCOMBIndex = 0;

                VCOMC_counter = 0; //for frame timeout  

            }

            else //if read failed

            {

                rxReadC(); //flush serial

            } 

        }

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

        //Read UART D

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

        {

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

            //Frame check

            VCOM_can_read[PORT_VCOMD_INDEX] = true;

            if(getParitySetD()) //if parity set

            {

                if(getErrorStatusD()) //if parity failed (or stop bit also)

                {

                    VCOM_can_read[PORT_VCOMD_INDEX] = false; 

                }

            }

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

            if(VCOM_can_read[PORT_VCOMD_INDEX]) //if we can read according to parity

            {

                readStatus[PORT_VCOMD_INDEX] = true;

                bufferD[VCOMDIndex] = rxReadD();

                VCOMDIndex++; 

                //if(VCOMBIndex > 64)

                //    VCOMBIndex = 0;

                VCOMD_counter = 0; //for frame timeout  

            }

            else //if read failed

            {

                rxReadD(); //flush serial

            } 

        }

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

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

        }

        /*else

        {

            readStatus[PORT_MCOM_INDEX] = false; //To prevent the bug on uC (Silicon cause ?)

        }*/

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

        if(getTimerFlag())

        {

            if(mainLedCounter > 240)

            {

                SET_DEBUG_LED;

            }

            else

                CLR_DEBUG_LED;

            mainLedCounter++;

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

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

            if(masterBuffer[1] == MASTER_ID) //check if frame is destinated to the MUX232

            {

                MCOM_scanframe(masterBuffer, MCOMIndex, VCOM_cfg);

            }

            else //otherwise send it through a VCOM

            {

                VCOM_sendframe(masterBuffer, MCOMIndex);

            }

            MCOMIndex = 0; //reset index buffer

            MCOM_counter = 0; //reset counter

        }

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

        //When buf is ready from VCOMA

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

        {

            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(VCOMB_counter > SERIAL_PORT_TIMEOUT_COUNT || VCOMBIndex >= 64)

        {

            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(VCOMC_counter > SERIAL_PORT_TIMEOUT_COUNT || VCOMCIndex >= 64)

        {

            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

        }

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

        {

            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

        }

    }

    return 0;

}

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

//Functions / macros

//bool EEPROM_read -> true read from EEPROM, false -> read from RAM

//cfgPort *cfg -> configuration where values must be read

void readCFG(bool EEPROM_read, cfgPort *localPort)

{

    cfgPort *debugPort;

    const uint8_t *dispBaud[] = {"9600", "19200", "38400"}; 

    const uint8_t dispParity[] = {'N', 'E', 'O'}; //The Matrix has you...

    const uint8_t dispData[] = {'5', '6', '7', '8'};

    const uint8_t dispBit[] = {'1', '2'};

    char msg[30]; //23 characters max

    //Read EEPROM configuration or RAM ?

    //if(EEPROM_read)

    //    getEEPROMCfg();

    if(!EEPROM_read) //Read RAM CFG ?

        debugPort = &localPort[PORT_VCOMA_INDEX];

    else

        debugPort = &OLD_CFG[PORT_VCOMA_INDEX];

        //readConfiguration(debugPort, PORT_VCOMA_INDEX); //or just get CFG read from EEPROM

    //Disp CFGRead bytes and display directly CFG

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

    {

        msg[i] = 0;

    }

    sprintf(msg, "%c%c%c%cVCOMA B%s F%c%c%c\r\n", 

            STX, 

            MASTER_ID, 

            FRAME_ADDR_1, 

            FRAME_ADDR_2, 

            dispBaud[debugPort->baud], 

            dispData[debugPort->dataByte], 

            dispParity[debugPort->parity], 

            dispBit[debugPort->stopBit]

            );

    for(uint8_t i = 0; i < 22; i++)

        TX_WRITE(msg[i]); //Display string

    if(!EEPROM_read) //Read RAM CFG ?

        debugPort = &localPort[PORT_VCOMB_INDEX];

    else

        debugPort = &OLD_CFG[PORT_VCOMB_INDEX];

        //readConfiguration(debugPort, PORT_VCOMB_INDEX); //or just get CFG read from EEPROM

    //Disp CFGRead bytes and display directly CFG

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

    {

        msg[i] = 0;

    }

    sprintf(msg, "%c%c%c%cVCOMB B%s F%c%c%c\r\n", 

            STX, 

            MASTER_ID, 

            FRAME_ADDR_1, 

            FRAME_ADDR_2, 

            dispBaud[debugPort->baud], 

            dispData[debugPort->dataByte], 

            dispParity[debugPort->parity], 

            dispBit[debugPort->stopBit]

            );

    for(uint8_t i = 0; i < 22; i++)

        TX_WRITE(msg[i]); //Display string

    if(!EEPROM_read) //Read RAM CFG ?

        debugPort = &localPort[PORT_VCOMC_INDEX];

    else

        debugPort = &OLD_CFG[PORT_VCOMC_INDEX];

        //readConfiguration(debugPort, PORT_VCOMC_INDEX); //or just get CFG read from EEPROM

    //Disp CFGRead bytes and display directly CFG

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

    {

        msg[i] = 0;

    }

    sprintf(msg, "%c%c%c%cVCOMC B%s F%c%c%c\r\n", 

            STX, 

            MASTER_ID, 

            FRAME_ADDR_1, 

            FRAME_ADDR_2, 

            dispBaud[debugPort->baud],

            dispData[debugPort->dataByte], 

            dispParity[debugPort->parity], 

            dispBit[debugPort->stopBit]

            );

    for(uint8_t i = 0; i < 22; i++)

        TX_WRITE(msg[i]); //Display string

    if(!EEPROM_read) //Read RAM CFG ?

        debugPort = &localPort[PORT_VCOMD_INDEX];

    else

        debugPort = &OLD_CFG[PORT_VCOMD_INDEX];

        //readConfiguration(debugPort, PORT_VCOMD_INDEX); //or just get CFG read from EEPROM

    //Disp CFGRead bytes and display directly CFG

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

    {

        msg[i] = 0;

    }

    sprintf(msg, "%c%c%c%cVCOMD B%s F%c%c%c\r\n", 

            STX, 

            MASTER_ID, 

            FRAME_ADDR_1, 

            FRAME_ADDR_2, 

            dispBaud[debugPort->baud], 

            dispData[debugPort->dataByte], 

            dispParity[debugPort->parity], 

            dispBit[debugPort->stopBit]

            );

    for(uint8_t i = 0; i < 22; i++)

        TX_WRITE(msg[i]); //Display string

}

//Set RAM Cfg that we must apply it to the EEPROM !

//cfgPort *cfg -> configuration where values must be applied

//uint8_t *localBuffer -> frame command structured by "BxxxxxFxxxCx" (see documentation)

void setRAMCfg(cfgPort *cfg, uint8_t *localBuffer)

{

    //Set default CFG

    uint8_t localBaudsCfg = ADDR_BAUD_9600, localDataCfg = ADDR_DATA_F8; 

    uint8_t localParityCfg = ADDR_PARITY_NONE, localSBCfg = ADDR_STOP_ONE;

    uint8_t localVCOMIndex;

    uint8_t localIndex;

    uint8_t i;

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

    //VCOM CONFIGURATION

    //Be sure our first character is B (so we can estimate that frame is good enough)

    if (localBuffer[MAX232_B_STR_INDEX] == MAX232_B_STR_CHAR) 

    {

        localIndex = MAX232_B_STR_INDEX;

        i = 0;

        //Calculate number of bytes between B and F char into frame (9600 bauds or 19200/38400 bauds for example)

        while (localBuffer[localIndex] != MAX232_F_STR_CHAR) 

        {

            i++;

            localIndex++;

        }

        if (i < 6) //number of char = 4 ? ("9600")

        {

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

            //At first set bauds speed

            if (localBuffer[MAX232_B_STR_INDEX + 1] == '9' && localBuffer[MAX232_B_STR_INDEX + 2] == '6' &&

                localBuffer[MAX232_B_STR_INDEX + 3] == '0' && localBuffer[MAX232_B_STR_INDEX + 4] == '0') 

            {

                //Put CFG into 9600 bauds

                localBaudsCfg = ADDR_BAUD_9600;

            }

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

            //Set Data bits

            localDataCfg = localBuffer[MAX232_B_STR_INDEX + 6] - '5'; // Shift to 0 because ADDR_DATA_F5 = 0, ADDR_DATA_F6 = 1, ect...

            //We have already localDataCfg as ADDR_PARITY_NONE (keep aat this value if it equals to 'N')

            //localParityCfg = (localBuffer[MAX232_B_STR_INDEX + 7] == 'N') ? ADDR_PARITY_NONE : localDataCfg;

            //Does it equals to ODD ?

            localParityCfg = (localBuffer[MAX232_B_STR_INDEX + 7] == 'O') ? ADDR_PARITY_ODD : localParityCfg;

            //or EVEN ?

            localParityCfg = (localBuffer[MAX232_B_STR_INDEX + 7] == 'E') ? ADDR_PARITY_EVEN : localParityCfg;

            //Read (localBuffer[MAX232_B_STR_INDEX + 8] for stop bits -> 1/2

            localSBCfg = (localBuffer[MAX232_B_STR_INDEX + 8] == '2'); //Return condition state only...

            //Read (localBuffer[MAX232_B_STR_INDEX + 10] VCOM -> A/B/C/D

            localVCOMIndex = localBuffer[MAX232_B_STR_INDEX + 10] - CESAR_SHIFT;

        } 

        else //number of char = 5 ? ("19200"/"38400")

        {

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

            //At first set bauds speed

            if (localBuffer[MAX232_B_STR_INDEX + 1] == '1' && localBuffer[MAX232_B_STR_INDEX + 2] == '9' &&

                localBuffer[MAX232_B_STR_INDEX + 3] == '2' && localBuffer[MAX232_B_STR_INDEX + 4] == '0' &&

                localBuffer[MAX232_B_STR_INDEX + 5] == '0') 

            {

                //Put CFG into 19200 bauds

                localBaudsCfg = ADDR_BAUD_19200;

            }

            if (localBuffer[MAX232_B_STR_INDEX + 1] == '3' && localBuffer[MAX232_B_STR_INDEX + 2] == '8' &&

                localBuffer[MAX232_B_STR_INDEX + 3] == '4' && localBuffer[MAX232_B_STR_INDEX + 4] == '0' &&

                localBuffer[MAX232_B_STR_INDEX + 5] == '0') 

            {

                //Put CFG into 38400 bauds

                localBaudsCfg = ADDR_BAUD_38400;

            }

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

            //Set Data bits

            localDataCfg = localBuffer[MAX232_B_STR_INDEX + 7] - '5'; // Shift to 0 because ADDR_DATA_F5 = 0, ADDR_DATA_F6 = 1, ect...

            //We have already localDataCfg as ADDR_PARITY_NONE (keep aat this value if it equals to 'N')

            //localParityCfg = (localBuffer[MAX232_B_STR_INDEX + 7] == 'N') ? ADDR_PARITY_NONE : localDataCfg;

            //Does it equals to ODD ?

            localParityCfg = (localBuffer[MAX232_B_STR_INDEX + 8] == 'O') ? ADDR_PARITY_ODD : localParityCfg;

            //or EVEN ?

            localParityCfg = (localBuffer[MAX232_B_STR_INDEX + 8] == 'E') ? ADDR_PARITY_EVEN : localParityCfg;

            //Read (localBuffer[MAX232_B_STR_INDEX + 8] for stop bits -> 1/2

            localSBCfg = (localBuffer[MAX232_B_STR_INDEX + 9] == '2'); //Return condition state only for stop bits...

            //Read (localBuffer[MAX232_B_STR_INDEX + 10] VCOM -> A/B/C/D

            localVCOMIndex = localBuffer[MAX232_B_STR_INDEX + 11] - CESAR_SHIFT;

            //TX_WRITE('F'); TX_WRITE('D'); TX_WRITE('P'); TX_WRITE(localBuffer[MAX232_B_STR_INDEX + 9]);

            //TX_WRITE('F'); TX_WRITE('D'); TX_WRITE('P'); TX_WRITE(localBuffer[MAX232_B_STR_INDEX + 11]);

            //TX_WRITE('F'); TX_WRITE('D'); TX_WRITE('P'); TX_WRITE(localParityCfg);

        }

        //Write into RAM buffer (and prepare for EEPROM writing)

        writeConfiguration(&cfg[localVCOMIndex], localBaudsCfg, localParityCfg, localDataCfg, localSBCfg, localVCOMIndex);

    }

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

}

//Read a frame destinated to the MUX232 itself

//uint8_t *data -> frame buffer (with SOF, ADDR, ..., EOF)

//uint8_t n -> size of that buffer

//cfgPort *localPort -> configuration structure that will be read/written (depend on cmd that inside of *data)

void MCOM_scanframe(uint8_t *data, uint8_t n, cfgPort *localPort)

{

    uint8_t *localBuffer; //Calculate byte quantity of effective data

    uint8_t i;

    while(localBuffer == NULL)

    {

        localBuffer = malloc(n-6);

        setWait(5);

    }

    for(i = 0; i < n-6; i++)

        localBuffer[i] = 0;

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

                {

                    for(i = 0; i < n-6; i++) //regarder la valeur de n

                    {

                        localBuffer[i] = data[i + 4]; //Get effective data

                    }

                    //Once data was collected, analysis it

                    if(!stringComp(localBuffer, MAX232_WRITE_COMMAND, n-6, MAX232_WRITE_SIZE)) //if the command is Write configuration

                    {

                        //Save CFG into EEPROM

                        setEEPROMCfg();

                        TX_WRITE(0x2);

                        TX_WRITE(FRAME_ADDR_1);

                        TX_WRITE(FRAME_ADDR_2);

                        TX_WRITE(MASTER_ID);

                        TX_WRITE('W');TX_WRITE('R');

                        TX_WRITE('C');TX_WRITE('F');TX_WRITE('G');

                        TX_WRITE(LF_CHAR);TX_WRITE(CR_CHAR);

                        TX_WRITE(0x2);

                        TX_WRITE(FRAME_ADDR_1);

                        TX_WRITE(FRAME_ADDR_2);

                        TX_WRITE(MASTER_ID);

                        TX_WRITE('R');TX_WRITE('E');TX_WRITE('B');TX_WRITE('O');TX_WRITE('O');TX_WRITE('T');

                        TX_WRITE(LF_CHAR);TX_WRITE(CR_CHAR);

                        while(1); //Force WDT reboot

                    }

                    else if(!stringComp(localBuffer, MAX232_READ_RAM_COMMAND, n-6, MAX232_READ_RAM_SIZE)) //is this Read configuration ?

                    {

                        //Read CFG from RAM

                        readCFG(false, localPort);

                    }

                    else if(!stringComp(localBuffer, MAX232_READ_ROM_COMMAND, n-6, MAX232_READ_ROM_SIZE)) //is this Read configuration ?

                    {

                        //Read CFG from EEPROM

                        readCFG(true, localPort);

                    }

                    else //otherwise that might be set configuration

                    {

                        setRAMCfg(localPort, localBuffer);      

                        TX_WRITE(0x2);

                        TX_WRITE(FRAME_ADDR_1);

                        TX_WRITE(FRAME_ADDR_2);

                        TX_WRITE(MASTER_ID);

                        TX_WRITE('S');TX_WRITE('E');TX_WRITE('T');

                        TX_WRITE('C');TX_WRITE('F');TX_WRITE('G');

                        TX_WRITE(LF_CHAR);TX_WRITE(CR_CHAR);

                    }

                }

            }

        }

    }

}

//Send a frame from virtual port to master port

//uint8_t *data -> data buffer read from device

//uint8_t n -> size of that buffer

//uint8_t port tell which port that come from (0~3)

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

//uint8_t *data -> frame buffer (with SOF, ADDR, ..., EOF)

//uint8_t n -> size of that buffer

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

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

    //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]);

                    }

                }

            }

        }

    }

}

/**

 void bootSequence(void)

 Display boot message and launch test led sequence

 */

void bootSequence(void)

{

    TX_WRITE(STX);

    TX_WRITE(MASTER_ID);TX_WRITE(FRAME_ADDR_1);TX_WRITE(FRAME_ADDR_1);

    TX_WRITE('B');TX_WRITE('O');TX_WRITE('O');TX_WRITE('T');

    TX_WRITE(LF_CHAR);TX_WRITE(CR_CHAR);

    debugLedsTest();

}

/**

 void debugLedsTest(void)

 Debug leds test sequence

 */

void debugLedsTest(void)

{

    //All leds are on PORTA -> Bit shifting is adviced

    PORTA.OUT = 1;

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

    {

        PORTA.OUT <<= 1;

        _delay_ms(250);

    }

    PORTA.OUT = 0;

}

/**

 void senseDebugLeds(void)

 ->Call this to update leds status

 * bool *hasWritten -> put written status of write led

 * bool *hasWritten -> put read status of read leds port

 */

void senseDebugLeds(bool *hasWritten, bool *hasRead)

{

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

    //Check Master Port

    if(*hasWritten)

    {

        SET_MASTER_WR_LED;

        *hasWritten = false;

    }

    else

        CLR_MASTER_WR_LED;

    if(hasRead[PORT_MCOM_INDEX])

    {

        SET_MASTER_RD_LED;

        hasRead[PORT_MCOM_INDEX] = false;

    }

    else

        CLR_MASTER_RD_LED;

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

    //Check VCOMA

    if(hasRead[PORT_VCOMA_INDEX])

    {

        SET_VCOMA_RD_LED;

        hasRead[PORT_VCOMA_INDEX] = false;

    }

    else

        CLR_VCOMA_RD_LED;

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

    //Check VCOMB

    if(hasRead[PORT_VCOMB_INDEX])

    {

        SET_VCOMB_RD_LED;

        hasRead[PORT_VCOMB_INDEX] = false;

    }

    else

        CLR_VCOMB_RD_LED;

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

    //Check VCOMC

    if(hasRead[PORT_VCOMC_INDEX])

    {

        SET_VCOMC_RD_LED;

        hasRead[PORT_VCOMC_INDEX] = false;

    }

    else

        CLR_VCOMC_RD_LED;

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

    //Check VCOMD

    if(hasRead[PORT_VCOMD_INDEX])

    {

        SET_VCOMD_RD_LED;

        hasRead[PORT_VCOMD_INDEX] = false;

    }

    else

        CLR_VCOMD_RD_LED;

}

//String comparator (better version...)

//uint8_t *str1 -> First string to compare

//uint8_t *str2 -> Second string to compare

//uint8_t n -> Size of first string

//uint8_t m -> Size of second string

bool stringComp(uint8_t *str1, uint8_t *str2, uint8_t n, uint8_t m)

{

    bool result = false;

    if(n == m)