/**
* @brief Calculate the angle and magnitude of a joystick.
*
* @param js [out] Pointer to a joystick_t structure.
* @param x The raw x-axis value.
* @param y The raw y-axis value.
*/
void calc_joystick_state(struct joystick_t* js, float x, float y) {
float rx, ry, ang;
/*
* Since the joystick center may not be exactly:
* (min + max) / 2
* Then the range from the min to the center and the center to the max
* may be different.
* Because of this, depending on if the current x or y value is greater
* or less than the assoicated axis center value, it needs to be interpolated
* between the center and the minimum or maxmimum rather than between
* the minimum and maximum.
*
* So we have something like this:
* (x min) [-1] ---------*------ [0] (x center) [0] -------- [1] (x max)
* Where the * is the current x value.
* The range is therefore -1 to 1, 0 being the exact center rather than
* the middle of min and max.
*/
rx = applyCalibration(x, js->min.x, js->max.x, js->center.x);
ry = applyCalibration(y, js->min.y, js->max.y, js->center.y);
/* calculate the joystick angle and magnitude */
ang = RAD_TO_DEGREE(atan2f(ry, rx));
js->mag = sqrtf((rx * rx) + (ry * ry));
js->ang = ang + 180.0f;
}
void AbsoluteQuantitation::calculateBiasAndR(
const std::vector<AbsoluteQuantitationStandards::featureConcentration> & component_concentrations,
const String & feature_name,
const String & transformation_model,
const Param & transformation_model_params,
std::vector<double> & biases,
double & correlation_coefficient)
{
// reset biases
biases.clear();
// extract out the calibration points
std::vector<double> concentration_ratios, feature_amounts_ratios;
TransformationModel::DataPoints data;
TransformationModel::DataPoint point;
for (size_t i = 0; i < component_concentrations.size(); ++i)
{
// calculate the actual and calculated concentration ratios
double calculated_concentration_ratio = applyCalibration(component_concentrations[i].feature,
component_concentrations[i].IS_feature,
feature_name,
transformation_model,
transformation_model_params);
double actual_concentration_ratio = component_concentrations[i].actual_concentration/
component_concentrations[i].IS_actual_concentration;
concentration_ratios.push_back(component_concentrations[i].actual_concentration);
// extract out the feature amount ratios
double feature_amount_ratio = calculateRatio(component_concentrations[i].feature,
component_concentrations[i].IS_feature,
feature_name)/component_concentrations[i].dilution_factor;
feature_amounts_ratios.push_back(feature_amount_ratio);
// calculate the bias
double bias = calculateBias(actual_concentration_ratio, calculated_concentration_ratio);
biases.push_back(bias);
point.first = actual_concentration_ratio;
point.second = feature_amount_ratio;
data.push_back(point);
}
// apply weighting to the feature amounts and actual concentration ratios
TransformationModel tm(data, transformation_model_params);
tm.weightData(data);
std::vector<double> concentration_ratios_weighted, feature_amounts_ratios_weighted;
for (size_t i = 0; i < data.size(); ++i)
{
concentration_ratios_weighted.push_back(data[i].first);
feature_amounts_ratios_weighted.push_back(data[i].second);
}
// calculate the R2 (R2 = Pearson_R^2)
correlation_coefficient = Math::pearsonCorrelationCoefficient(
concentration_ratios_weighted.begin(), concentration_ratios_weighted.begin() + concentration_ratios_weighted.size(),
feature_amounts_ratios_weighted.begin(), feature_amounts_ratios_weighted.begin() + feature_amounts_ratios_weighted.size()
);
}
/*
* getOrientationVector method:
* store calibrated and scaled accelerometer data(x,y,z) in '&data' parameter
*/
void HMC5883L::getMagVector(float (&data)[3])
{
read();
applyCalibration();
scaleGain();
memcpy(data, magVector, sizeof(data));
}
CompassVec Compass::getMeasurements()
{
byte buf[6];
//writeReg(2, 1);
//delay(10);
readRegs(COMPASS_REG_DATA_OUT_X, 6, buf);
float x, y, z;
x = (float)makeI16(buf[0], buf[1]);
z = (float)makeI16(buf[2], buf[3]);
y = (float)makeI16(buf[4], buf[5]);
CompassVec v(x, y, z);
return applyCalibration(v);
}
void main()
{
byte writeIndex = 0;
byte i;
long l;
TRISB = 0xFFFF; /* All inputs */
LAT_BATT1_CTL = BATT_ENABLE;
LAT_BATT2_CTL = BATT_ENABLE;
LAT_BATT3_CTL = BATT_ENABLE;
LAT_BATT4_CTL = BATT_ENABLE;
#ifdef BBR2
LAT_BATT5_CTL = ~BATT_ENABLE;
#else
LAT_BATT5_CTL = BATT_ENABLE;
#endif
LAT_BATT6_CTL = BATT_ENABLE;
TRIS_BATT1_CTL = TRIS_OUT;
TRIS_BATT2_CTL = TRIS_OUT;
TRIS_BATT3_CTL = TRIS_OUT;
TRIS_BATT4_CTL = TRIS_OUT;
#ifdef BBR2
TRIS_BATT5_CTL = TRIS_IN;
#else
TRIS_BATT5_CTL = TRIS_OUT;
#endif
TRIS_BATT6_CTL = TRIS_OUT;
TRIS_BATT1 = TRIS_IN;
TRIS_BATT2 = TRIS_IN;
TRIS_BATT3 = TRIS_IN;
TRIS_BATT4 = TRIS_IN;
TRIS_BATT5 = TRIS_IN;
TRIS_BATT6 = TRIS_IN;
TRIS_WTRSEN = TRIS_IN;
LAT_PWRKILL = ~PWRKILL_ON;
TRIS_PWRKILL = TRIS_OUT;
TRIS_LED_STA = TRIS_OUT;
TRIS_LED_BATTLOW = TRIS_OUT;
LAT_LED_STA = LED_ON;
LAT_LED_BATTLOW = LED_ON;
initBus();
LAT_LED_STA = LED_ON;
LAT_LED_BATTLOW = ~LED_ON;
// while(1);
initADC();
initI2C();
initBattlowLight();
#ifdef HAS_UART
initInterruptUarts();
#endif
for(l=0; l<50000; l++);
LAT_LED_STA = LED_ON;
LAT_LED_BATTLOW = ~LED_ON;
for(l=0; l<50000; l++);
// LAT_PWRKILL = PWRKILL_ON;
LAT_LED_STA = ~LED_ON;
for(i=0; i<16; i++)
cfgRegs[i] = 65;
byte i2cErrCount = 0;
while(1)
{
// checkBus();
/* Give it a second */
// for(l=0; l<10000; l++);
byte rx = readTemp(0x9E);
/* Read error */
if(rx == 255)
{
if(i2cErrCount < 10)
i2cErrCount++;
else
myTemperature = 255;
initI2C();
} else
{
i2cErrCount = 0;
myTemperature = rx;
}
static const byte vADCs[]={ADC_B1V, ADC_B2V, ADC_B3V, ADC_B4V, ADC_B5V, ADC_B6V, ADC_26V};
/* Measure battery voltages */
for(i=0; i < 7; i++) {
#ifdef BBR2
/* There is no fifth battery in BBR2, so skip it */
if(i == 4) { vBatt[4]= 0; continue; }
#endif
setADC(vADCs[i]);
vBatt[i] = applyCalibration(readADC(), CAL_V_A, CAL_V_B);
}
/* Maintain running averages of the I sensors */
for(i=0; i < BATT_COUNT; i++) {
#ifdef BBR2
/* There is no fifth battery in BBR2, so skip it */
if(i == 4) { iADCVal[4][writeIndex] = 0; continue; }
#endif
setADC(iADCs[i]);
iADCVal[i][writeIndex] = readADC();
}
writeIndex++;
if(writeIndex >= IHISTORY_SIZE)
writeIndex = 0;
/* Calculate running averages of the battery currents */
for(i=0; i < BATT_COUNT; i++) {
#ifdef BBR2
/* There is no fifth battery in BBR2, so skip it. */
if(i == 4) { iBatt[4] = 0; continue; }
#endif
iBatt[i] = applyCalibration(avgRow(i), CAL_I12V_A, CAL_I12V_B);
}
}
}
void AbsoluteQuantitation::quantifyComponents(FeatureMap& unknowns)
{
//Potential Optimizations: create a map for each unknown FeatureMap
// to reduce multiple loops
// initialize all other variables
Feature empty_feature;
size_t IS_component_it, IS_component_group_it;
// // iterate through the unknowns
// for (size_t i = 0; i < unknowns.size(); i++)
// {
// iterate through each component_group/feature
for (size_t feature_it = 0; feature_it < unknowns.size(); ++feature_it)
{
String component_group_name = (String)unknowns[feature_it].getMetaValue("PeptideRef");
Feature unknowns_quant_feature;
// iterate through each component/sub-feature
for (size_t sub_it = 0; sub_it < unknowns[feature_it].getSubordinates().size(); ++sub_it)
{
String component_name = (String)unknowns[feature_it].getSubordinates()[sub_it].getMetaValue("native_id");
// apply the calibration curve to components that are in the quant_method
if (quant_methods_.count(component_name)>0)
{
double calculated_concentration = 0.0;
std::map<String,AbsoluteQuantitationMethod>::iterator quant_methods_it = quant_methods_.find(component_name);
String quant_component_name = quant_methods_it->second.getComponentName();
String quant_IS_component_name = quant_methods_it->second.getISName();
String quant_feature_name = quant_methods_it->second.getFeatureName();
if (quant_IS_component_name != "")
{
// look up the internal standard for the component
bool IS_found = false;
// Optimization: 90% of the IS will be in the same component_group/feature
for (size_t is_sub_it = 0; is_sub_it < unknowns[feature_it].getSubordinates().size(); ++is_sub_it)
{
String IS_component_name = (String)unknowns[feature_it].getSubordinates()[is_sub_it].getMetaValue("native_id");
if (quant_IS_component_name == IS_component_name)
{
IS_found = true;
IS_component_group_it = feature_it;
IS_component_it = is_sub_it;
break;
}
}
if (!IS_found)
{// expand IS search to all components
// iterate through each component_group/feature
for (size_t is_feature_it = 0; is_feature_it < unknowns.size(); ++is_feature_it)
{
//iterate through each component/sub-feature
for (size_t is_sub_it = 0; is_sub_it < unknowns[is_feature_it].getSubordinates().size(); ++is_sub_it)
{
String IS_component_name = (String)unknowns[is_feature_it].getSubordinates()[is_sub_it].getMetaValue("native_id");
if (quant_IS_component_name == IS_component_name)
{
IS_found = true;
IS_component_group_it = is_feature_it;
IS_component_it = is_sub_it;
break;
}
}
if (IS_found)
{
break;
}
}
}
if (IS_found)
{
String transformation_model = quant_methods_it->second.getTransformationModel();
Param transformation_model_params = quant_methods_it->second.getTransformationModelParams();
calculated_concentration = applyCalibration(
unknowns[feature_it].getSubordinates()[sub_it],
unknowns[IS_component_group_it].getSubordinates()[IS_component_it],
quant_feature_name,transformation_model,transformation_model_params);
}
else
{
LOG_INFO << "Component " << component_name << " IS " << quant_IS_component_name << " was not found.";
LOG_INFO << "No concentration will be calculated.";
}
}
else
{
String transformation_model = quant_methods_it->second.getTransformationModel();
Param transformation_model_params = quant_methods_it->second.getTransformationModelParams();
calculated_concentration = applyCalibration(
unknowns[feature_it].getSubordinates()[sub_it],
empty_feature,
quant_feature_name,transformation_model,transformation_model_params);
}
// add new metadata (calculated_concentration, concentration_units) to the component
unknowns[feature_it].getSubordinates()[sub_it].setMetaValue("calculated_concentration",calculated_concentration);
String concentration_units = quant_methods_it->second.getConcentrationUnits();
unknowns[feature_it].getSubordinates()[sub_it].setMetaValue("concentration_units",concentration_units);
// calculate the bias?
}
else
{
LOG_INFO << "Component " << component_name << " does not have a quantitation method.";
LOG_INFO << "No concentration will be calculated.";
unknowns[feature_it].getSubordinates()[sub_it].setMetaValue("calculated_concentration","");
unknowns[feature_it].getSubordinates()[sub_it].setMetaValue("concentration_units","");
}
}
}
// }
}