Value Eeprom::readEeprom(const EepromLocation& location) { //get the type and location from the EepromLocation object ValueType type = location.valueType(); uint16 eepromLoc = location.location(); //determine which readEeprom function to call, based on the valueType switch(type) { case valueType_uint16: return Value(type, readEeprom(eepromLoc)); case valueType_float: return Value(type, readEeprom_float(eepromLoc)); case valueType_uint32: return Value(type, readEeprom_uint32(eepromLoc)); case valueType_int16: return Value(type, readEeprom_int16(eepromLoc)); default: assert(false); //we are trying to read a value with an invalid type? return Value(type, readEeprom(eepromLoc)); //just default to uint16 } }
uint32 Eeprom::readEeprom_uint32(uint16 location) { //try to read the first part of the float uint16 msw = readEeprom(location); //try to read the second part of the float uint16 lsw = readEeprom(location + 2); //make a uint32 and return return Utils::make_uint32(Utils::msb(msw), Utils::lsb(msw), Utils::msb(lsw), Utils::lsb(lsw)); }
float Eeprom::readEeprom_float(uint16 location) { //try to read the first part of the float uint16 msw = readEeprom(location); //try to read the second part of the float uint16 lsw = readEeprom(location + 2); //split the words into bytes uint8 b1, b2, b3, b4; Utils::split_uint16(msw, b1, b2); Utils::split_uint16(lsw, b3, b4); //convert the values into a float and return return Utils::make_float(b1, b2, b3, b4, Utils::littleEndian); //note that this just swapped endianness by passing the msb as the lsb }
void startUp() { readEeprom(); setFanSpeed(255); _delay_us(100); restoreState(); }
//************************************************************************ uint8_t EEPROMClass::read(unsigned int address) { uint8_t data; readEeprom((uint32_t)address, &data); return data; }
void Thermal_init(){ I2C_init(THERMAL_I2C_ID,I2C_CLOCK_FREQ); count = 0; readEeprom(); writeTrimmingValue(); writeConfigReg(); readConfigReg(); configCalculationData(); Timer_new(TIMER_THERMAL,READ_DELAY); }
void startUp() { readEeprom(); for(char i = 0; i < 12; i++) { crossfade[i] = save_compbuff[i]; } setFanSpeed(255); _delay_us(100); setFanSpeed(save_fanspeed); crossFade(100); for(char i = 0; i < 12; i++) { crossfade[i] = 0; } }
void setup() { EEPROM.setMemPool(0, EEPROM_SIZE); readEeprom(); pinMode(PIN_GREEN, OUTPUT); pinMode(PIN_RED, OUTPUT); pinMode(PIN_YELLOW, OUTPUT); green = false; red = false; yellow = false; mute = false; contentLength = 0; selfTest(); updateLeds(); Serial.begin(57600); wdt_enable(WDTO_4S); }
int16 Eeprom::readEeprom_int16(uint16 location) { return static_cast<int16>(readEeprom(location)); }
void FlashFirmwareDialog::startFlash(const QString &filename) { bool backup = g.backupOnFlash(); close(); ProgressDialog progressDialog(this, tr("Write Firmware to Radio"), CompanionIcon("write_flash.png")); // check hardware compatibility if requested if (g.checkHardwareCompatibility()) { QString tempFirmware = generateProcessUniqueTempFileName("flash-check.bin"); if (!readFirmware(tempFirmware, progressDialog.progress())) { QMessageBox::warning(this, tr("Firmware check failed"), tr("Could not check firmware from radio")); return; } FirmwareInterface previousFirmware(tempFirmware); qunlink(tempFirmware); FirmwareInterface newFirmware(filename); qDebug() << "startFlash: checking firmware compatibility between " << tempFirmware << "and" << filename; if (!newFirmware.isHardwareCompatible(previousFirmware)) { QMessageBox::warning(this, tr("Firmware check failed"), tr("New firmware is not compatible with the one currently installed!")); if (isTempFileName(filename)) { qDebug() << "startFlash: removing temporary file" << filename; qunlink(filename); } return; } } // backup if requested bool result = true; QString backupFilename; QString backupPath; if (backup) { backupPath = g.profile[g.id()].pBackupDir(); if (backupPath.isEmpty()) { backupPath=g.backupDir(); } backupFilename = backupPath + "/backup-" + QDateTime().currentDateTime().toString("yyyy-MM-dd-HHmmss") + ".bin"; result = readEeprom(backupFilename, progressDialog.progress()); sleep(2); } // flash result = (result && writeFirmware(filename, progressDialog.progress())); // restore if backup requested if (backup && result) { sleep(2); QString restoreFilename = generateProcessUniqueTempFileName("restore.bin"); if (!convertEEprom(backupFilename, restoreFilename, filename)) { QMessageBox::warning(this, tr("Conversion failed"), tr("Cannot convert Models and Settings for use with this firmware, original data will be used")); restoreFilename = backupFilename; } if (!writeEeprom(restoreFilename, progressDialog.progress())) { QMessageBox::warning(this, tr("Restore failed"), tr("Could not restore Models and Settings to Radio. The models and settings data file can be found at: %1").arg(backupFilename)); } } progressDialog.progress()->setInfo(tr("Flashing done")); progressDialog.exec(); if (isTempFileName(filename)) { qDebug() << "startFlash: removing temporary file" << filename; qunlink(filename); } }
AutoBalanceResult WirelessNode_Impl::autoBalance(const ChannelMask& mask, float targetPercent) { Utils::checkBounds_min(targetPercent, 0.0f); Utils::checkBounds_max(targetPercent, 100.0f); //attempt a few pings first //(legacy (v1) autobalance doesn't have a response packet, so need to check communication) uint8 retryCounter = 0; bool pingSuccess = false; while(!pingSuccess && retryCounter < 3) { pingSuccess = ping().success(); retryCounter++; } if(!pingSuccess) { throw Error_NodeCommunication(nodeAddress()); } //find the eeprom location that the autobalance will adjust //Note: this also verifies that it is supported for this mask const EepromLocation& eepromLoc = features().findEeprom(WirelessTypes::chSetting_autoBalance, mask); //currently, autobalance is always per channel, so get the channel from the mask uint8 channelNumber = mask.lastChEnabled(); AutoBalanceResult result; //perform the autobalance command with the parent base station m_baseStation.node_autoBalance(protocol(), m_address, channelNumber, targetPercent, result); //clear the cache of the hardware offset eeprom location we adjusted eeprom().clearCacheLocation(eepromLoc.location()); Utils::threadSleep(200); //if we used the legacy command, we don't get result info, need to do more work to get it if(result.m_errorCode == WirelessTypes::autobalance_legacyNone) { result.m_errorCode = WirelessTypes::autobalance_maybeInvalid; //force the read eeprom retries to a minimum of 3 uint8 startRetries = m_eepromSettings.numRetries; //when this goes out of scope, it will change back the original retries value ScopeHelper writebackRetries(std::bind(&WirelessNode_Impl::setReadWriteRetries, this, startRetries)); //if there are less than 10 retries if(startRetries < 10) { //we want to retry at least a few times setReadWriteRetries(10); } else { //don't need to write back the retries since we didn't make a change writebackRetries.cancel(); } //read the updated hardware offset from the node result.m_hardwareOffset = readEeprom(eepromLoc).as_uint16(); bool readSensorSuccess = false; uint8 readSensorTry = 0; do { //perform the read single sensor command uint16 sensorVal = 0; readSensorSuccess = m_baseStation.node_readSingleSensor(m_address, channelNumber, sensorVal); if(readSensorSuccess) { //find the max bits value of the node uint32 maxBitsVal = 0; switch(model()) { case WirelessModels::node_vLink: case WirelessModels::node_sgLink_rgd: case WirelessModels::node_shmLink: maxBitsVal = 65536; break; default: maxBitsVal = 4096; break; } //calculate and store the percent achieved result.m_percentAchieved = static_cast<float>(sensorVal) / static_cast<float>(maxBitsVal) * 100.0f; } readSensorTry++; } while(!readSensorSuccess && readSensorTry <= 3); if(readSensorSuccess) { //mark as questionable if not close enough to the target percentage if(std::abs(result.m_percentAchieved - targetPercent) > 5.0) { result.m_errorCode = WirelessTypes::autobalance_maybeInvalid; } else { result.m_errorCode = WirelessTypes::autobalance_success; } } } return result; }