"Arduino Setup+" rev_01

/********* Pleasedontcode.com **********

    Pleasedontcode thanks you for automatic code generation! Enjoy your code!

    - Terms and Conditions:
    You have a non-exclusive, revocable, worldwide, royalty-free license
    for personal and commercial use. Attribution is optional; modifications
    are allowed, but you're responsible for code maintenance. We're not
    liable for any loss or damage. For full terms,
    please visit pleasedontcode.com/termsandconditions.

    - Project: "Arduino Setup+"
    - Source Code compiled for: Arduino Pro Mini 5V
    - Source Code created on: 2023-12-22 12:22:37

********* Pleasedontcode.com **********/

/****** SYSTEM REQUIREMENTS *****/
/****** SYSTEM REQUIREMENT 1 *****/
    /* Check if digital data is received from bluetooth */
    /* and and use this data into MCP4725. */
/****** SYSTEM REQUIREMENT 2 *****/
    /* Read currentAcquisition and send it via bluetooth. */
    /* The data to be send has to be integer. */
/****** END SYSTEM REQUIREMENTS *****/

/****** DEFINITION OF LIBRARIES *****/
#include <Arduino.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_MCP4725.h>

/****** FUNCTION PROTOTYPES *****/
void setup(void);
void loop(void);
void updateInputs(void);
void convertInputsFromRawToPhyData(void);

/***** DEFINITION OF ANALOG INPUT PINS *****/
const uint8_t currentAcquisition_PIN_A0 = A0;

/***** DEFINITION OF Software Serial *****/
const uint8_t DX_BT27_Slave_HC05_mySerial_PIN_SERIAL_TX_A1 = A1;
const uint8_t DX_BT27_Slave_HC05_mySerial_PIN_SERIAL_RX_A2 = A2;
SoftwareSerial DX_BT27_Slave_HC05_mySerial(DX_BT27_Slave_HC05_mySerial_PIN_SERIAL_RX_A2, DX_BT27_Slave_HC05_mySerial_PIN_SERIAL_TX_A1);

/***** DEFINITION OF I2C PINS *****/
const uint8_t MCP4725_PIN_SDA_A4 = A4;
const uint8_t MCP4725_PIN_SCL_A5 = A5;

/****** DEFINITION OF ANALOG INPUTS CHARACTERISTIC CURVES *****/
const uint8_t SEGMENT_POINTS_voltage_Current_PIN_A0 = 2;
const float voltage_Current_PIN_A0_lookup[2][SEGMENT_POINTS_voltage_Current_PIN_A0] = {
  {0.0, 5.0},  //Voltage [V]
  {0.0, 500.0} //Current [A]
};

/***** DEFINITION OF INPUT RAW VARIABLES *****/
/***** used to store raw data *****/
unsigned int currentAcquisition_PIN_A0_rawData = 0; // Analog Input

/***** DEFINITION OF INPUT PHYSICAL VARIABLES *****/
/***** used to store data after characteristic curve transformation *****/
float currentAcquisition_PIN_A0_phyData = 0.0; // Current [A]

/****** DEFINITION OF LIBRARIES CLASS INSTANCES*****/
Adafruit_MCP4725 dac;

void setup(void) {
  // put your setup code here, to run once:

  pinMode(currentAcquisition_PIN_A0, INPUT);

  DX_BT27_Slave_HC05_mySerial.begin(9600);

  dac.begin(MCP4725_I2CADDR_DEFAULT, &Wire); // Initialize DAC with default I2C address and Wire object
}

void loop(void) {
  // put your main code here, to run repeatedly:

  updateInputs(); // Refresh input data

  convertInputsFromRawToPhyData(); // after that updateInput function is called, so raw data are transformed into physical data according to the characteristic curve

  // Check if digital data is received from bluetooth and use this data into MCP4725
  if (DX_BT27_Slave_HC05_mySerial.available()) {
    int data = DX_BT27_Slave_HC05_mySerial.parseInt();
    dac.setVoltage(data, true); // Set the voltage output of the DAC and write to EEPROM
  }

  // Read currentAcquisition and send it via bluetooth
  int currentAcquisitionInt = (int)currentAcquisition_PIN_A0_phyData;
  DX_BT27_Slave_HC05_mySerial.println(currentAcquisitionInt);
}

void updateInputs() {
  currentAcquisition_PIN_A0_rawData = analogRead(currentAcquisition_PIN_A0);
}

/* BLOCK lookup_phyData_from_voltage */
float lookup_phyData_from_voltage(float voltage, int segment_points, const float* voltage_phyData_lookup)
{
    // Search table for appropriate value.
    uint8_t index = 0;

    const float *voltagePointer = &voltage_phyData_lookup[0];
    const float *phyDataPointer = &voltage_phyData_lookup[segment_points];

    // Perform minimum and maximum voltage saturation based on characteristic curve
    voltage = min(voltage, voltagePointer[segment_points-1]);
    voltage = max(voltage, voltagePointer[0]);

    while( voltagePointer[index] <= voltage && index < segment_points )
        index++;

    // If index is zero, physical value is smaller than our table range
    if( index==0 )
    {
        return map_f( voltage,
            voltagePointer[0],   // X1
            voltagePointer[1],   // X2
            phyDataPointer[0],   // Y1
            phyDataPointer[1] ); // Y2
    }
    // If index is maxed out, phyisical value is larger than our range.
    else if( index==segment_points )
    {
        return map_f( voltage,
            voltagePointer[segment_points-2],   // X1
            voltagePointer[segment_points-1],   // X2
            phyDataPointer[segment_points-2],   // Y1
            phyDataPointer[segment_points-1] ); // Y2
    }
    // index is between 0 and max, just right
    else
    {
        return map_f( voltage,
            voltagePointer[index-1], // X1
            voltagePointer[index],    // X2
            phyDataPointer[index-1], // Y1
            phyDataPointer[index] );  // Y2
    }
}
/* END BLOCK lookup_phyData_from_voltage */

/* BLOCK map_f */
float map_f(float x, float in_min, float in_max, float out_min, float out_max)
{
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
/* END BLOCK map_f */

/* BLOCK convertInputsFromRawToPhyData */
void convertInputsFromRawToPhyData()
{
    float voltage = 0.0;

    voltage = currentAcquisition_PIN_A0_rawData * (5.0 / 1023.0);
    currentAcquisition_PIN_A0_phyData = lookup_phyData_from_voltage(voltage, SEGMENT_POINTS_voltage_Current_PIN_A0, &(voltage_Current_PIN_A0_lookup[0][0]));

}
/* END BLOCK convertInputsFromRawToPhyData */