예제 #1
2
/*
 * 	to sort a band, we have
 */
void	band::sortBand (void) {
int	MadeChange = true;
int	i;
/*
 * 	just a simple bubblesort, since the amount of elements
 * 	is limited, and the function is only called on set up
 */
	while (MadeChange) {
	   MadeChange = false;
	   for (i = 0; i < amount - 1; i ++)
	      if (getFrequency (i) > getFrequency (i + 1)) {
	         int f1, v1;
	         f1 = getFrequency (i + 1);
	         v1 = getVoltage   (i + 1);
	         setFrequency (i + 1, getFrequency (i));
	         setVoltage   (i + 1, getVoltage   (i));
	         setFrequency (i, f1);
	         setVoltage   (i, v1);
	         MadeChange = true;
	      }
	}

	setLowerBound (getFrequency (0));
	setUpperBound (getFrequency (amount - 1));
}
void controlCharging(void) {
  float BAT1 = getVoltage(BAT1_ID);
  float BAT2 = getVoltage(BAT2_ID);
  float BAT3 = getVoltage(BAT3_ID);

  checkBatteryCharging(BAT1, PANEL1_ID);
  checkBatteryCharging(BAT2, PANEL2_ID);
  checkBatteryCharging(BAT3, DCDC1_ID);
}
예제 #3
1
uint8_t ProgramData::printVoltageString() const
{
    if(battery.type == Unknown) {
        lcdPrintVoltage(getVoltage(), 7);
        return 7;
    } else {
        uint8_t r = 5+2+1;
        lcdPrintVoltage(getVoltage(), 5);
        lcdPrintChar('/');
        lcdPrintUInt(battery.cells);
        lcdPrintChar('C');
        return r;
    }
}
예제 #4
1
파일: isr.c 프로젝트: azizbahri/Darkholme
void ISR_BATTERY_CHECK(void)
{

	static byte bLowBatteryCount;
	GB_ADC0_VOLTAGE = getVoltage();

	//if (  GB_ADC0_VOLTAGE <= VOLTAGE_LEVEL_0 ) {
	if (  GB_ADC0_VOLTAGE <= VOLTAGE_LEVEL_1 && GB_ADC0_VOLTAGE > 130) {
		if (bLowBatteryCount < LOW_BATTERY_COUNT) bLowBatteryCount++;
	}
	else {
		bLowBatteryCount = 0;
	}

	if ( bLowBatteryCount == LOW_BATTERY_COUNT  )
	{
		setBuzzerPlayLength(SOUND_LOW_VOLTAGE_LENGTH);
		setBuzzerData(SOUND_LOW_VOLTAGE_DATA);


		if(!getBuzzerState())
		{

			PlayBuzzer();
		}
	}

}
예제 #5
1
파일: IrSensor.cpp 프로젝트: pmrobotix/PMX
int IrSensor::getDistance()
{
	try
	{
		voltage_ = getVoltage();
		distanceMm_ = gp2Convert(type_, voltage_);

		logger().debug() << "getDistance type="
				<< type_
				<< " "
				<< adcPin_
				<< " dist="
				<< distanceMm_
				<< " v="
				<< voltage_
				<< logs::end;
	} catch (logs::Exception * e)
	{
		logger().error() << "Exception IrSensor getDistance: " << e->what() << logs::end;
	}
	if (distanceMm_ >= 9999.0)
	{
		distanceMm_ = 9999.0;
	}
	return (int) distanceMm_;
}
예제 #6
1
int QBatteryInfoPrivate::voltage(int battery)
{
    if (!watchVoltage)
        return getVoltage(battery);

    return voltages.value(battery);
}
예제 #7
1
/*******************

Eens hij aan het algoritme begonnen is, gaat hij het blijven volhouden tot hij klaar is met laden tenzij de state aangepast wordt. 

*******************/
int charge_NiMH(int socLoad){
	int V_bat;
	int sleepTime,sleepTime_fin;
	
	init_V_max();
	setCurrentCharger(C);
	// Slaaptijd tussen opeenvolgende metingen, in milliseconden
	sleepTime = 100;
	sleepTime_fin =5000;

	while (getLoadFactor()>0) {
		setLEDS(getLoadFactor());
		if (isAtChargeLimit(socLoad)) return 2;
		V_bat=getVoltage();
	
		if(V_max<V_bat){
			V_max=V_bat;
		}
	
		if(V_bat<V_max*0.9975){
			//hoe kan je controleren of dit 5 sec lang zo blijft (andere tijdsduur is ook goed, maar men stelt 5 sec voor)
			usleep(sleepTime_fin*1000);
			if(V_bat<V_max*0.9975){
				return 1;
			}
		}

		usleep(sleepTime*1000);
	}
	return 0;
}
void securityCheck(void) {
  for (int i=0; i < countVoltagePins; i++) {
    if (getVoltage(i) > BAT_ALARM_HIGH) {
      die();
    }
  }
}
double NoiseLevelSensor::averageVoltage() {
  double sum = 0;
  for (int i = 0; i < _bufferSize; i++) {
    sum = sum + getVoltage(_buffer[i]);
  }
  double avg = sum / ((double) _bufferSize);
  return avg;
}
double NoiseLevelSensor::stdevVoltage() {
  double m = averageVoltage();
  double sum = 0;
  for (int i = 0; i < _bufferSize; i++) {
    sum = sum + pow(getVoltage(_buffer[i]) - m, 2);
  }
  return sqrt( (1/((double) _bufferSize)) * sum );
}
void BatteryFioVThree::getVoltage(uint8_t* voltage) {
	double v = getVoltage();
	
	//just get the whole number
	voltage[0] = (uint8_t)floor(v);
	
	//just get the decimal part, shift it by 2 places, then round to the nearest int
	voltage[1] = round((v - voltage[0]) * 100);
}
예제 #12
1
void testTask(void *pvParameters) {
	for (;;) {
		Serial_print("Voltage: ");
		Serial_printInteger(getVoltage(ADC_readValue(0)), 10);
		Serial_print("V\n");

		vTaskDelay(1000);
	}

	vTaskDelete(NULL);
}
float Photoresistor::read(Photoresistor::Unit unit) {
	switch (unit)
    {
    case Photoresistor::VOLT:
        return getVoltage();
        break;
    case Photoresistor::LUX:
        return getLightLevel();
        break;
    }
}
예제 #14
1
파일: bq34z100.cpp 프로젝트: Ralim/BQ34Z100
uint16_t bq34z100::CalibrateVoltageDivider(uint16_t currentVoltage)
{
    if(currentVoltage<5000)
        return 0;
//So do this we set the voltage divider to 1.5 Times the current pack voltage (to start with)
 float setVoltage =   ((float)readVDivider());
 //chg104Table((uint16_t)setVoltage);//set voltage divider
 float readVoltage = (float)getVoltage();
float newSetting = (currentVoltage/readVoltage)*setVoltage;
chg104Table((uint16_t)newSetting,0,0);//set new divider ratio
return (uint16_t)newSetting;
}
boolean BatteryFioVThree::update() {
	boolean rv = false;
	double voltage = getVoltage();
	//logic here is that the 3.7V lipo battery should not be able to reach over CHARGING_THRESHOLD volts
	//so if that is the case we're going to assume we are not battery powered
	_chargeState = (voltage > CHARGING_THRESHOLD ? 1 : 0);
	//logic here is that if the 3.7V lipo battery goes under LOW_BATTERY_THRESHOLD volts
	//then we're going to alert
	_lowBatteryAlert = (voltage < LOW_BATTERY_THRESHOLD ? true : false);
		
	return rv;
}
예제 #16
1
uint16_t ProgramData::getMaxIc() const
{
    uint32_t i;
    uint16_t v;
    v = getVoltage(VCharge);
    i = MAX_CHARGE_P;
    i *= ANALOG_VOLT(1);
    i /= v;

    if(i > MAX_CHARGE_I)
        i = MAX_CHARGE_I;
    return i;
}
예제 #17
1
double Adc::getSampledVoltage(byte channel, uint8_t numSamples)
{
	double adcVoltage = 0;

	for (int i = 0; i < numSamples; i++)
	{
		adcVoltage += getVoltage(channel);
	}

	adcVoltage /= numSamples;

	return adcVoltage;
}
예제 #18
1
char* slave_read( unsigned ch )
{
  double val = 50.0 + (getVoltage(ADC_3, 5.0) - 2.5) * 100.0;
  static char str[20];
  str[0] = 't'; str[1] = 'e'; str[2] = 'm'; str[3] = 'p';
  str[4] = ':';
  dtostrf( val, 5, 3, &str[5] );
  str[10] = ':';
  str[11] = 'F';
  str[12] = '\n';
  str[13] = 0;
  return str;
};
void displayVoltages(){
  char buffer[BUFSIZE];

  lcd.setCursor(0, 1);
  
  for (int i=0; i < countVoltagePins; i++) {
    ftoa(buffer, getVoltage(i), 1);
    lcd.print(buffer);
    lcd.print(" ");
  }

  /* Serial debug */

  Serial.print(millis());
  Serial.print(",");
  
  for (int i=0; i < countVoltagePins; i++) {
    Serial.print(getVoltage(i));
    Serial.print(",");
  }
  
  Serial.println();
}
float AccelerometerADXL335::getAcceleration(int _pin, int _n_readings, float _bias)
{
    //local variables
    float volts, accel; 
    
    //get raw voltage at incicated pin
    volts = getVoltage(_pin, _n_readings);
    
    //convert to acceleration [m/s^2]
    accel = voltage2acceleration(volts, _bias); 
    
    //return
    return accel; 

}
예제 #21
0
파일: hip9011.cpp 프로젝트: rusefi/rusefi
static void showHipInfo(void) {
	if (!CONFIGB(isHip9011Enabled)) {
		scheduleMsg(logger, "hip9011 driver not active");
		return;
	}

	printSpiState(logger, boardConfiguration);
	scheduleMsg(logger, "enabled=%s state=%s bore=%.2fmm freq=%.2fkHz PaSDO=%d",
			boolToString(CONFIGB(isHip9011Enabled)),
			getHip_state_e(instance.state),
			engineConfiguration->cylinderBore, getHIP9011Band(PASS_HIP_PARAMS),
			engineConfiguration->hip9011PrescalerAndSDO);

	char *outputName = getPinNameByAdcChannel("hip", engineConfiguration->hipOutputChannel, hipPinNameBuffer);

	scheduleMsg(logger, "band_index=%d gain %.2f/index=%d output=%s", instance.currentBandIndex, engineConfiguration->hip9011Gain, instance.currentGainIndex,
			outputName);
	scheduleMsg(logger, "integrator index=%d knockVThreshold=%.2f knockCount=%d maxKnockSubDeg=%.2f",
	            instance.currentIntergratorIndex, engineConfiguration->knockVThreshold,
	            engine->knockCount, engineConfiguration->maxKnockSubDeg);

	const char * msg = instance.invalidHip9011ResponsesCount > 0 ? "NOT GOOD" : "ok";
	scheduleMsg(logger, "spi=%s IntHold@%s/%d response count=%d incorrect response=%d %s",
			getSpi_device_e(engineConfiguration->hip9011SpiDevice),
			hwPortname(CONFIGB(hip9011IntHoldPin)),
			CONFIGB(hip9011IntHoldPinMode),
			instance.correctResponsesCount, instance.invalidHip9011ResponsesCount,
			msg);
	scheduleMsg(logger, "CS@%s updateCount=%d", hwPortname(CONFIGB(hip9011CsPin)), instance.settingUpdateCount);

#if EFI_PROD_CODE
	scheduleMsg(logger, "hip %.2fv/last=%.2f@%s/max=%.2f adv=%d",
			engine->knockVolts,
			getVoltage("hipinfo", engineConfiguration->hipOutputChannel),
			getPinNameByAdcChannel("hip", engineConfiguration->hipOutputChannel, pinNameBuffer),
			hipValueMax,
			CONFIGB(useTpicAdvancedMode));
	scheduleMsg(logger, "mosi=%s", hwPortname(getMosiPin(engineConfiguration->hip9011SpiDevice)));
	scheduleMsg(logger, "miso=%s", hwPortname(getMisoPin(engineConfiguration->hip9011SpiDevice)));
	scheduleMsg(logger, "sck=%s", hwPortname(getSckPin(engineConfiguration->hip9011SpiDevice)));
#endif /* EFI_PROD_CODE */

	scheduleMsg(logger, "start %.2f end %.2f", engineConfiguration->knockDetectionWindowStart,
			engineConfiguration->knockDetectionWindowEnd);

	hipValueMax = 0;
	engine->printKnockState();
}
예제 #22
0
char* slave_read( unsigned ch )
{
  double val = getVoltage(ADC_3, 5.0);
  static char str[20];
  int i = 0;
  str[i++] = 'a'; str[i++] = 'd'; str[i++] = 'c';
  str[i++] = ':';
  dtostrf( val, 5, 3, &str[i] );
  i += 5;
  str[i++] = ':';
  str[i++] = 'r';
  str[i++] = 'a';
  str[i++] = 'w';
  str[i++] = '\n';
  str[i++] = 0;
  return str;
};
예제 #23
0
파일: cj125.cpp 프로젝트: rusefi/rusefi
static float getUa() {
#if ! EFI_UNIT_TEST
	if (CONFIG(cj125ua) != EFI_ADC_NONE) {
#if EFI_PROD_CODE
		if (engineConfiguration->cj125isUaDivided) {
			return getVoltageDivided("cj125ua", CONFIG(cj125ua));
		} else {
			return getVoltage("cj125ua", CONFIG(cj125ua));
		}
#endif /* EFI_PROD_CODE */
	}

	return 0.0f;
#else /* EFI_UNIT_TEST */
	return 0;
#endif /* EFI_UNIT_TEST */
}
예제 #24
0
파일: maingtk.c 프로젝트: emilw/MixedStuff
/**
* @brief Event method that is fired when it's time to calculate the output of the input
*
* Event method that fires when the button is clicked. This calculates the result of the electrolib functionality.
* @return void
**/
static void calculateAndPresentOutput(){
    int RESISTANCEOUTPUTLABELROW = 6;
    int VOLTAGEOUTPUTLABELROW = 7;
    int E12OUTPUTLABELROW = 8;
    float* replaceResistanceValues = calloc(3,sizeof(float));

    float totalresistance = calc_resistance(getNumberOfComponents(), getConnectionType(), getResistanceItems());
    float totalpower = calc_power_r(getVoltage(), totalresistance);
    int numberOfResistors = e_resistance(totalresistance, replaceResistanceValues);

    char formatedMessage[100];
    sprintf(formatedMessage, "Ersättningsresistance: %.1f ohm", totalresistance);
    addOutputLabel(_mainGrid, formatedMessage, 1, RESISTANCEOUTPUTLABELROW, 2);
    sprintf(formatedMessage, "Effekt: %.2f W", totalpower);
    addOutputLabel(_mainGrid, formatedMessage, 1, VOLTAGEOUTPUTLABELROW, 2);
    sprintf(formatedMessage, "Ersättningsresistans i E12-serien koppliade i serie: %.0f, %.0f, %.0f", *replaceResistanceValues, *(replaceResistanceValues+1), *(replaceResistanceValues+2));
    addOutputLabel(_mainGrid, formatedMessage, 1, E12OUTPUTLABELROW, 2);
}
예제 #25
0
파일: cj125.cpp 프로젝트: rusefi/rusefi
static float getUr() {
#if ! EFI_UNIT_TEST
	if (CONFIG(cj125ur) != EFI_ADC_NONE) {
#if EFI_PROD_CODE
#ifdef EFI_CJ125_DIRECTLY_CONNECTED_UR
		// in case of directly connected Ur signal from CJ125 to the ADC pin of MCU
		return getVoltage("cj125ur", CONFIG(cj125ur));
#else
		// if a standard voltage division scheme with OpAmp is used
		return getVoltageDivided("cj125ur", CONFIG(cj125ur));
#endif /* EFI_CJ125_DIRECTLY_CONNECTED_UR */
#endif /* EFI_PROD_CODE */
	}
	return 0.0f;
#else /* EFI_UNIT_TEST */
	return 0;
#endif /* EFI_UNIT_TEST */
}
예제 #26
0
void statusTask(void) {
    static time_t last = 100; // Don't begin immediately
    static uint32_t lastDuration = 0;
    if (((getSystemTime() - last) >= STATUSDELAY) && (!(state & STATE_OUTPUT))) {
        last = getSystemTime();
        printf("p%.2f %.2f %.2f\n", orientation.vPitch, orientation.vRoll, orientation.vYaw);
        printf("q%li %li\n", sumFlightTask / countFlightTask, lastDuration);
        printf("r%.2f %.2f\n", pidStates[0].intMin, pidStates[0].intMax);
        printf("s%.2f %.2f\n", pidStates[0].outMin, pidStates[0].outMax);
        printf("t%.3f %.3f %.3f\n", pidStates[0].kp, pidStates[0].ki, pidStates[0].kd);
        printf("u%.2f %.2f\n", pidOutput[PITCH], pidOutput[ROLL]);
        printf("v%i %i %i %i\n", motorSpeed[0], motorSpeed[1], motorSpeed[2], motorSpeed[3]);
        printf("w%.2f\n", orientation.pitch);
        printf("x%.2f\n", orientation.roll);
        printf("y%.2f\n", orientation.yaw);
        printf("z%.2f\n", getVoltage());
        lastDuration = getSystemTime() - last;
    }
}
예제 #27
0
void eapsUta12Port::updateValues()
{
    checkInTimeCount();

    if( _emitVoltage || _emitPower || _emitResistance )
    {
        getVoltage();
    }
    if( _emitCurrent || _emitPower || _emitResistance )
    {
        getCurrent();
    }
    updateNumInTimeValues();

    if( _setValueType != setValueType::setTypeNone
            && _autoAdjust )
    {
        adjustValues();
    }
}
예제 #28
0
static void showHipInfo(void) {
	if (!boardConfiguration->isHip9011Enabled) {
		scheduleMsg(logger, "hip9011 driver not active");
		return;
	}

	printSpiState(logger, boardConfiguration);
	scheduleMsg(logger, "enabled=%s state=%d bore=%fmm freq=%fkHz PaSDO=%d",
			boolToString(boardConfiguration->isHip9011Enabled),
			state,
			engineConfiguration->cylinderBore, getBand(),
			engineConfiguration->hip9011PrescalerAndSDO);

	scheduleMsg(logger, "band_index=%d gain %f/index=%d", currentBandIndex, boardConfiguration->hip9011Gain, currentGainIndex);
	scheduleMsg(logger, "integrator index=%d knockVThreshold=%f knockCount=%d maxKnockSubDeg=%f",
	            currentIntergratorIndex, engineConfiguration->knockVThreshold,
	            engine->knockCount, engineConfiguration->maxKnockSubDeg);

	scheduleMsg(logger, "spi=%s IntHold@%s response count=%d incorrect response=%d",
			getSpi_device_e(hipSpiDevice),
			hwPortname(boardConfiguration->hip9011IntHoldPin),
			correctResponse, invalidResponse);
	scheduleMsg(logger, "CS@%s updateCount=%d", hwPortname(boardConfiguration->hip9011CsPin), settingUpdateCount);

	scheduleMsg(logger, "hip %fv/last=%f@%s/max=%f spiCount=%d adv=%d",
			engine->knockVolts,
			getVoltage("hipinfo", engineConfiguration->hipOutputChannel),
			getPinNameByAdcChannel("hip", engineConfiguration->hipOutputChannel, pinNameBuffer),
			hipValueMax,
			spiCount, boardConfiguration->useTpicAdvancedMode);
	scheduleMsg(logger, "mosi=%s", hwPortname(getMosiPin(hipSpiDevice)));
	scheduleMsg(logger, "miso=%s", hwPortname(getMisoPin(hipSpiDevice)));
	scheduleMsg(logger, "sck=%s", hwPortname(getSckPin(hipSpiDevice)));

	scheduleMsg(logger, "start %f end %f", engineConfiguration->knockDetectionWindowStart,
			engineConfiguration->knockDetectionWindowEnd);

	hipValueMax = 0;
	engine->printKnockState();
}
예제 #29
0
static void printAnalogInfo(void) {
	scheduleMsg(&logger, "analogInputDividerCoefficient: %f", engineConfiguration->analogInputDividerCoefficient);

	printAnalogChannelInfo("hip9011", engineConfiguration->hipOutputChannel);
	printAnalogChannelInfo("fuel gauge", engineConfiguration->fuelLevelSensor);
	printAnalogChannelInfo("TPS", engineConfiguration->tpsAdcChannel);
	printAnalogChannelInfo("pPS", engineConfiguration->pedalPositionChannel);
	if (engineConfiguration->clt.adcChannel != EFI_ADC_NONE) {
		printAnalogChannelInfo("CLT", engineConfiguration->clt.adcChannel);
	}
	if (engineConfiguration->iat.adcChannel != EFI_ADC_NONE) {
		printAnalogChannelInfo("IAT", engineConfiguration->iat.adcChannel);
	}
	if (hasMafSensor()) {
		printAnalogChannelInfo("MAF", engineConfiguration->mafAdcChannel);
	}
	for (int i = 0; i < FSIO_ADC_COUNT ; i++) {
		adc_channel_e ch = engineConfiguration->fsioAdc[i];
		if (ch != EFI_ADC_NONE) {
			printAnalogChannelInfo("fsio", ch);
		}
	}

	printAnalogChannelInfo("AFR", engineConfiguration->afr.hwChannel);
	if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) {
		printAnalogChannelInfo("MAP", engineConfiguration->map.sensor.hwChannel);
	}
	if (hasBaroSensor(PASS_ENGINE_PARAMETER_F)) {
		printAnalogChannelInfo("BARO", engineConfiguration->baroSensor.hwChannel);
	}
	if (engineConfiguration->externalKnockSenseAdc != EFI_ADC_NONE) {
		printAnalogChannelInfo("extKno", engineConfiguration->externalKnockSenseAdc);
	}

	printAnalogChannelInfo("A/C sw", engineConfiguration->acSwitchAdc);
	printAnalogChannelInfo("HIP9011", engineConfiguration->hipOutputChannel);
	printAnalogChannelInfoExt("Vbatt", engineConfiguration->vbattAdcChannel, getVoltage("vbatt", engineConfiguration->vbattAdcChannel),
			engineConfiguration->vbattDividerCoeff);
}
예제 #30
0
파일: waveBot.cpp 프로젝트: 3ygun/WaveBot
// Loop the execute temperature reads and waving actions
void loop() {

  /*
   *  Turn lights on, read temperature, and possibly wave if it's too hot!
   */
  digitalWrite(led2, HIGH); // Turn on the sanity LED
	
	float temperature = getVoltage(tempPin); // Read in the current temperature in voltage form
	temperature = (temperature - .33) * 100; // Convert the temperature from voltage to degrees Celsius
                                           // Remove the 330mV offset and convert
	
	String table = "TemperatureData";  // Gets the appropriate Azure held table the store the temperature data
	char buffer[100];  // Create the buffer string
	snprintf(buffer, sizeof(buffer), "{\"Temperature\":\"%d\"}", &temperature);  // Load the current temperature data into the buffer string
	ams.create(table, buffer); // Add the data to the data to the Azure table 
	
  // Determine if it's hot enough for waveBot to tell you to cool down through a wave
  if (temperature >= 21.1) {  // 21.1 degrees Celsius it 70 degrees Fahrenheit 
    motorSpeed = 210; // Set the arm motors speed
    analogWrite(motorPin, motorSpeed);  // Turn on the motor at the decided speed
    digitalWrite(ledEye1, HIGH);   // Turn ON the LED pins
    digitalWrite(ledEye2, HIGH);   // Turn ON the LED pins
  }

  delay(2500);               // Wait for 2500mS = 2.5 second    
  

  /*
   *  Turn off the lights and motor
   */
  motorSpeed = 0; // Set the motor speed to off
  analogWrite(motorPin, motorSpeed);  // Turn the motor off
  digitalWrite(ledEye1, LOW); // Turn off the 1st eye LED
  digitalWrite(ledEye2, LOW); // Turn off the 2nd eye LED
  digitalWrite(led2, LOW);  // Turn off the sanity LED
  delay(2500);  // Wait for 2.5 second in off mode
}