RS232-MUX

/*

 * File:   main.c

 * Author: eniro

 *

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

 */

#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 "frame_definitions.h"

//USART setup

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

#define UART_BAUD_VALUE     833 // 10000 is equivalent as 9600 bauds 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)

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

//Prototypes

void bootSequence(void);

//reset watchdog counter

#define WATCHDOG_RESET      asm("WDR")

uint8_t global_debugBuffer[256];

uint8_t global_n = 0;

int main(void) {

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

    //Local variables

    const char *boot_msg = BOOT_MSG;

    cfgPort cfgVCOM1, cfgVCOM2, cfgVCOM3, cfgVCOM4;

    uint8_t ledsCfg;

    //Output buffer

    uint8_t MCOMBuf[256], VCOM1Buf[256], VCOM2Buf[256], VCOM3Buf[256], VCOM4Buf[256];

    //Output buffer index 

    uint8_t MCOMIndex = 0, VCOM1Index = 0, VCOM2Index = 0, VCOM3Index = 0, VCOM4Index = 0;

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

    uint32_t timerCnt = 0;

    //local timer for counting how many cycles passed since we've got activity on serial port ?

    uint32_t serialTimer = 0;

    //Counter to make a timeout if all data has passed

    uint8_t MCOM_counter = 0;

    uint8_t VCOM1_counter = 0;

    uint8_t VCOM2_counter = 0;

    uint8_t VCOM3_counter = 0;

    uint8_t VCOM4_counter = 0;

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

    {

        MCOMBuf[i] = 0;

        VCOM1Buf[i] = 0;

        VCOM2Buf[i] = 0;

        VCOM3Buf[i] = 0;

        VCOM4Buf[i] = 0;

    }

    PORTD.DIR = 0x01; // DEBUG LED

    //PORTMUX.USARTROUTEA = _USART0_REG_WR; //set TX and RX on PD4 and PD5 pins

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

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

    //Prepare VCOM configuration

    //At first read EEPROM !

    getEEPROMCfg(); //Get serial port configuration

    ledsCfg = getDebugLedsConfiguration(); //get debug leds configuration

    //And then, read configuration for each port...

    readConfiguration(&cfgVCOM1, 0);

    readConfiguration(&cfgVCOM2, 1);

    readConfiguration(&cfgVCOM3, 2);

    readConfiguration(&cfgVCOM4, 3);

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

    //Interrupt & serial port setup

    //Set port with debug leds

    initPort0(UART_BAUD_VALUE, (ledsCfg & 0x1), F8BIT_MODE, ONE_STOPBIT, NO_PARITY); //init master port with debug leds

    initPort1(cfgVCOM1.baud, (ledsCfg & 0x2) >> 1, cfgVCOM1.dataByte, cfgVCOM1.stopBit, cfgVCOM1.parity); //init vcom1 port with debug leds

    initPort2(cfgVCOM2.baud, (ledsCfg & 0x4) >> 2, cfgVCOM2.dataByte, cfgVCOM2.stopBit, cfgVCOM2.parity); //init vcom2 port with debug leds

    initPort3(cfgVCOM3.baud, (ledsCfg & 0x8) >> 3, cfgVCOM3.dataByte, cfgVCOM3.stopBit, cfgVCOM3.parity); //init vcom3 port with debug leds

    initPort4(cfgVCOM4.baud, (ledsCfg & 0x16) >> 4, cfgVCOM4.dataByte, cfgVCOM4.stopBit, cfgVCOM4.parity); //init vcom4 port  with debug leds     

    //Timer init

    //Setup for interrupt every 25ms

    timerInterruptInit(0x2EE0);

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

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

    //Debug led on boot sequence

    WATCHDOG_RESET; //reset WD counter

    bootSequence(); //Launch leds sequence

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

    {

        txWrite0(boot_msg[i]);

    }

    while(1)

    {

        WATCHDOG_RESET; //Always call this to prevent undesired boot...

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

        if(portAvailable0() > 0)

        {

            MCOMBuf[MCOMIndex] = rxRead0(); //store byte into buffer

            MCOMIndex++; //increment to next byte

            MCOM_counter = 0; //refresh timeout counter

        }

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

        {

            VCOM1Buf[VCOM1Index] = rxRead1(); //store byte into buffer

            VCOM1Index++; //increment to next byte

            VCOM1_counter = 0; //refresh timeout counter

        }

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

        {

            VCOM2Buf[VCOM2Index] = rxRead2(); //store byte into buffer

            VCOM2Index++; //increment to next byte

            VCOM2_counter = 0; //refresh timeout counter

        }

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

        {

            VCOM3Buf[VCOM3Index] = rxRead3(); //store byte into buffer

            VCOM3Index++; //increment to next byte

            VCOM3_counter = 0; //refresh timeout counter

        }

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

        {

            VCOM4Buf[VCOM4Index] = rxRead4(); //store byte into buffer

            VCOM4Index++; //increment to next byte

            VCOM4_counter = 0; //refresh timeout counter

        }

        //if timeout

        if(MCOM_counter > 10)

        {

            MCOM_sendframe(MCOMBuf, MCOMIndex);

            //Clear the buffer

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

            {

                MCOMBuf[i] = 0;

            }

            MCOMIndex = 0;

            MCOM_counter = 0;

        }

        //NOTE : Not sure that stuff will be useful...

        //Just in case if bytes does not match, clear counter

        if(MCOMIndex >= 255)

            MCOMIndex = 0;

        if(VCOM1Index >= 255)

            VCOM1Index = 0;

        if(VCOM2Index >= 255)

            VCOM2Index = 0;

        if(VCOM3Index >= 255)

            VCOM3Index = 0;

        if(VCOM4Index >= 255)

            VCOM4Index = 0;

        //Refresh led status

        if(abs(getTimerCounts() - timerCnt) >= 25)

        {

            senseDebugLeds();

            timerCnt = getTimerCounts();

        }

        //count

        if(abs(getTimerCounts() - serialTimer) >= 1)

        {

            //prevent incrementing counter if no bytes available...

            if(MCOMIndex > 0)

                MCOM_counter++;

            VCOM1_counter++;

            VCOM2_counter++;

            VCOM3_counter++;

            VCOM4_counter++;

            serialTimer = getTimerCounts();

        }

    }

    return 0;

}

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

//Functions / macros

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

void MCOM_sendframe(uint8_t *data, uint8_t n)

{

    uint16_t addrFunctions[] = {&txWrite1, &txWrite2, &txWrite3, &txWrite4 }; //list of available functions addresses

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

    global_n = n;

    //To read buffer with debugger

    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)

                {

                    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)

{

    debugLedsTest();

}