324 lines
12 KiB
C++
324 lines
12 KiB
C++
#include "MAX122x.h"
|
|
#include <SPI.h>
|
|
|
|
MAX122x_library::MAX122x_library(bool displayMsg) {
|
|
// Anything you need when instantiating your object goes here
|
|
}
|
|
|
|
// Reads out MAX122x internal temperature sensor
|
|
float MAX122x_library::max122xreadTemp(uint8_t Chipselect_Pin){
|
|
// Utilise SPI bus with appropriate settings
|
|
SPI.beginTransaction(SPI_SETTINGS);
|
|
// Write Setup register
|
|
digitalWrite(Chipselect_Pin,LOW);
|
|
// Write in setup register
|
|
SPI.transfer(MAX122x_SETUP_0);
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
// Write conversion register to get temperature
|
|
SPI.transfer(MAX122x_CONVERT_TMP);
|
|
// Wait for conversion to be finished (incl. int. ref. wake-up time)
|
|
delayMicroseconds(SPI_delay_conversionTime);
|
|
// Write 24-2 byte of zeros on bus
|
|
for (byte i=0;i<=21;i++){
|
|
SPI.transfer(0x00);
|
|
}
|
|
// Fetch temperature from last 2 bytes of the 24 bytes sent
|
|
byte tmp_msb=SPI.transfer(0x00); // MSB of conversion
|
|
byte tmp_lsb=SPI.transfer(0x00); // LSB of conversion
|
|
// end ADC sampling
|
|
digitalWrite(Chipselect_Pin,HIGH);
|
|
// Clear bus
|
|
SPI.endTransaction();
|
|
// recover 12 bit value into 16 bit/2byte/uint16_t
|
|
//adc_msb = adc_msb & 0x0F;
|
|
uint16_t tmp_comb=((uint16_t)tmp_msb << 8) | tmp_lsb;
|
|
// Convert to celsius
|
|
float tmp_result = (float)tmp_comb/8;
|
|
// Return result
|
|
return tmp_result;
|
|
} // end of max122xreadTMP()
|
|
|
|
// Reads out single MAX122x ADC channnel
|
|
uint16_t MAX122x_library::max122xreadADCsingle(uint8_t Chipselect_Pin, byte channel){
|
|
// Utilise SPI bus with appropriate settings
|
|
SPI.beginTransaction(SPI_SETTINGS);
|
|
// Write Setup register
|
|
digitalWrite(Chipselect_Pin,LOW);
|
|
// Write in setup register
|
|
SPI.transfer(MAX122x_SETUP_0);
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
// Select channel
|
|
switch(channel){
|
|
case 0 : SPI.transfer(MAX122x_CONVERT_CH0);
|
|
break;
|
|
case 1 : SPI.transfer(MAX122x_CONVERT_CH1);
|
|
break;
|
|
case 2 : SPI.transfer(MAX122x_CONVERT_CH2);
|
|
break;
|
|
case 3 : SPI.transfer(MAX122x_CONVERT_CH3);
|
|
break;
|
|
case 4 : SPI.transfer(MAX122x_CONVERT_CH4);
|
|
break;
|
|
case 5 : SPI.transfer(MAX122x_CONVERT_CH5);
|
|
break;
|
|
case 6 : SPI.transfer(MAX122x_CONVERT_CH6);
|
|
break;
|
|
case 7 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
case 8 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
case 9 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
case 10 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
case 11 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
default: break;
|
|
}
|
|
// Wait for conversion to be finished (incl. int. ref. wake-up time)
|
|
delayMicroseconds(SPI_delay_conversionTime);
|
|
byte data[16]={0};
|
|
byte adc_msb=SPI.transfer(0x00); // MSB of conversion
|
|
byte adc_lsb=SPI.transfer(0x00); // LSB of conversion
|
|
// end ADC sampling
|
|
digitalWrite(Chipselect_Pin,HIGH);
|
|
// Clear bus
|
|
SPI.endTransaction();
|
|
// recover 12 bit value into 16 bit/2byte/uint16_t
|
|
//adc_msb = adc_msb & 0x0F;
|
|
uint16_t adc_result=((uint16_t)adc_msb << 8) | adc_lsb;
|
|
// Return result
|
|
return adc_result;
|
|
} // end of max122xreadADCsingle()
|
|
|
|
|
|
// Reads out MAX122x ADC channel 0 through 3 (MAX1227 and MAX1229)
|
|
struct ADCresults0to3 MAX122x_library::max122xReadADC0to3(uint8_t Chipselect_Pin){
|
|
// Instantiate struct
|
|
struct ADCresults0to3 adcresult0to3_instance;
|
|
// Initialise function variables
|
|
uint16_t results_concat;
|
|
// Utilise SPI bus with appropriate settings
|
|
SPI.beginTransaction(SPI_SETTINGS);
|
|
// Write Setup register
|
|
digitalWrite(Chipselect_Pin,LOW);
|
|
// Write in setup register
|
|
SPI.transfer(MAX122x_SETUP_0);
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
// Loop over all channels
|
|
for(uint8_t i=0; i<=3; i++){
|
|
switch(i){
|
|
case 0 : SPI.transfer(MAX122x_CONVERT_CH0);
|
|
break;
|
|
case 1 : SPI.transfer(MAX122x_CONVERT_CH1);
|
|
break;
|
|
case 2 : SPI.transfer(MAX122x_CONVERT_CH2);
|
|
break;
|
|
case 3 : SPI.transfer(MAX122x_CONVERT_CH3);
|
|
break;
|
|
default: break;
|
|
}
|
|
// Wait for conversion to be finished (incl. int. ref. wake-up time)
|
|
if(i==0){
|
|
delayMicroseconds(SPI_delay_conversionTime);
|
|
}else{
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
}
|
|
byte adc_msb=SPI.transfer(0x00); // MSB of conversion
|
|
byte adc_lsb=SPI.transfer(0x00); // LSB of conversion
|
|
// End ADC sampling
|
|
// Recover 12 bit value into 16 bit/2byte/uint16_t
|
|
//adc_msb = adc_msb & 0x0F;
|
|
results_concat=((uint16_t)adc_msb << 8) | adc_lsb;
|
|
// Write into instantiated struct
|
|
switch(i){
|
|
case 0 : adcresult0to3_instance.result_ch0=results_concat;
|
|
break;
|
|
case 1 : adcresult0to3_instance.result_ch1=results_concat;
|
|
break;
|
|
case 2 : adcresult0to3_instance.result_ch2=results_concat;
|
|
break;
|
|
case 3 : adcresult0to3_instance.result_ch3=results_concat;
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
// Clear bus
|
|
digitalWrite(Chipselect_Pin,HIGH);
|
|
SPI.endTransaction();
|
|
// Return result
|
|
return adcresult0to3_instance;
|
|
} // end of max122xReadADC0to3()
|
|
|
|
// Reads out MAX122x ADC channel 0 through 7 (MAX1227 and MAX1229)
|
|
struct ADCresults0to7 MAX122x_library::max122xReadADC0to7(uint8_t Chipselect_Pin){
|
|
// Instantiate struct
|
|
struct ADCresults0to7 adcresult0to7_instance;
|
|
// Initialise function variables
|
|
uint16_t results_concat;
|
|
// Utilise SPI bus with appropriate settings
|
|
SPI.beginTransaction(SPI_SETTINGS);
|
|
// Write Setup register
|
|
digitalWrite(Chipselect_Pin,LOW);
|
|
// Write in setup register
|
|
SPI.transfer(MAX122x_SETUP_0);
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
// Loop over all channels
|
|
for(uint8_t i=0; i<=7; i++){
|
|
switch(i){
|
|
case 0 : SPI.transfer(MAX122x_CONVERT_CH0);
|
|
break;
|
|
case 1 : SPI.transfer(MAX122x_CONVERT_CH1);
|
|
break;
|
|
case 2 : SPI.transfer(MAX122x_CONVERT_CH2);
|
|
break;
|
|
case 3 : SPI.transfer(MAX122x_CONVERT_CH3);
|
|
break;
|
|
case 4 : SPI.transfer(MAX122x_CONVERT_CH4);
|
|
break;
|
|
case 5 : SPI.transfer(MAX122x_CONVERT_CH5);
|
|
break;
|
|
case 6 : SPI.transfer(MAX122x_CONVERT_CH6);
|
|
break;
|
|
case 7 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
default: break;
|
|
}
|
|
// Wait for conversion to be finished (incl. int. ref. wake-up time)
|
|
if(i==0){
|
|
delayMicroseconds(SPI_delay_conversionTime);
|
|
}else{
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
}
|
|
byte adc_msb=SPI.transfer(0x00); // MSB of conversion
|
|
byte adc_lsb=SPI.transfer(0x00); // LSB of conversion
|
|
// End ADC sampling
|
|
// Recover 12 bit value into 16 bit/2byte/uint16_t
|
|
//adc_msb = adc_msb & 0x0F;
|
|
results_concat=((uint16_t)adc_msb << 8) | adc_lsb;
|
|
// Write into instantiated struct
|
|
switch(i){
|
|
case 0 : adcresult0to7_instance.result_ch0=results_concat;
|
|
break;
|
|
case 1 : adcresult0to7_instance.result_ch1=results_concat;
|
|
break;
|
|
case 2 : adcresult0to7_instance.result_ch2=results_concat;
|
|
break;
|
|
case 3 : adcresult0to7_instance.result_ch3=results_concat;
|
|
break;
|
|
case 4 : adcresult0to7_instance.result_ch4=results_concat;
|
|
break;
|
|
case 5 : adcresult0to7_instance.result_ch5=results_concat;
|
|
break;
|
|
case 6 : adcresult0to7_instance.result_ch6=results_concat;
|
|
break;
|
|
case 7 : adcresult0to7_instance.result_ch7=results_concat;
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
// Clear bus
|
|
digitalWrite(Chipselect_Pin,HIGH);
|
|
SPI.endTransaction();
|
|
// Return result
|
|
return adcresult0to7_instance;
|
|
} // end of max122xReadADC0to7()
|
|
|
|
|
|
// Reads out MAX122x ADC channel 0 through 11 (only MAX1229!)
|
|
struct ADCresults0to11 MAX122x_library::max122xReadADC0to11(uint8_t Chipselect_Pin){
|
|
// Instantiate struct
|
|
struct ADCresults0to11 adcresult0to11_instance;
|
|
// Initialise function variables
|
|
uint16_t results_concat;
|
|
// Utilise SPI bus with appropriate settings
|
|
SPI.beginTransaction(SPI_SETTINGS);
|
|
// Write Setup register
|
|
digitalWrite(Chipselect_Pin,LOW);
|
|
// Write in setup register
|
|
SPI.transfer(MAX122x_SETUP_0);
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
// Loop over all channels
|
|
for(uint8_t i=0; i<=11; i++){
|
|
switch(i){
|
|
case 0 : SPI.transfer(MAX122x_CONVERT_CH0);
|
|
break;
|
|
case 1 : SPI.transfer(MAX122x_CONVERT_CH1);
|
|
break;
|
|
case 2 : SPI.transfer(MAX122x_CONVERT_CH2);
|
|
break;
|
|
case 3 : SPI.transfer(MAX122x_CONVERT_CH3);
|
|
break;
|
|
case 4 : SPI.transfer(MAX122x_CONVERT_CH4);
|
|
break;
|
|
case 5 : SPI.transfer(MAX122x_CONVERT_CH5);
|
|
break;
|
|
case 6 : SPI.transfer(MAX122x_CONVERT_CH6);
|
|
break;
|
|
case 7 : SPI.transfer(MAX122x_CONVERT_CH7);
|
|
break;
|
|
case 8 : SPI.transfer(MAX122x_CONVERT_CH8);
|
|
break;
|
|
case 9 : SPI.transfer(MAX122x_CONVERT_CH9);
|
|
break;
|
|
case 10 : SPI.transfer(MAX122x_CONVERT_CH10);
|
|
break;
|
|
case 11 : SPI.transfer(MAX122x_CONVERT_CH11);
|
|
break;
|
|
default: break;
|
|
}
|
|
// Wait for conversion to be finished (incl. int. ref. wake-up time)
|
|
if(i==0){
|
|
delayMicroseconds(SPI_delay_conversionTime);
|
|
}else{
|
|
delayMicroseconds(SPI_delay_commandSkip);
|
|
}
|
|
byte adc_msb=SPI.transfer(0x00); // MSB of conversion
|
|
byte adc_lsb=SPI.transfer(0x00); // LSB of conversion
|
|
// End ADC sampling
|
|
// Recover 12 bit value into 16 bit/2byte/uint16_t
|
|
//adc_msb = adc_msb & 0x0F;
|
|
results_concat=((uint16_t)adc_msb << 8) | adc_lsb;
|
|
// Write into instantiated struct
|
|
switch(i){
|
|
case 0 : adcresult0to11_instance.result_ch0=results_concat;
|
|
break;
|
|
case 1 : adcresult0to11_instance.result_ch1=results_concat;
|
|
break;
|
|
case 2 : adcresult0to11_instance.result_ch2=results_concat;
|
|
break;
|
|
case 3 : adcresult0to11_instance.result_ch3=results_concat;
|
|
break;
|
|
case 4 : adcresult0to11_instance.result_ch4=results_concat;
|
|
break;
|
|
case 5 : adcresult0to11_instance.result_ch5=results_concat;
|
|
break;
|
|
case 6 : adcresult0to11_instance.result_ch6=results_concat;
|
|
break;
|
|
case 7 : adcresult0to11_instance.result_ch7=results_concat;
|
|
break;
|
|
case 8 : adcresult0to11_instance.result_ch8=results_concat;
|
|
break;
|
|
case 9 : adcresult0to11_instance.result_ch9=results_concat;
|
|
break;
|
|
case 10 : adcresult0to11_instance.result_ch10=results_concat;
|
|
break;
|
|
case 11 : adcresult0to11_instance.result_ch11=results_concat;
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
// Clear bus
|
|
digitalWrite(Chipselect_Pin,HIGH);
|
|
SPI.endTransaction();
|
|
// Return result
|
|
return adcresult0to11_instance;
|
|
} // end of max122xReadADC0to11()
|
|
|
|
|
|
float MAX122x_library::max122xFloatToVoltage(uint16_t adc_raw_value){
|
|
static float v_ref = 2.5; // [V] ADC internal voltage reference
|
|
static uint16_t adc_bit = 4095; // [bit] 2^12 bit resolution
|
|
return (float(adc_raw_value)*v_ref/adc_bit);
|
|
} // End of max122xFloatToVoltage
|