quick arduino bms

/* This code is a total kludge, thrown together on a rainy day
* Thanks to Adafruit, Kevin Darrah, and Tinkerit for allowing me to lift some useful bits
*/
#define MODULENUM 5
#define POWERPIN 13
#define TRIGGERPIN 12
#define NUMSENSORS 3
// resistance at 25 degrees C
#define THERMISTORNOMINAL 10000  
// temp. for nominal resistance (almost always 25 C)
#define TEMPERATURENOMINAL 298.15
// how many samples to take and average, more takes longer
// but is more 'smooth'
#define NUMSAMPLES 5
// The beta coefficient of the thermistor (usually 3000-4000)
#define BCOEFFICIENT 3950
// the value of the 'other' resistor
#define SERIESRESISTOR 10000 

float readVcc()
 {
 long result; // Read 1.1V reference against AVcc
 ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
 delay(5); // Wait for Vref to settle
 ADCSRA |= _BV(ADSC); // Convert
 while (bit_is_set(ADCSRA,ADSC));
 result = ADCL; result |= ADCH<<8;
 result = 1100000L / result; // Back-calculate AVcc in
 return result/1000.0;
 }

float steinhart(float average)
 {
 float result;
 average = 1023 / average - 1;
 average = SERIESRESISTOR / average;
 result = average / THERMISTORNOMINAL;  // (R/Ro)
 result = log(result);         // ln(R/Ro)
 result /= BCOEFFICIENT;         // 1/B * ln(R/Ro)
 result += 1.0 / (TEMPERATURENOMINAL); // + (1/To)
 result = 1.0 / result;        // Invert
 return result;
 }

void setup(void)
 {
 Serial.begin(9600);
 pinMode(POWERPIN, OUTPUT);
 pinMode(TRIGGERPIN, OUTPUT);
 }


void loop(void)
 {
 uint8_t i,n;
 uint16_t samples[NUMSAMPLES];
 float averages[NUMSENSORS];
 float highest, lowest;

 for (n=0; n < NUMSENSORS; n++)
  {
  // take N samples in a row, with a slight delay
  for (i=0; i< NUMSAMPLES; i++)
   {
   digitalWrite(POWERPIN, HIGH);
   delay(2);
   samples[i] = analogRead('A' + n);
   digitalWrite(POWERPIN, LOW);
   delay(2);
   }
  // average all the samples out
  averages[n] = 0;
  for (i=0; i< NUMSAMPLES; i++)
   {
   averages[n] += samples[i];
   }
  averages[n] /= NUMSAMPLES;
  }

 highest = 0.0;
 lowest = 1023.0;

 for(i=0; i< NUMSENSORS; i++)
  {
  if(averages[i] > highest) highest = averages[i];
  if(averages[i] <= lowest) lowest = averages[i];
  }
 // highest and lowest are swapped after steinhart
 Serial.print(MODULENUM);
 Serial.print(' ');
 Serial.print(readVcc(),3);
 Serial.print("V ");
 Serial.print(steinhart(lowest),1);
 Serial.print("K ");
 Serial.print(steinhart(highest),1);
 Serial.print("K ");
 Serial.println();
 digitalWrite(TRIGGERPIN, HIGH);
 delay(10);
 digitalWrite(TRIGGERPIN, LOW);
 delay(20);
 ADCSRA &= ~(1 << 7); //shut down adc
 SMCR |= (1 << 2); //power down mode
 SMCR |= 1;//enable sleep
 MCUCR |= (3 << 5); //set both BODS and BODSE at the same time
 MCUCR = (MCUCR & ~(1 << 5)) | (1 << 6); //then set the BODS bit and clear the BODSE bit at the same time
 __asm__ __volatile__("sleep");//in line assembler to go to sleep
}

/* This code is a total kludge, thrown together on a rainy day
* Thanks to Adafruit, Kevin Darrah, and Tinkerit for allowing me to lift some useful bits
*
* UPDATE 20 Nov 2018 - I have shaved this code down to the bare bones, will do all calculations
* and calibration on the master. this means the only change to each module is the
* MODULENUM define.
*/
#define POWERPIN 13
#define NUMSENSORS 4 // max 8
#define NUMSAMPLES 5 // max 32

uint16_t readVcc()
 {
 uint16_t result = 0;
 uint16_t sample;
 ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
 delay(2); // Wait for Vref to settle
 for(uint8_t i = 0; i < NUMSAMPLES; i++)
  {
  ADCSRA |= _BV(ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  sample = ADCL; sample |= ADCH<<8;
  result += sample;
  delay(2);
  }
 return result;
 }

void setup(void)
 {
 noInterrupts();
 CLKPR = 0x80; //allow changing the prescaler
 CLKPR = 0x01; //divide by two
 interrupts();
 Serial.begin(4800);
 pinMode(POWERPIN, OUTPUT);
 pinMode(2, INPUT_PULLUP);
 attachInterrupt(0, digitalInterrupt, FALLING);
 }

void loop(void)
 {
 ADCSRA |= (1 << ADEN);
 uint8_t i,n;
 uint16_t sample, lowest, highest;

 lowest = (1024 * NUMSAMPLES) - 1;

 for (n=0; n < NUMSENSORS; n++)
  {
  sample = 0;
  // take N samples in a row, with a slight delay
  for (i=0; i< NUMSAMPLES; i++)
   {
   digitalWrite(POWERPIN, HIGH);
   delay(1);
   sample += analogRead('A' + n);
   delay(1);
   digitalWrite(POWERPIN, LOW);
   }
  if(sample > highest) highest = sample;
  if(sample <= lowest) lowest = sample;
  }
 sample = readVcc(); //re-used variable
 Serial.print(sample);
 Serial.print(' ');
 Serial.print(lowest);
 Serial.print(' ');
 Serial.print(highest);
 delay(30);
 ADCSRA &= ~(1 << 7); //shut down adc
 SMCR |= (1 << 2); //power down mode
 SMCR |= 1;//enable sleep
 MCUCR |= (3 << 5); //set both BODS and BODSE at the same time
 MCUCR = (MCUCR & ~(1 << 5)) | (1 << 6); //then set the BODS bit and clear the BODSE bit at the same time
 __asm__ __volatile__("sleep");//in line assembler to go to sleep
}

void digitalInterrupt(){}

#include <SoftwareSerial.h>
#define THERMISTORNOMINAL 10000  
#define TEMPERATURENOMINAL 298.15
#define BCOEFFICIENT 3950
#define SERIESRESISTOR 10000 

const float num_samples = 5.0;

SoftwareSerial mySerial(10, 11);

String getValue(String data, char separator, int index)
{
 int found = 0;
 int strIndex[] = {0, -1};
 int maxIndex = data.length()-1;

 for(int i=0; i<=maxIndex && found<=index; i++){
  if(data.charAt(i)==separator || i==maxIndex){
    found++;
    strIndex[0] = strIndex[1]+1;
    strIndex[1] = (i == maxIndex) ? i+1 : i;
  }
 }

 return found>index ? data.substring(strIndex[0], strIndex[1]) : "";
}

float steinhart(float average)
 {
 float result;
 average = 1023 / average - 1;
 average = SERIESRESISTOR / average;
 result = average / THERMISTORNOMINAL;  // (R/Ro)
 result = log(result);         // ln(R/Ro)
 result /= BCOEFFICIENT;         // 1/B * ln(R/Ro)
 result += 1.0 / (TEMPERATURENOMINAL); // + (1/To)
 result = 1.0 / result;        // Invert
 return result;
 }

void setup() {
 Serial.begin(9600);
 mySerial.begin(2400);
 pinMode(12, OUTPUT);
}

void loop()
 {
 bool was_read = 0;
 int vraw, highest, lowest;
 String instring, s1, s2, s3;
 float v_batt, t_low, t_high, result;
 if (mySerial.available())
  {
  instring = mySerial.readString();
  was_read = true;
  }
while(was_read)
{
 s1 = getValue(instring, ' ', 0);
 s2 = getValue(instring, ' ', 1);
 s3 = getValue(instring, ' ', 2);
 vraw = s1.toInt();
 highest = s2.toInt();
 lowest = s3.toInt();

 result = vraw / num_samples;
 result = 1125300/result;
 result = result/1000;
 t_low = steinhart(lowest/num_samples) - 273.15;
 t_high = steinhart(highest/num_samples) - 273.15;
 Serial.print(result, 3);
 Serial.println(" Volts");
 Serial.print(t_low, 2);
 Serial.print(" C, ");
 Serial.print(t_high, 2);
 Serial.println(" C");
 was_read = false;

}
delay(5000);
digitalWrite(12, HIGH);
delay(10);
digitalWrite(12, LOW);
}