void CONFEH::getMeasurements( float &storageVoltage, float &solarVoltage, float &solarCurrent ) { // Configure LTC2990 for Current-Voltage-Voltage measurement (using 1 ohm sense resistor) setLTC_Config( celsius, single, V1_V2V3V4, 1, 0 ); triggerConversion(); // Read the storage voltage if ( storageType == DLC ) readVoltage( storageVoltage, Voltage_V3 ); else if ( storageType == BAT ) readVoltage( storageVoltage, Voltage_V4 ); // Read the solar current readCurrent( solarCurrent, Current_V12 ); // Check for LTC3105 reset condition if ( solarCurrent < 0.001 ) { // Reset LTC3105 setLTC3105_EN( false ); setLTC3105_EN( true ); } // Re-configure LTC2990 for pure voltage measurement setLTC_Config( celsius, single, V1V2V3V4, 1, 0 ); triggerConversion(); // Read the solar voltage readVoltage( solarVoltage, Voltage_V1 ); }
float getVoltage(int id) { float voltage = readVoltage(id); // Substract voltages from previous batteries (if any) in the serial bank if (id > 0) { return voltage - readVoltage(id-1); } else { return voltage; } }
bool SuperIOMonitor::updateSensor(const char *key, const char *type, unsigned char size, SuperIOSensorGroup group, unsigned long index) { long value = 0; switch (group) { case kSuperIOTemperatureSensor: value = readTemperature(index); break; case kSuperIOVoltageSensor: value = readVoltage(index); break; case kSuperIOTachometerSensor: value = readTachometer(index); break; default: break; } if (strcmp(type, TYPE_FP2E) == 0) { value = encode_fp2e(value); } else if (strcmp(type, TYPE_FPE2) == 0) { value = encode_fpe2(value); } if (kIOReturnSuccess != fakeSMC->callPlatformFunction(kFakeSMCSetKeyValue, true, (void*)key, (void*)size, (void*)&value, 0)) return false; return true; }
bool LPCSensors::willReadSensorValue(FakeSMCSensor *sensor, float *outValue) { if (sensor) { switch (sensor->getGroup()) { case kFakeSMCTemperatureSensor: *outValue = sensor->getOffset() + readTemperature(sensor->getIndex()); break; case kFakeSMCVoltageSensor: { float v = readVoltage(sensor->getIndex()); *outValue = sensor->getOffset() + v + (v - sensor->getReference()) * sensor->getGain(); break; } case kFakeSMCTachometerSensor: *outValue = readTachometer(sensor->getIndex()); break; case kLPCSensorsFanManualSwitch: case kLPCSensorsFanMinController: case kLPCSensorsFanTargetController: default: // Just return stored key value return false; } return true; } return false; }
/****************************************************************************** * @fn sendReport * * @brief Send sensor report * * @param none * * @return none */ static void sendReport(void) { uint8 pData[SENSOR_REPORT_LENGTH]; static uint8 reportNr=0; uint8 txOptions; // Read and report temperature value pData[SENSOR_TEMP_OFFSET] = readTemp(); // Read and report voltage value pData[SENSOR_VOLTAGE_OFFSET] = readVoltage(); pData[SENSOR_PARENT_OFFSET] = HI_UINT16(parentShortAddr); pData[SENSOR_PARENT_OFFSET + 1] = LO_UINT16(parentShortAddr); // Set ACK request on each ACK_INTERVAL report // If a report failed, set ACK request on next report if ( ++reportNr<ACK_REQ_INTERVAL && reportFailureNr==0 ) { txOptions = AF_TX_OPTIONS_NONE; } else { txOptions = AF_MSG_ACK_REQUEST; reportNr = 0; } // Destination address 0xFFFE: Destination address is sent to previously // established binding for the commandId. zb_SendDataRequest( 0xFFFE, SENSOR_REPORT_CMD_ID, SENSOR_REPORT_LENGTH, pData, 0, txOptions, 0 ); }
void Battery::test() { printMessage(BATTERY_TEST_MESSAGE); printMessage(BATTERY_MESSAGE); float v = readVoltage(); Serial.println(v); // the voltage must be between 4.8 and 5.1 to pass the test if (v < 5.08 && v > 4.92) printMessage(TEST_PASS_MESSAGE); else printMessage(TEST_FAIL_MESSAGE); }
void displayVoltages2(){ char buffer[BUFSIZE]; lcd.setCursor(0, 0); for (int i=0; i < countVoltagePins; i++) { ftoa(buffer, readVoltage(i), 1); lcd.print(buffer); lcd.print(" "); } }
int main (void) { int on=0, ID, calb; int batt_voltage = 0; //init(); //ID = readID(); //calb = readCalibration(); // GPIO_SetValue(RED_LED_PORT, RED_LED_BIT,1); int i = 0; /* Used in main loop */ uint32_t value = 0xaa; setup_ports(); sc_time_t one_sec_timer = sc_get_timer(); /* Initialise the timer variable */ sc_time_t test_in_timer = sc_get_timer(); /* Initialise the timer variable */ /* Set LEDs to known states, i.e. on */ red_led(ON); yellow_led(ON); GPIO_SetValue(CAN_EN_PORT, CAN_EN_BIT, ON); scandal_register_in_channel_handler(0, &in_channel_0_handler); /* This is the main loop, go for ever! */ while (1) { /* This checks whether there are pending requests from CAN, and sends a heartbeat message. * The heartbeat message encodes some data in the first 4 bytes of the CAN message, such as * the number of errors and the version of scandal */ handle_scandal(); /* * scandal_send_channel(TELEM_LOW, ID_VOLT, readVoltage()); * scandal_send_channel(TELEM_LOW, ID_TEMP, readTemperature()); * scandal_send_channel(TELEM_LOW, ID_VOLT, readVoltage()); */ if(sc_get_timer() >= one_sec_timer + 1000) { toggle_red_led(); toggle_yellow_led(); one_sec_timer = sc_get_timer(); batt_voltage = readVoltage(); scandal_send_channel(TELEM_LOW, // priority 0, // channel num batt_voltage // value ); } } }
void Battery::setup(BatteryType batteryType, float batteryMonitorCalibration, float threshold) { _isLow = false; _batteryType = batteryType; _calibration = batteryMonitorCalibration; _threshold = threshold; if (batteryType == BATTERY_TYPE_LIPO) { // measure the LIPO voltage and work out the number of cells float v = readVoltage(); _numberOfCells = ((v < LIPO_CELL_DETECT_THRESHOLD) ? 2 : 3); } }
/****************************************************************************** * @fn sendReport * * @brief Send sensor report * * @param none * * @return none */ static void sendReport(void) { uint8 pData[SENSOR_REPORT_LENGTH]; static uint8 reportNr = 0; uint8 txOptions; // Read and report temperature value pData[SENSOR_TEMP_OFFSET] = readTemp(); // Read and report voltage value pData[SENSOR_VOLTAGE_OFFSET] = readVoltage(); pData[SENSOR_PARENT_OFFSET] = HI_UINT16(parentShortAddr); pData[SENSOR_PARENT_OFFSET + 1] = LO_UINT16(parentShortAddr); pData[BUTTON_PARENT_OFFSET+1] = MCU_IO_GET(0,1); // HalUARTWrite(HAL_UART_PORT_0,pData,SENSOR_REPORT_LENGTH); // HalUARTWrite(HAL_UART_PORT_1,pData,SENSOR_REPORT_LENGTH); int test = MCU_IO_GET(0,1); if( MCU_IO_GET(0,1) > 0){ MCU_IO_SET_LOW(0, 0); } else { MCU_IO_SET_HIGH(0, 0); } MCU_IO_SET_LOW(0, 1); // Set ACK request on each ACK_INTERVAL report // If a report failed, set ACK request on next report if ( ++reportNr<ACK_REQ_INTERVAL && reportFailureNr == 0 ) { txOptions = AF_TX_OPTIONS_NONE; } else { txOptions = AF_MSG_ACK_REQUEST; reportNr = 0; } // Destination address 0xFFFE: Destination address is sent to previously // established binding for the commandId. //printf("%i %i",pData[SENSOR_TEMP_OFFSET],oldValue); if(timeDone >= 60000){ timeDone += 1; } if(pData[SENSOR_TEMP_OFFSET] != oldValue && timeDone >= 60000){ oldValue = pData[SENSOR_TEMP_OFFSET]; zb_SendDataRequest( 0xFFFE, SENSOR_REPORT_CMD_ID, SENSOR_REPORT_LENGTH, pData, 0, txOptions, 0 ); timeDone = 0; } else { timeDone += myReportPeriod; } }
// There is a small amount of hysteresis in this function to stop the alarm from // intermittently switching on and off near the voltage threshold. boolean Battery::isLow() { if (_batteryType == BATTERY_TYPE_NONE) return false; // TODO: would be better to abstract the hysteresis calculation here boolean low; double v = readVoltage(); if (_batteryType == BATTERY_TYPE_LIPO) { if (_isLow) low = ((v / _numberOfCells) < (_threshold + BATTERY_MONITOR_HYSTERESIS)); else low = ((v / _numberOfCells) < _threshold); } if (_batteryType == BATTERY_TYPE_NIMH) { if (_isLow) low = (v < (_threshold + BATTERY_MONITOR_HYSTERESIS)); else low = (v < _threshold); } _isLow = low; return low; }
static msg_t Thread2(void *arg) { (void)arg; chRegSetThreadName("ADC blinker"); while (TRUE) { #ifdef DEBUG_TO_SERIAL chprintf( (BaseSequentialStream *)&SD2, "\r\nADC sampling", NULL ); #endif if (console == 1) { gwinPrintf(ghc, "\r\nADC sampling"); } palTogglePad(GPIOD, GPIOD_LED4); /* Orange. */ chSysLockFromIsr(); readADC(); readVoltage(); readICU(); chSysUnlockFromIsr(); chThdSleepMilliseconds(1000); } return 0; }
float SuperIOPlugin::getSensorValue(FakeSMCSensor *sensor) { float value = 0; if (sensor) { switch (sensor->getGroup()) { case kFakeSMCTemperatureSensor: value = sensor->getOffset() + readTemperature(sensor->getIndex()); break; case kFakeSMCVoltageSensor: value = readVoltage(sensor->getIndex()); value = sensor->getOffset() + value + (value - sensor->getReference()) * sensor->getGain(); break; case kFakeSMCTachometerSensor: value = readTachometer(sensor->getIndex()); break; } } return value; }
int main(void) { // Make sure all interrupts are disabled. // This must be the first step, because in some cases interupt vectors are totally wrong // (e.g. when we get here after a soft reboot from another application) msp430ClearAllInterruptsNosave(); msp430WatchdogStop(); ledsInit(); flashLeds(LEDS_BOOTLOADER_START); BootParams_t bootParams; intFlashRead(BOOT_PARAMS_ADDRESS, &bootParams, sizeof(bootParams)); ++bootParams.bootRetryCount; if (bootParams.bootRetryCount > MAX_RETRY_COUNT) { bootParams.bootRetryCount = 0; bootParams.extFlashAddress = GOLDEN_IMAGE_ADDRESS; bootParams.doReprogramming = 1; } // make sure internal flash address is sane if (bootParams.intFlashAddress == 0xffff || bootParams.intFlashAddress < BOOTLOADER_END) { bootParams.intFlashAddress = SYSTEM_CODE_START; } // read voltage, and quit if not enough for writing in flash if (readVoltage() < THRESHOLD_VOLTAGE) { flashLeds(LEDS_LOW_BATTERY); goto exec; } // write the updated info back in flash intFlashErase(BOOT_PARAMS_ADDRESS, sizeof(bootParams)); intFlashWrite(BOOT_PARAMS_ADDRESS, &bootParams, sizeof(bootParams)); if (bootParams.doReprogramming) { redLedOn(); // will be using external flash extFlashInit(); extFlashWake(); uint32_t extAddress = bootParams.extFlashAddress; // read number of blocks uint16_t imageBlockCount; extFlashRead(extAddress, &imageBlockCount, sizeof(uint16_t)); extAddress += 2; while (imageBlockCount) { // read a block from external flash ExternalFlashBlock_t block; extFlashRead(extAddress, &block, sizeof(block)); if (block.crc != crc16((uint8_t *)&block, sizeof(block) - 2)) { // the best we can do is to reboot now; // after a few tries the golden image will be loaded flashLeds(LEDS_CRC_ERROR); // no need to disable all of the interrupts (they already are), // just write in watchdog timer wihout password, it will generate reset. watchdogRebootSimple(); } bool firstBlockInChunk = block.address & 0x1; block.address &= ~0x1; if (firstBlockInChunk) { // prepare internal flash to be written intFlashErase(block.address, INT_FLASH_SEGMENT_SIZE); } // program internal flash COMPILE_TIME_ASSERT(sizeof(block.data) == INT_FLASH_BLOCK_SIZE, ifs); intFlashWriteBlock(block.address, block.data, INT_FLASH_BLOCK_SIZE); --imageBlockCount; extAddress += sizeof(ExternalFlashBlock_t); } extFlashSleep(); redLedOff(); } #if ENABLE_BOOT_DELAY // delay for a second or so to allow the user to interrupt booting (by pressing the reset button) flashLeds(LEDS_BOOTLOADER_END); #endif // execute the program exec: ((ApplicationStartExec)bootParams.intFlashAddress)(); }
float HC401::readPascal() { return max(0, (readVoltage() - 0.5) / 0.015); }
float MCP9700A::tempReadCelcius(){ float base = readVoltage(); return (base - .5) / .01 ; }