Adaptation Panel Reader en Bluetooth

/*

 * File:   main.c

 * Author: Enzo Niro

 * Revision history : 2.0

 *

 * Created on August 28, 2024, 2:39 PM

 */

#define F_CPU   10000000UL

#include <xc.h>

#include <stdio.h>

#include <string.h>

#include <stdint.h>

#include <stdbool.h>

#include <util/delay.h>

#include <avr/interrupt.h>

#include <avr/eeprom.h>

#include "factory.h"

#include "defValues.h"

#include "configuration.h"

#include "pins.h"

#include "moduleCmds.h"

/*

 TODO list :

 * ADC for battery

 * Test setBluetoothConfiguration()

 */

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

//Prototypes & Macros

//USART functions

void writeCommand(const uint8_t *buf, uint8_t n);                     //Write a buffer on usart 1 port

void readBuffer(uint8_t *cfg, uint8_t n);

void usart0_write_byte(uint8_t b);                              //send a single byte to usart 0 port

void usart1_write_byte(uint8_t b);                              //send a single byte to usart 1 port

uint8_t usart0_read_byte(void);                                 //read a single byte from usart 0 port

uint8_t usart1_read_byte(void);                                 //read a single byte from usart 1 port

uint8_t usart0_available(void);                                 //check number of bytes available into usart 0 buffer

uint8_t usart1_available(void);                                 //check number of bytes available into usart 1 buffer

void serialDebug(const char *str, uint8_t n);

//Analog functions

void dimmerSetup(void);                                         //start dimmer

void adcInit(void);                                             //Init ADC cfg

//Control functions

uint8_t numberOfParity(uint8_t *p, uint8_t n);                  //Return the sum of bytes' parity

uint8_t numberOfBit(uint8_t *p, uint8_t n);                     //Return the total bit at 1 of buffer

void getEEPROMCfg(uint8_t *cfg);                                //Get EEPROM buffer into RAM

uint8_t controlCfg(uint8_t *cfg);                               //Control RAM buffer

void getBluetoothConfiguration(uint8_t *cfg);

void setBluetoothConfiguration(uint8_t *cfg);

void restoreFactoryConfiguration(uint8_t *cfg);

uint8_t controlRN4678(void);

//MCU Commands functions

uint8_t gotMCUCommand(uint8_t *buf, uint8_t *frame, uint8_t n); //Method to analyse command

//Macros

#define ADC_START_CONV          ADC0.COMMAND |= 0x01                //Start conversion

#define ADC_READ                ADC0.SAMPLE                         //Get sample value

#define BLUETOOTH_CONNECTED     ((PORTA.IN & STAT2_PIN) >> 4)   //Get Bluetooth connected status

#define SET_DATA_LED            PORTB.OUT |= STATUS_DATA_PIN

#define CLR_DATA_LED            PORTB.OUT &= ~STATUS_DATA_PIN

#define SET_CONNECTED_LED       PORTB.OUT |= STATUS_CONNECTED_PIN

#define CLR_CONNECTED_LED       PORTB.OUT &= ~STATUS_CONNECTED_PIN

#define SET_POWER_LED           TCA0.SINGLE.CMP1 = 255 //Pin depend on timer

#define CLR_POWER_LED           TCA0.SINGLE.CMP1 = 0

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

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

//Serial port backend

enum baudsIndex

{

    B2400 = 0,

    B4800,

    B9600,

    B14400,

    B19200,

    B28800,

    B38400,

    B57600,

    B115200,

};

enum ATtinyMemAddr

{

    AUTH_ADDR = 0x0,

    BLM_ADDR = 0x3,

    DEVN_ADDR = 0x6,

    PINC_ADDR = 0x18,

    BAUD_ADDR = 0x1E,

    COUNT_ADDR = 0x50, //For error memory count

};

//Equivalents baudrate at 10MHz of oscillation

uint16_t _10MHz_Baud_CFG[] = { 16666, 8333, 4166, 2777, 2083, 1389, 1042, 694, 347 };

uint8_t USART0_Buffer[256], USART0_counter = 0;

uint8_t USART1_Buffer[256], USART1_counter = 0;

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

//Special MCU Commands

uint8_t debugSerialBuffer[MAX_WINDOW_BUFFER]; //set window analyse buffer

uint8_t debugSerialCounter = 0;

uint8_t debugStatus_cmd[] = { 0x2, 'A', '$', '$', 'G', 'E', 'T', 'M', 'E', 'M', 'S', 'T', 'S', 0x3, }; 

int main(void) {

    uint8_t ATtiny826_buffer[TOP_CFG_ADDR]; //saved cfg

    bool serialOk = false; //To find the right baud value

    uint8_t baudSelector = 0;

    //Memory corrupt variables

    uint8_t ATtiny_mem_err = 0x00;

    uint8_t RN4678_mem_err = 0x00;

    //Memory corrput counter (for debug, if this is not corrupted...)

    uint8_t ATtiny_mem_cnt = 0;

    uint8_t RN4678_mem_cnt = 0;

    uint8_t EMRG_mem_cnt = 0;

    uint8_t paramBuffer[64];

    uint8_t paramBuffer_cnt = 0;

    _PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, ENABLE_BIT); //Enable clock prescaler (and divide by 2)

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

    //Basic pins setup

    PORTA.OUT = 0x00;

    PORTA.DIR = BOOT_BL_PIN; //set boot pin as output

    PORTB.OUT = 0x00;

    PORTB.DIR = STATUS_POWER_PIN | STATUS_DATA_PIN | STATUS_CONNECTED_PIN; //set all status pins as output

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

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

    //Start PWM

    dimmerSetup();

    SET_DATA_LED; //display boot status

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

    //Boot Bluetooth module

    _delay_ms(50);

    PORTA.OUT |= BOOT_BL_PIN;

    _delay_ms(50);

    PORTA.OUT &= ~(BOOT_BL_PIN);

    _delay_ms(50);

    PORTA.OUT |= BOOT_BL_PIN;    

    _delay_ms(500);

    CLR_DATA_LED;

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

    //USART Setup

    #ifdef USE_TWO_SERIAL_PORTS

    cli();

    PORTA.DIR |= TX2_PIN; //Only this pin is output, others are input

    PORTB.DIR |= TX1_PIN; //Add TX1 pin as output on PORTB

    USART0.CTRLA = USART_RXCIE_bm; // Enable RXCIE -> Receive complete interrupt flag

    USART0.CTRLB = USART_RXEN_bm | USART_TXEN_bm; //TX and RX enable

    USART0.CTRLC = USART_CHSIZE_8BIT_gc | USART_CMODE_ASYNCHRONOUS_gc | USART_PMODE_DISABLED_gc | USART_SBMODE_2BIT_gc; // 8 bits + 2 stop bit + No parity (Normal mode)

    USART0.BAUD = _10MHz_Baud_CFG[0]; //set baudrate

    USART1.CTRLA = USART_RXCIE_bm; // Enable RXCIE -> Receive complete interrupt flag

    USART1.CTRLB = USART_RXEN_bm | USART_TXEN_bm; //TX and RX enable

    USART1.CTRLC = USART_CHSIZE_8BIT_gc | USART_CMODE_ASYNCHRONOUS_gc | USART_PMODE_DISABLED_gc; // 8 bits + 2 stop bit + No parity (Normal mode)

    USART1.BAUD = _10MHz_Baud_CFG[0]; //set baudrate

    sei();

    #endif

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

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

    //Start ADC

    //adcInit();

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

    //Find serial port baud speed

    while(!serialOk)

    {

        uint8_t window_analysis[3]; //create window here (to analyse "CMD" command)

        writeCommand(ENTER_SETUP, 4); //sizeof(ENTER_SETUP)

        _delay_ms(100); //wait a bit

        while(usart0_available() > 0)

        {

            paramBuffer[paramBuffer_cnt] = usart0_read_byte();

            paramBuffer_cnt++;

        }

        while(paramBuffer_cnt > 0) //Try to reach desired buffer and flush "noise" buffer

        {

            //Read 3 first bytes...

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

            {

                window_analysis[i] = paramBuffer[i];

            }

            //Sweep buffer

            for(int i = 0; i < paramBuffer_cnt-1; i++)

            {

                paramBuffer[i] = paramBuffer[i+1];

            }

            //Check buffer

            if(window_analysis[0] == 'C' && window_analysis[1] == 'M' && window_analysis[2] == 'D') //we've got data -> Leave !

            {

                serialOk = true;

            }

            paramBuffer_cnt--;

        }

        if(!serialOk) //if buffer messed up (no "CMD" string found...)

        {

            //Go on next baud

            USART0.BAUD = _10MHz_Baud_CFG[baudSelector]; //set baudrate

            baudSelector++;

            _delay_ms(10);

            //If we've got the last param

            if(baudSelector >= MAX_BAUD_VALUES)

                serialOk = true; //force

        }

    }

    serialDebug("Start\n", 6);

    //_delay_ms(50);

    while(usart0_available() > 0) //flush buffer

    {

        usart0_read_byte();

    }

    _delay_ms(1000); //wait a bit

    USART1.BAUD = USART0.BAUD; //copy baud to another...

    //serialDebug("Dimst\n", 6);

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

    //Memory boot management 

    getEEPROMCfg(ATtiny826_buffer); //read EEPROM saved cfg (At first...)    

    ATtiny_mem_err = controlCfg(ATtiny826_buffer); //control ATtiny826 Memory

    RN4678_mem_err = controlRN4678();              //control RN4678 Memory Status

    //serialDebug("Cfggt\n", 6);

    ATtiny_mem_cnt = eeprom_read_byte(COUNT_ADDR);

    _delay_ms(100);

    RN4678_mem_cnt = eeprom_read_byte(COUNT_ADDR+1);

    _delay_ms(100);

    EMRG_mem_cnt = eeprom_read_byte(COUNT_ADDR+2);

    _delay_ms(100);

    if(ATtiny_mem_err != 0x00 && RN4678_mem_err == 0x00) //MCU memory error !

    {

        ATtiny_mem_cnt++;

        SET_DATA_LED;

        _delay_ms(250);

        CLR_DATA_LED;

        _delay_ms(250);

        SET_DATA_LED;

        _delay_ms(250);

        CLR_DATA_LED;

        _delay_ms(250);

        SET_DATA_LED;

        _delay_ms(250);

        CLR_DATA_LED;

        _delay_ms(250);

        getBluetoothConfiguration(ATtiny826_buffer);

    }

    else if(ATtiny_mem_err == 0x00 && RN4678_mem_err != 0x00) // RN4678 memory error !

    {

        RN4678_mem_cnt++;

        SET_CONNECTED_LED;

        _delay_ms(250);

        CLR_CONNECTED_LED;

        _delay_ms(250);

        SET_CONNECTED_LED;

        _delay_ms(250);

        CLR_CONNECTED_LED;

        _delay_ms(250);

        SET_CONNECTED_LED;

        _delay_ms(250);

        CLR_CONNECTED_LED;

        _delay_ms(250);

        setBluetoothConfiguration(ATtiny826_buffer);

    }

    else if(ATtiny_mem_err != 0x00 && RN4678_mem_err != 0x00)//Emergency case !!! (Twice memory are corrupted...)

    {

        EMRG_mem_cnt++;

        SET_POWER_LED;

        _delay_ms(250);

        CLR_POWER_LED;

        _delay_ms(250);

        SET_POWER_LED;

        _delay_ms(250);

        CLR_POWER_LED;

        _delay_ms(250);

        SET_POWER_LED;

        _delay_ms(250);

        CLR_POWER_LED;

        _delay_ms(250);

        restoreFactoryConfiguration(ATtiny826_buffer);

    }

    else

    {

        SET_DATA_LED;

        _delay_ms(250);

        CLR_DATA_LED;

        SET_CONNECTED_LED;

        _delay_ms(250);

        CLR_CONNECTED_LED;

        SET_POWER_LED; //STATUS_POWER_PIN

        _delay_ms(250);

        CLR_POWER_LED; //STATUS_POWER_PIN

        SET_DATA_LED;

        _delay_ms(250);

        CLR_DATA_LED;

        SET_CONNECTED_LED;

        _delay_ms(250);

        CLR_CONNECTED_LED;

        SET_POWER_LED; //STATUS_POWER_PIN

        _delay_ms(250);

        CLR_POWER_LED; //STATUS_POWER_PIN

    }

    if(EMRG_mem_cnt == 0xFF) //if default EEPROM mem.

    {

        EMRG_mem_cnt = 0; //clear...

        //And write to EEPROM...

        eeprom_write_byte(COUNT_ADDR+2, EMRG_mem_cnt);

        _delay_ms(100);

    }

    if(RN4678_mem_cnt == 0xFF) //if default EEPROM mem.

    {

        RN4678_mem_cnt = 0; //clear...

        //And write to EEPROM...

        eeprom_write_byte(COUNT_ADDR+1, RN4678_mem_cnt);

        _delay_ms(100);

    }

    if(ATtiny_mem_cnt == 0xFF) //if default EEPROM mem.

    {

        ATtiny_mem_cnt = 0; //clear...

        //And write to EEPROM...

        eeprom_write_byte(COUNT_ADDR, ATtiny_mem_cnt);

        _delay_ms(100);

    }

    writeCommand(QUIT_SETUP, sizeof(QUIT_SETUP));

    _delay_ms(1000); //wait a bit

    while(usart0_available() > 0) //flush buffer

    {

        usart0_read_byte();

    }

    while(1)

    {

        //Mux USART Management (Put status and switch together)

        BLUETOOTH_CONNECTED ? (SET_CONNECTED_LED) : (CLR_CONNECTED_LED);

        //Set USART data flow status

        if((PORTA.IN & (STAT1_PIN | STAT_RX_PIN)) != (STAT1_PIN | STAT_RX_PIN)) 

        {

            SET_DATA_LED;

        }

        else

        {

            CLR_DATA_LED;

        }

        //Set Power status (Depending on ADC_BAT and SECTOR_STAT)

        if((PORTC.IN & SECTOR_PIN) == SECTOR_PIN)

        {

            SET_POWER_LED;

        }

        else //Battery Only

        {

            CLR_POWER_LED;

        }

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

        //Man-in-the-middle script

        if(usart1_available() > 0)

        {

                //usart0_write_byte(usart1_read_byte());

                /*paramBuffer[paramBuffer_cnt] = usart1_read_byte();

                usart0_write_byte(paramBuffer[paramBuffer_cnt]);

                paramBuffer_cnt++;*/

                //_delay_ms(1);

                if(BLUETOOTH_CONNECTED)

                    usart0_write_byte(usart1_read_byte());

                else

                {

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

                    //Debug Hardware When BL. module disconnected

                    debugSerialBuffer[MAX_WINDOW_BUFFER-1] = usart1_read_byte(); //get byte into window buffer

                    //usart1_write_byte(debugSerialBuffer[MAX_WINDOW_BUFFER-1]);

                    usart0_write_byte(debugSerialBuffer[MAX_WINDOW_BUFFER-1]); //send it to another serial port (just in case)

                    for(int i = 0; i < MAX_WINDOW_BUFFER-1; i++)

                    {

                        debugSerialBuffer[i] = debugSerialBuffer[i+1]; //shift bytes from right to left

                    }

                    if(gotMCUCommand(debugSerialBuffer, debugStatus_cmd, sizeof(debugStatus_cmd)))

                    {

                        //Bad coding...

                        serialDebug("COUNT: ", 7);

                        usart1_write_byte(ATtiny_mem_cnt);

                        _delay_ms(1);

                        usart1_write_byte(' ');

                        _delay_ms(1);

                        usart1_write_byte(RN4678_mem_cnt);

                        _delay_ms(1);

                        usart1_write_byte(' ');

                        _delay_ms(1);

                        usart1_write_byte(EMRG_mem_cnt);

                        _delay_ms(1);

                        //clearDebugBuffer(debugSerialBuffer, MAX_WINDOW_BUFFER); //if needed, implement it !

                    }

                }

        }

        //When buffer is filled, load it to serial port

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

        {

            usart0_write_byte(paramBuffer[i]);

        }

        paramBuffer_cnt = 0;*/

        if(usart0_available() > 0)

        {

            usart1_write_byte(usart0_read_byte());

        }

        /*

        if(!BLUETOOTH_CONNECTED) //Check STAT2 pin if not connected 

        {

            //Now we accept setup mode

        }

        */

        /*if((PORTA.IN & 0x10) == 0x00) //button pushed

        {

            //wait a bit

            _delay_ms(500);

            _delay_ms(500);

            SLPCTRL.CTRLA = (0x01 << 1); //standby sleep mode

            SLPCTRL.CTRLA |= ENABLE_BIT;

        }

        PORTA.OUT ^= 0x20;

        counter++;

        _delay_ms(500);*/

    }

    return 0;

}

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

//Functions

//Memory configuration functions

//Control RN4678 memory status

uint8_t controlRN4678(void)

{

    uint8_t result = 0x02;

    uint8_t _name[16];

    //uint8_t cmd[3];

    uint8_t devNameTrig[] = {'R','N','4','6','7','8'};

    //TODO : Add more reading through Bluetooth module

    //sprintf(cmd, "%s\r", GET_BLM);      //prepare get Bluetooth mode cmd

    do

    {

        writeCommand(GET_DEVN, 3);              //send command

        _delay_ms(500); //wait a bit

    }

    while(usart0_available <= 0); //wait until we've got data

    readBuffer(_name, 16);                 //get request for 16 bytes

    while(usart0_available() > 0) //flush dust bytes...

    {

        usart0_read_byte();

    }

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

    {

        result = (_name[i] != devNameTrig[i]) ? 0x00 : result;

    }

    if(result == 0x02) //fault detected -> Dev. name = "RN4678-XXXXX" ! 

        result = 0x01;

    return result;

}

//Control ATtiny memory CFG

uint8_t controlCfg(uint8_t *cfg)

{

    uint8_t err_code = 0; 

    uint16_t local_crc;

    //Check Authentification mode

    local_crc = numberOfBit(&cfg[AUTH_ADDR], 1) << 8 | numberOfParity(&cfg[AUTH_ADDR], 1);

    if(local_crc != ((cfg[AUTH_ADDR + 1] << 8) | cfg[AUTH_ADDR + 2]))

    {

        err_code |= 0x01;

    }

    //Check Bluetooth mode

    local_crc = numberOfBit(&cfg[BLM_ADDR], 1) << 8 | numberOfParity(&cfg[BLM_ADDR], 1);

    if(local_crc != ((cfg[BLM_ADDR + 1] << 8) | cfg[BLM_ADDR + 2]))

    {

        err_code |= 0x02;

    }

    //Check Device name (ISSUE HERE)

    local_crc = numberOfBit(&cfg[DEVN_ADDR], 16) << 8 | numberOfParity(&cfg[DEVN_ADDR], 16);

    if(local_crc != ((cfg[DEVN_ADDR + 16] << 8) | cfg[DEVN_ADDR + 17])) //read CRC at DEVN_ADDR + STR_LENGTH (16 alphanumeric char)

    {

        err_code |= 0x04;

    }

    //Check Pincode

    local_crc = numberOfBit(&cfg[PINC_ADDR], 4) << 8 | numberOfParity(&cfg[PINC_ADDR], 4);

    if(local_crc != ((cfg[PINC_ADDR + 4] << 8) | cfg[PINC_ADDR + 5])) //read CRC at PINC_ADDR + STR_LENGTH (4 char number)

    {

        err_code |= 0x08;

    }

    //Check Baud (ISSUE HERE)

    local_crc = numberOfBit(&cfg[BAUD_ADDR], 1) << 8 | numberOfParity(&cfg[BAUD_ADDR], 1);

    if(local_crc != ((cfg[BAUD_ADDR + 1] << 8) | cfg[BAUD_ADDR + 2])) 

    {

        err_code |= 0x10;

    }

    return err_code;

}

//Read RN4678 in case of ATtiny826 memory corrupt

void getBluetoothConfiguration(uint8_t *cfg)

{

    char cmd[25];

    int i;

    uint8_t buffer[25];

    //Implement get bluetooth value with index here

    //Authentification Mode

    sprintf(cmd, "%s", GET_AUTH);     //prepare get authentification cmd

    writeCommand(cmd, 25);              //send command

    _delay_ms(1000);

    //serialDebug("\r\ncmd : ", 8);

    //serialDebug(cmd, 25);

    readBuffer(buffer, 25);                 //get request (for 1 byte here)

    //serialDebug("\r\nbuf : ", 8);

    //serialDebug(buffer, 25);

    cfg[AUTH_ADDR] = buffer[0]-ASCII_NUMBER_CONVERSION;         //store result

    //crc calcultate

    cfg[AUTH_ADDR + 1] = numberOfBit(&cfg[AUTH_ADDR], 1);

    cfg[AUTH_ADDR + 2] = numberOfParity(&cfg[AUTH_ADDR], 1);

    //Bluetooth Mode

    sprintf(cmd, "%s", GET_BLM);      //prepare get Bluetooth mode cmd

    writeCommand(cmd, 25);              //send command

    _delay_ms(1000);

    readBuffer(buffer, 25);                 //get request for 1 byte again

    cfg[BLM_ADDR] = buffer[0]-ASCII_NUMBER_CONVERSION;          //store result

    //serialDebug("\r\nbuffer[0] : ", 14);

    //serialDebug(buffer[0], 1);

    //serialDebug("\r\nbascii[0] : ", 14);

    //serialDebug(buffer[0]-ASCII_NUMBER_CONVERSION, 1);

    //crc calcultate

    cfg[BLM_ADDR + 1] = numberOfBit(&cfg[BLM_ADDR], 1);

    cfg[BLM_ADDR + 2] = numberOfParity(&cfg[BLM_ADDR], 1);

    //Device Name

    sprintf(cmd, "%s", GET_DEVN);      //prepare get Bluetooth dev. name

    //serialDebug("\r\ncmd : ", 8);

    //serialDebug(cmd, 25);

    writeCommand(cmd, 25);              //send command

    _delay_ms(1000);

    readBuffer(buffer, 25);                 //get request for 16 bytes

    //serialDebug("\r\nbuf : ", 8);

    //serialDebug(buffer, 25);

    i = 15; //max buffer for device name

    while(buffer[i] != '\r') //clear buffer exclusivity (for name structure)

    {

        buffer[i] = 0xFF;

        i--;

    }

    for(i = 0; i < 16; i++)

    {

        cfg[DEVN_ADDR + i] = buffer[i]; //store name

    }

    cfg[DEVN_ADDR + 16] = numberOfBit(&cfg[DEVN_ADDR], 16);

    cfg[DEVN_ADDR + 17] = numberOfParity(&cfg[DEVN_ADDR], 16);

    //Pincode

    sprintf(cmd, "%s", GET_PINC);      //prepare get Bluetooth pin code

    writeCommand(cmd, 25);              //send command

    _delay_ms(1000);

    readBuffer(buffer, 25);                 //get request for 4 bytes

    for(i = 0; i < 4; i++)

    {

        cfg[PINC_ADDR + i] = buffer[i]; //store name

    }

    cfg[PINC_ADDR + 4] = numberOfBit(&cfg[PINC_ADDR], 4);

    cfg[PINC_ADDR + 5] = numberOfParity(&cfg[PINC_ADDR], 4);

    //Baudrate

    sprintf(cmd, "%s", GET_BAUD);      //prepare get Bluetooth mode cmd

    writeCommand(cmd, 25);              //send command

    _delay_ms(1000);

    readBuffer(buffer, 25);                 //get request for 4 bytes

    //Buffer will get "0x" -> buffer[0] = '0' and buffer[1] = 'x'

    cfg[BAUD_ADDR] = (buffer[1] == 'A') ? 0x0A : (buffer[1] == 'B') ? 0x0B : buffer[1] - '0'; //Method "0A", "0B" and "03" to "09"

    cfg[BAUD_ADDR + 1] = numberOfBit(&cfg[BAUD_ADDR], 1);

    cfg[BAUD_ADDR + 2] = numberOfParity(&cfg[BAUD_ADDR], 1);

    //Write into eeprom    

    for(i = 0; i < TOP_CFG_ADDR; i++)

    {

        eeprom_write_byte(i, cfg[i]);

    }

}

//Read ATtiny826 in case of RN4678 memory corrupt

void setBluetoothConfiguration(uint8_t *cfg)

{

    //Implement set bluetooth value with index here

    char cmd[25];

    char _name[16];

    char _pin[4];

    char _authValues[] = { '1', '2', '3', '4', };

    char _blmValues[] = { '0', '1', '2', };

    char *_baudsValues[] = { BAUD_VAL_115200, BAUD_VAL_57600, BAUD_VAL_38400, BAUD_VAL_28800, BAUD_VAL_19200, BAUD_VAL_14400, BAUD_VAL_9600, BAUD_VAL_4800, BAUD_VAL_2400,  };

    //Write authentification mode

    sprintf(cmd, "%s%c\r", SET_AUTH, _authValues[cfg[AUTH_ADDR]]);

    writeCommand(cmd, 25); //always put max buffer value, it stop with chara \r !

    //serialDebug(cmd, 25);

    //Write bluetooth mode

    sprintf(cmd, "%s%c\r", SET_BLM, _blmValues[cfg[BLM_ADDR]]);

    writeCommand(cmd, 25); //always put max buffer value, it stop with chara \r !

    //serialDebug(cmd, 25);

    //Write device name

    /*serialDebug("Copy : ", 7);

    serialDebug(&cfg[DEVN_ADDR], 16);

    serialDebug("\r\n", 2);

    serialDebug("Name : ", 7);*/

    strncpy(_name, &cfg[DEVN_ADDR], 16);

    /*serialDebug(_name, 16);

    serialDebug("\r\n", 2);

    serialDebug("DEVN : ", 7);

    serialDebug(SET_DEVN, 3);

    serialDebug("\r\n", 2);*/

    sprintf(cmd, "%s%s\r", SET_DEVN, _name);

    writeCommand(cmd, 25); //always put max buffer value, it stop with chara \r !

    /*serialDebug("cmd : ", 6);

    serialDebug(cmd, 25);

    serialDebug("\r\n", 2);*/

    //Write pin code

    strncpy(_pin, &cfg[PINC_ADDR], 4);

    sprintf(cmd, "%s%s\r", SET_PINC, _pin);

    writeCommand(cmd, 25); //always put max buffer value, it stop with chara \r !

    //serialDebug(cmd, 25);

    //Write baudrate

    sprintf(cmd, "%s%s\r", SET_BAUD, _baudsValues[cfg[BAUD_ADDR]]);

    writeCommand(cmd, 25); //always put max buffer value, it stop with chara \r !

    //serialDebug(cmd, 25);

}

//Restore Factory setting in ATtiny826 EEPROM and RN4678 EEPROM

void restoreFactoryConfiguration(uint8_t *cfg)

{

    //Write factory settings inside ATtiny826 EEPROM

    for(int i = 0; i < sizeof(ATtiny826_factory_buffer); i++)

    {

        cfg[i] = ATtiny826_factory_buffer[i];

        eeprom_write_byte(i, cfg[i]);

    }

    setBluetoothConfiguration(cfg); //Once we wrote configuration inside ATtiny EEPROM -> Write it on RN4678 EEPROM

    serialDebug("FactoryDone\r\n", 13);

}

void getEEPROMCfg(uint8_t *cfg)

{

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

    {

        cfg[i] = eeprom_read_byte(i);

        _delay_ms(100); //wait a bit when reading eeprom... (so slow :'| )

    }

}

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

//CRC functions

uint8_t numberOfParity(uint8_t *p, uint8_t n)

{

    uint8_t r = 0;

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

    {

       if(p[i] % 2 == 0)

        r+=2;

       else // == 1

        r++;

    }

    return r;

}

uint8_t numberOfBit(uint8_t *p, uint8_t n)

{

    uint8_t r = 0;

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

    {

        for(uint8_t j = 1; j != 0; j <<= 1)

        {

            if((j & p[i]) != 0)

                r++;

        }

    }

    return r;

}

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

//MCU commands function

//Method to analyse command

uint8_t gotMCUCommand(uint8_t *buf, uint8_t *frame, uint8_t n)

{

    bool result = true;

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

    {

        if((buf[i] != frame[i]))

        {

            result = false;

        }

    }

    return result;

}

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

//Analog functions

void adcInit(void)

{

    ADC0.CTRLA = ENABLE_BIT; //Enable register

    ADC0.COMMAND = (ADC_SINGLE_12BIT << 4); //Just use 12 bit resolution (no differential mode)

    ADC0.CTRLB = ADC_PRESCALER; //divide clock for conversion

    ADC0.CTRLC = (ADC_TIMEBASE << 3) | ADC_REF; //Set analog reference

    ADC0.PGACTRL = (ADC_PGA_GAIN << 5) | (ADC_PGA_BIAS << 3) | (ADC_PGA_SMD << 1) | ENABLE_BIT; //set PGA cfg

    ADC0.CTRLE = 0x80; //Set sample duration (SAMPDUR -> p.407)

    ADC0.MUXPOS = (ADC_VIA_PGA << 6) | (ADC_MUX_AIN12); //PC0 connected to AIN12

    ADC0.MUXNEG = (ADC_VIA_DIRECT << 6) | (ADC_MUXN_GND); //Set reference in common mode

}

uint16_t adcGetSample(void)

{

    ADC_START_CONV; //as for a conversion

    _delay_ms(1); //wait a bit

    while(!ADC0.STATUS); //Wait when conversion is now complete

    return ADC_READ; //get stored value

}

void dimmerSetup(void)

{

    TCA0.SINGLE.CTRLA = (PWM_DIV << 1) | ENABLE_BIT; //enable register set PWM frequency (datasheet p.209)

    TCA0.SINGLE.CTRLB = 0x13; //set output frequency in Single-slope PWM

    TCA0.SINGLE.CTRLD = ENABLE_BIT; //enable split mode

    TCA0.SINGLE.CMP0 = PWM_RATE; //set duty cycle

    PORTB.DIR |= PWM_DIMMER_PIN;

}

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

//Usart functions

void serialDebug(const char *str, uint8_t n)

{

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

    {

        usart1_write_byte(str[i]);

        _delay_ms(1);

    }

}

void readBuffer(uint8_t *cfg, uint8_t n)

{

    uint8_t _counter = 0;

    _delay_ms(50); //force wait to let buffer filling inside interrutp

    while(usart0_available() > 0 && _counter < n) //ensure not overflow buffer...

    {

        cfg[_counter] = usart0_read_byte(); //now read the stuff

        _counter++;

    }

}

void writeCommand(const uint8_t *buf, uint8_t n)

{

    int i = 0;

    while(i < n)

    {

        usart0_write_byte(buf[i]); 

        //serialDebug("\n\rb: ", 5);

        //usart1_write_byte(buf[i]);

        if(buf[i] == '\r') //read before and increment after

        {

            i = n; //stop right there

        }

        i++;

        _delay_ms(10); //wait a bit...

    }

}

//Write on TX0 buffer

void usart0_write_byte(uint8_t b)

{

    USART0.TXDATAL = b;

}

//Write on TX1 buffer

void usart1_write_byte(uint8_t b)

{

    USART1.TXDATAL = b;

}

//Read on RX0 FIFO buffer

uint8_t usart0_read_byte(void)

{

    uint8_t r = USART0_Buffer[0];

    for(int i = 0; i < USART0_counter-1; i++)

    {

        USART0_Buffer[i] = USART0_Buffer[i+1];

    }

    USART0_counter--;

    return r;

}

//Read on RX1 FIFO buffer

uint8_t usart1_read_byte(void)

{

    uint8_t r = USART1_Buffer[0];

    for(int i = 0; i < USART1_counter-1; i++)

    {

        USART1_Buffer[i] = USART1_Buffer[i+1];

    }

    USART1_counter--;

    return r;

}

//Check RX0 FIFO buffer

uint8_t usart0_available(void)

{

    return USART0_counter;

}

//Check RX1 FIFO buffer

uint8_t usart1_available(void)

{

    return USART1_counter;

}

//////////

//ISR part

//When interrupt is occured (Receive complete flag), read RX buffer and store it into the equivalent software buffer

ISR(USART0_RXC_vect)

{

    USART0_Buffer[USART0_counter++] = USART0.RXDATAL; 

}

ISR(USART1_RXC_vect)

{

    USART1_Buffer[USART1_counter++] = USART1.RXDATAL;

}