RS232-MUX

/*

 * File:   newmain.c

 * Author: eniro

 *

 * Created on May 27, 2024, 3:32 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 "macros_def.h"

#include "TL16C_addr.h"

#include "TL16C_CFG.h"

//OSC. setup

#define FREQSEL             0x7   //16MHz

#define _FREQSEL_REG_WR     ((FREQSEL) << 2)

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

//prototypes functions

void initUartA(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void initUartB(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void initUartC(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void initUartD(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit);

void writePortA(uint8_t reg, uint8_t addr);

void writePortB(uint8_t reg, uint8_t addr);

void writePortC(uint8_t reg, uint8_t addr);

void writePortD(uint8_t reg, uint8_t addr);

uint8_t readPortA(uint8_t addr);

uint8_t readPortB(uint8_t addr);

uint8_t readPortC(uint8_t addr);

uint8_t readPortD(uint8_t addr);

void initExtClock(uint8_t prescaler, uint16_t cnt); //set an external clock on PA0

void setWait(uint16_t cnt); //fast delay

uint8_t DLL_DEBUG, DLH_DEBUG, LCR_DEBUG;

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

int main(void) {

    uint8_t ctrlReg;

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

    uint8_t counterA = 0, counterB = 0, counterC = 0, counterD = 0;

    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

    //initExtClock(DIV1, 0x0000); //Set clock out with prescaler

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

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

    /*ENABLE_POW_SUPPLY_PIN;

    POWER_OFF;

    _delay_ms(500);

    POWER_ON;

    _delay_ms(500);*/

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

    //init TL16C IC

    SETRST; 

    //_delay_ms(10);

    setWait(100);

    CLRRST;

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

    asm("nop"); //wait a little bit for reset sequence back on boot

    //uint16_t wordTemp;

    /*uint8_t regVal; //temp value for reading register and change it's value without clearing it

    regVal = readPortA(LCR_REG); 

    writePortA(0x9D, LCR_REG); //set LCR[7] = 1 -> enable divisor latch mode

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    //wordTemp = busSpeed >> 8;

    writePortA(0, DLH_REG); //Always 0x00 in our cfg... 

    LCR_DEBUG = readPortA(DLH_REG);

    writePortA(104, DLL_REG); //Set speed... 

    LCR_DEBUG = readPortA(DLL_REG);

    _delay_ms(1);

    writePortA(3, LCR_REG); 

    LCR_DEBUG = readPortA(LCR_REG);

    _delay_ms(1);

    writePortA(0x01, FCR_REG); //enable FIFO

    _delay_ms(250); //wait a bit

    */

    initUartA(BAUDS_19200, DATA_8BITS, NO_PARITY, ONE_STOPBIT);

    initUartB(BAUDS_19200, DATA_8BITS, NO_PARITY, ONE_STOPBIT);

    initUartC(BAUDS_19200, DATA_8BITS, NO_PARITY, ONE_STOPBIT);

    initUartD(BAUDS_19200, DATA_8BITS, NO_PARITY, ONE_STOPBIT);

    //ctrlReg = readPortA(LSR_REG);

    //ctrlReg = readPortA(RHR_REG);

    /*ctrlReg = readPortB(LSR_REG);

    ctrlReg = readPortB(RHR_REG);

    ctrlReg = readPortC(LSR_REG);

    ctrlReg = readPortC(RHR_REG);

    ctrlReg = readPortD(LSR_REG);

    ctrlReg = readPortD(RHR_REG);*/

    //_delay_ms(1000);

    setWait(500);

    ctrlReg = 0;

    while(1)

    {

        //Tx send

        /*writePortA(0x42, THR_REG);

        writePortA(0x55, THR_REG);

        writePortA(0x43, THR_REG);

        writePortA(0x60, THR_REG);

        writePortA(0x97, THR_REG);

        writePortA(0x54, THR_REG);

        writePortA(0x26, THR_REG);

        writePortA(0x08, THR_REG);*/

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

        //Read UART A

        ctrlReg = readPortA(LSR_REG);

        if((ctrlReg & 0x01) == 0x01) //Check if one byte available

        {

            bufferA[counterA] = readPortA(RHR_REG); 

            counterA++; 

            if(counterA >= 64)

                counterA = 0;

            if(bufferA[counterA] == 0xF8)

                asm("nop");

            ctrlReg = 0;

        }

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

        //Read UART B

        ctrlReg = readPortB(LSR_REG);

        if((ctrlReg & 0x01) == 0x01) //Check if one byte available

        {

            bufferB[counterB] = readPortB(RHR_REG); 

            counterB++; 

            if(counterB >= 64)

                counterB = 0;

            if(bufferB[counterB] == 0xF8)

                asm("nop");

            ctrlReg = 0;

        }

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

        //Read UART C

        ctrlReg = readPortC(LSR_REG);

        if((ctrlReg & 0x01) == 0x01) //Check if one byte available

        {

            bufferC[counterC] = readPortC(RHR_REG); 

            counterC++; 

            if(counterC >= 64)

                counterC = 0;

            if(bufferC[counterC] == 0xF8)

                asm("nop");

            ctrlReg = 0;

        }

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

        //Read UART D

        ctrlReg = readPortD(LSR_REG);

        if((ctrlReg & 0x01) == 0x01) //Check if one byte available

        {

            bufferD[counterD] = readPortD(RHR_REG); 

            counterD++; 

            if(counterD >= 64)

                counterD = 0;

            if(bufferD[counterD] == 0xF8)

                asm("nop");

            ctrlReg = 0;

        }

        if(LCR_DEBUG == 0x00)

        asm("nop");

        if(DLL_DEBUG == 0x00)

            asm("nop");

        if(DLH_DEBUG == 0x00)

            asm("nop");

        setWait(10);

        //_delay_ms(1);

    }

    return 0;

}

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

//functions

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

//High level functions

void initUartA(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal; //temp value for reading register and change it's value without clearing it

    //void (*callFuncWR)();

    //uint8_t (*callFuncRD)();

    //uint16_t addrWriteFunc[] = {&writePortA, &writePortB, &writePortC, &writePortD};

    //uint16_t addrReadFunc[] = {&readPortA, &readPortB, &readPortC, &readPortD};

    uint8_t wordValues[] = {DATA_5BITS, DATA_6BITS, DATA_7BITS, DATA_8BITS};

    uint8_t baudsValues[] = {DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS};

    uint8_t parityValues[] = {PARITY_NONE, PARITY_ODD, PARITY_EVEN};

    uint8_t stopBitValues[] = {STOPBIT_ONE, STOPBIT_TWO};

    //callFuncWR = uart_type > 3 ? writePortD : addrWriteFunc[uart_type];

    //callFuncRD = uart_type > 3 ? writePortD : addrReadFunc[uart_type];

    //Read register first...

    regVal = readPortA(LCR_REG);

    //_delay_ms(1);

    setWait(20);

    regVal |= DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortA(regVal, LCR_REG); //switch Mode

    //_delay_ms(1);

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortA(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    //_delay_ms(1);

    setWait(20);

    writePortA(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    //_delay_ms(1);

    setWait(20);

    regVal = readPortA(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    regVal |= dataBits > 3 ? DATA_8BITS : wordValues[dataBits]; //set 8bits mode

    regVal |= (stopBit > 1 ? STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    regVal |= (parity > 2 ? PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    writePortA(regVal, LCR_REG);

    //_delay_ms(1);

    setWait(20);

    writePortA(0x01, FCR_REG); //enable FIFO

    //_delay_ms(250); //wait a bit

    setWait(20);

}

void initUartB(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal; //temp value for reading register and change it's value without clearing it

    //void (*callFuncWR)();

    //uint8_t (*callFuncRD)();

    //uint16_t addrWriteFunc[] = {&writePortA, &writePortB, &writePortC, &writePortD};

    //uint16_t addrReadFunc[] = {&readPortA, &readPortB, &readPortC, &readPortD};

    uint8_t wordValues[] = {DATA_5BITS, DATA_6BITS, DATA_7BITS, DATA_8BITS};

    uint8_t baudsValues[] = {DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS};

    uint8_t parityValues[] = {PARITY_NONE, PARITY_ODD, PARITY_EVEN};

    uint8_t stopBitValues[] = {STOPBIT_ONE, STOPBIT_TWO};

    //callFuncWR = uart_type > 3 ? writePortD : addrWriteFunc[uart_type];

    //callFuncRD = uart_type > 3 ? writePortD : addrReadFunc[uart_type];

    //Read register first...

    regVal = readPortB(LCR_REG);

    setWait(20);

    regVal |= DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortB(regVal, LCR_REG); //switch Mode

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortB(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    setWait(20);

    writePortB(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    setWait(20);

    regVal = readPortB(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    regVal |= dataBits > 3 ? DATA_8BITS : wordValues[dataBits]; //set 8bits mode

    regVal |= (stopBit > 1 ? STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    regVal |= (parity > 2 ? PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    writePortB(regVal, LCR_REG);

    setWait(20);

    writePortB(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

void initUartC(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal; //temp value for reading register and change it's value without clearing it

    //void (*callFuncWR)();

    //uint8_t (*callFuncRD)();

    //uint16_t addrWriteFunc[] = {&writePortA, &writePortB, &writePortC, &writePortD};

    //uint16_t addrReadFunc[] = {&readPortA, &readPortB, &readPortC, &readPortD};

    uint8_t wordValues[] = {DATA_5BITS, DATA_6BITS, DATA_7BITS, DATA_8BITS};

    uint8_t baudsValues[] = {DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS};

    uint8_t parityValues[] = {PARITY_NONE, PARITY_ODD, PARITY_EVEN};

    uint8_t stopBitValues[] = {STOPBIT_ONE, STOPBIT_TWO};

    //callFuncWR = uart_type > 3 ? writePortD : addrWriteFunc[uart_type];

    //callFuncRD = uart_type > 3 ? writePortD : addrReadFunc[uart_type];

    //Read register first...

    regVal = readPortC(LCR_REG);

    setWait(20);

    regVal |= DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortC(regVal, LCR_REG); //switch Mode

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortC(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    setWait(20);

    writePortC(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    setWait(20);

    regVal = readPortC(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    regVal |= dataBits > 3 ? DATA_8BITS : wordValues[dataBits]; //set 8bits mode

    regVal |= (stopBit > 1 ? STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    regVal |= (parity > 2 ? PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    writePortC(regVal, LCR_REG);

    setWait(20);

    writePortC(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

void initUartD(uint8_t busSpeed, uint8_t dataBits, uint8_t parity, uint8_t stopBit)

{

    uint8_t regVal; //temp value for reading register and change it's value without clearing it

    //void (*callFuncWR)();

    //uint8_t (*callFuncRD)();

    //uint16_t addrWriteFunc[] = {&writePortA, &writePortB, &writePortC, &writePortD};

    //uint16_t addrReadFunc[] = {&readPortA, &readPortB, &readPortC, &readPortD};

    uint8_t wordValues[] = {DATA_5BITS, DATA_6BITS, DATA_7BITS, DATA_8BITS};

    uint8_t baudsValues[] = {DL_9600_BAUDS, DL_19200_BAUDS, DL_38400_BAUDS};

    uint8_t parityValues[] = {PARITY_NONE, PARITY_ODD, PARITY_EVEN};

    uint8_t stopBitValues[] = {STOPBIT_ONE, STOPBIT_TWO};

    //callFuncWR = uart_type > 3 ? writePortD : addrWriteFunc[uart_type];

    //callFuncRD = uart_type > 3 ? writePortD : addrReadFunc[uart_type];

    //Read register first...

    regVal = readPortD(LCR_REG);

    setWait(20);

    regVal |= DLAB_ERF_EN_BIT; //set LCR[7] = 1 -> enable divisor latch mode

    writePortD(regVal, LCR_REG); //switch Mode

    setWait(20);

    //Set bus speed (according of 8MHz OSC. -> DL = Fosc/(16*Fbauds*DIV)); 

    //DIV = 1 or 4 (see TL16C datasheet p.14), we use here DIV = 1 

    writePortD(0x00, DLH_REG); //Always 0x00 in our cfg... MAX 12MHz

    setWait(20);

    writePortD(busSpeed > 2 ? DL_38400_BAUDS : baudsValues[busSpeed], DLL_REG);

    setWait(20);

    regVal = readPortD(LCR_REG);

    regVal &= ~(DLAB_ERF_EN_BIT); //set LCR[7] = 0 -> disable divisor latch mode

    regVal |= dataBits > 3 ? DATA_8BITS : wordValues[dataBits]; //set 8bits mode

    regVal |= (stopBit > 1 ? STOPBIT_TWO : stopBitValues[stopBit]) << 2; //set stop bits

    regVal |= (parity > 2 ? PARITY_EVEN : parityValues[parity]) << 3; //set stop bits

    writePortD(regVal, LCR_REG);

    setWait(20);

    writePortD(0x01, FCR_REG); //enable FIFO

    setWait(20);

}

//set an external clock on PA0

void initExtClock(uint8_t prescaler, uint16_t cnt)

{

    TCA0.SINGLE.CMP0 = cnt; //set number of count that define period

    TCA0.SINGLE.CTRLA = 0x01 | ((prescaler & 0x7) << 1) ; //enable with DIVn prescaler

    TCA0.SINGLE.CTRLB = 0x11; //Freq mode and enable CMP0 bit for waveform output

    PORTA.DIR |= 0x01; // PA0 OUTPUT

}

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

//write functions

void writePortA(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSA; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSA; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

void writePortB(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSB; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSB; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

void writePortC(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSC; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSC; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

void writePortD(uint8_t reg, uint8_t addr)

{

    DATADIR(0xFF); //set I/O on write mode

    ADDRWRITE(addr); //search uartn register

    DATAWRITE(reg); //write data

    CLRCSD; //enable uartA call

    setWait(3);

    CLRWR; //enable write mode

    setWait(3);

    SETWR; //disable write mode

    setWait(3);

    SETCSD; //disable uartA call

    DATADIR(0x00); //set input mode (to reduce power consumption)

}

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

//read functions

uint8_t readPortA(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSA; //enable uartA call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSA; //hang up uartA call

    return result;

}

uint8_t readPortB(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSB; //enable uartB call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSB; //hang up uartB call

    return result;

}

uint8_t readPortC(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSC; //enable uartC call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSC; //hang up uartC call

    return result;

}

uint8_t readPortD(uint8_t addr)

{

    uint8_t result;

    DATADIR(0x00); //set I/O on read mode

    ADDRWRITE(addr); //search uartn register

    CLRCSD; //enable uartD call

    setWait(3);

    CLRRD; //enable read mode

    setWait(3);

    result = PORTD.IN; //set I/O on read mode

    setWait(3);

    SETRD; //disable read mode

    setWait(3);

    SETCSD; //hang up uartD call

    return result;

}

void setWait(uint16_t cnt)

{

    uint16_t k = 0;

    while(k < cnt)

    {

        asm("nop");

        k++;

    }

}