int CGitIndexList::ReadIndex(CString dgitdir) { this->clear(); m_critRepoSec.Lock(); if (repository.Open(dgitdir)) { m_critRepoSec.Unlock(); return -1; } // add config files CAutoConfig config(true); CString projectConfig = dgitdir + _T("config"); CString globalConfig = g_Git.GetGitGlobalConfig(); CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig(); CString systemConfig(CRegString(REG_SYSTEM_GITCONFIGPATH, _T(""), FALSE)); git_config_add_file_ondisk(config, CGit::GetGitPathStringA(projectConfig), GIT_CONFIG_LEVEL_LOCAL, FALSE); git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalConfig), GIT_CONFIG_LEVEL_GLOBAL, FALSE); git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalXDGConfig), GIT_CONFIG_LEVEL_XDG, FALSE); if (!systemConfig.IsEmpty()) git_config_add_file_ondisk(config, CGit::GetGitPathStringA(systemConfig), GIT_CONFIG_LEVEL_SYSTEM, FALSE); git_repository_set_config(repository, config); CAutoIndex index; // load index in order to enumerate files if (git_repository_index(index.GetPointer(), repository)) { repository.Free(); m_critRepoSec.Unlock(); return -1; } size_t ecount = git_index_entrycount(index); resize(ecount); for (size_t i = 0; i < ecount; ++i) { const git_index_entry *e = git_index_get_byindex(index, i); this->at(i).m_FileName.Empty(); this->at(i).m_FileName = CUnicodeUtils::GetUnicode(e->path); this->at(i).m_FileName.MakeLower(); this->at(i).m_ModifyTime = e->mtime.seconds; this->at(i).m_Flags = e->flags | e->flags_extended; this->at(i).m_IndexHash = e->id.id; this->at(i).m_Size = e->file_size; } g_Git.GetFileModifyTime(dgitdir + _T("index"), &this->m_LastModifyTime); std::sort(this->begin(), this->end(), SortIndex); m_critRepoSec.Unlock(); return 0; }
displayPort_t *max7456DisplayPortInit(const vcdProfile_t *vcdProfile) { displayInit(&max7456DisplayPort, &max7456VTable); #ifdef USE_OSD_SLAVE max7456Init(max7456Config(), vcdProfile, false); #else max7456Init(max7456Config(), vcdProfile, systemConfig()->cpu_overclock); #endif resync(&max7456DisplayPort); return &max7456DisplayPort; }
ConfigurationProvider::shared_pointer ConfigurationFactory::getProvider() { Lock guard(conf_factory_mutex); if(configurationProvider.get() == NULL) { configurationProvider.reset(new ConfigurationProviderImpl()); // default Configuration::shared_pointer systemConfig(new SystemConfigurationImpl()); configurationProvider->registerConfiguration("system", systemConfig); } return configurationProvider; }
int CGitIndexList::ReadIndex(CString dgitdir) { this->clear(); CAutoLocker lock(m_critRepoSec); if (repository.Open(dgitdir)) return -1; // add config files CAutoConfig config(true); CString projectConfig = dgitdir + _T("config"); CString globalConfig = g_Git.GetGitGlobalConfig(); CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig(); CString systemConfig(CRegString(REG_SYSTEM_GITCONFIGPATH, _T(""), FALSE)); CString programDataConfig(GetProgramDataGitConfig()); git_config_add_file_ondisk(config, CGit::GetGitPathStringA(projectConfig), GIT_CONFIG_LEVEL_LOCAL, FALSE); git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalConfig), GIT_CONFIG_LEVEL_GLOBAL, FALSE); git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalXDGConfig), GIT_CONFIG_LEVEL_XDG, FALSE); if (!systemConfig.IsEmpty()) git_config_add_file_ondisk(config, CGit::GetGitPathStringA(systemConfig), GIT_CONFIG_LEVEL_SYSTEM, FALSE); if (!programDataConfig.IsEmpty()) git_config_add_file_ondisk(config, CGit::GetGitPathStringA(programDataConfig), GIT_CONFIG_LEVEL_PROGRAMDATA, FALSE); git_repository_set_config(repository, config); CAutoIndex index; // load index in order to enumerate files if (git_repository_index(index.GetPointer(), repository)) { repository.Free(); return -1; } m_bHasConflicts = FALSE; size_t ecount = git_index_entrycount(index); try { resize(ecount); } catch (const std::bad_alloc& ex) { repository.Free(); CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Could not resize index-vector: %s\n", ex.what()); return -1; } for (size_t i = 0; i < ecount; ++i) { const git_index_entry *e = git_index_get_byindex(index, i); this->at(i).m_FileName = CUnicodeUtils::GetUnicode(e->path); this->at(i).m_FileName.MakeLower(); this->at(i).m_ModifyTime = e->mtime.seconds; this->at(i).m_Flags = e->flags; this->at(i).m_FlagsExtended = e->flags_extended; this->at(i).m_IndexHash = e->id.id; this->at(i).m_Size = e->file_size; m_bHasConflicts |= GIT_IDXENTRY_STAGE(e); } CGit::GetFileModifyTime(dgitdir + _T("index"), &this->m_LastModifyTime); std::sort(this->begin(), this->end(), SortIndex); return 0; }
uint32_t sdHalInit() { enableIfaceAndFunctionalClock(); if ( softwareReset() ) { return 1; } if ( resetLines( MMCHS_SYSCTL_SRA_BIT ) ) { return 1; } selectSupportedVoltage( MMCHS_CAPA_VS18_BIT | MMCHS_CAPA_VS30_BIT ); // want enable wakeup when card is inserted systemConfig( MMCHS_SYSCONFIG_AUTOIDLE_BIT /*| MMCHS_SYSCONFIG_ENAWAKEUP_BIT */ ); setBusWidth( BUS_WIDTH_1BIT ); setBusVoltage( MMCHS_HCTL_SDVS_30V_BIT ); if ( setBusPower( TRUE ) ) { return 1; } // need some initial clock divider otherwise would not work to set the bus frequency MMCHS_SYSCTL = 0x0000a007; if ( setBusFrequency( SDMMC_CONTROLLER_CLOCK, SDMMC_BUS_CLOCK, FALSE ) ) { return 1; } /* // wake-up event enabled on card-insertion MMCHS_HCTL |= MMCHS_HCTL_INS_BIT; // clear all and set card-interrupt enable MMCHS_ISE = MMCHS_ISE_CIRQ_SIGEN_BIT; // TODO: the next only when card is inserted! */ sendInitStream(); if ( identifyCard() ) { return 1; } if ( configBusWidth() ) { return 1; } configTransferSpeed(); return 0; }
void updateArmingStatus(void) { if (ARMING_FLAG(ARMED)) { LED0_ON; } else { // Check if the power on arming grace time has elapsed if ((getArmingDisableFlags() & ARMING_DISABLED_BOOT_GRACE_TIME) && (millis() >= systemConfig()->powerOnArmingGraceTime * 1000)) { // If so, unset the grace time arming disable flag unsetArmingDisabled(ARMING_DISABLED_BOOT_GRACE_TIME); } // Clear the crash flip active status flipOverAfterCrashMode = false; // If switch is used for arming then check it is not defaulting to on when the RX link recovers from a fault if (!isUsingSticksForArming()) { static bool hadRx = false; const bool haveRx = rxIsReceivingSignal(); const bool justGotRxBack = !hadRx && haveRx; if (justGotRxBack && IS_RC_MODE_ACTIVE(BOXARM)) { // If the RX has just started to receive a signal again and the arm switch is on, apply arming restriction setArmingDisabled(ARMING_DISABLED_BAD_RX_RECOVERY); } else if (haveRx && !IS_RC_MODE_ACTIVE(BOXARM)) { // If RX signal is OK and the arm switch is off, remove arming restriction unsetArmingDisabled(ARMING_DISABLED_BAD_RX_RECOVERY); } hadRx = haveRx; } if (IS_RC_MODE_ACTIVE(BOXFAILSAFE)) { setArmingDisabled(ARMING_DISABLED_BOXFAILSAFE); } else { unsetArmingDisabled(ARMING_DISABLED_BOXFAILSAFE); } if (calculateThrottleStatus() != THROTTLE_LOW) { setArmingDisabled(ARMING_DISABLED_THROTTLE); } else { unsetArmingDisabled(ARMING_DISABLED_THROTTLE); } if (!STATE(SMALL_ANGLE) && !IS_RC_MODE_ACTIVE(BOXFLIPOVERAFTERCRASH)) { setArmingDisabled(ARMING_DISABLED_ANGLE); } else { unsetArmingDisabled(ARMING_DISABLED_ANGLE); } if (averageSystemLoadPercent > 100) { setArmingDisabled(ARMING_DISABLED_LOAD); } else { unsetArmingDisabled(ARMING_DISABLED_LOAD); } if (isCalibrating()) { setArmingDisabled(ARMING_DISABLED_CALIBRATING); } else { unsetArmingDisabled(ARMING_DISABLED_CALIBRATING); } if (isModeActivationConditionPresent(BOXPREARM)) { if (IS_RC_MODE_ACTIVE(BOXPREARM) && !ARMING_FLAG(WAS_ARMED_WITH_PREARM)) { unsetArmingDisabled(ARMING_DISABLED_NOPREARM); } else { setArmingDisabled(ARMING_DISABLED_NOPREARM); } } #ifdef USE_GPS_RESCUE if (isModeActivationConditionPresent(BOXGPSRESCUE)) { if (!gpsRescueConfig()->minSats || STATE(GPS_FIX_HOME) || ARMING_FLAG(WAS_EVER_ARMED)) { unsetArmingDisabled(ARMING_DISABLED_GPS); } else { setArmingDisabled(ARMING_DISABLED_GPS); } } #endif if (IS_RC_MODE_ACTIVE(BOXPARALYZE)) { setArmingDisabled(ARMING_DISABLED_PARALYZE); } if (!isUsingSticksForArming()) { /* Ignore ARMING_DISABLED_CALIBRATING if we are going to calibrate gyro on first arm */ bool ignoreGyro = armingConfig()->gyro_cal_on_first_arm && !(getArmingDisableFlags() & ~(ARMING_DISABLED_ARM_SWITCH | ARMING_DISABLED_CALIBRATING)); /* Ignore ARMING_DISABLED_THROTTLE (once arm switch is on) if we are in 3D mode */ bool ignoreThrottle = feature(FEATURE_3D) && !IS_RC_MODE_ACTIVE(BOX3D) && !flight3DConfig()->switched_mode3d && !(getArmingDisableFlags() & ~(ARMING_DISABLED_ARM_SWITCH | ARMING_DISABLED_THROTTLE)); #ifdef USE_RUNAWAY_TAKEOFF if (!IS_RC_MODE_ACTIVE(BOXARM)) { unsetArmingDisabled(ARMING_DISABLED_RUNAWAY_TAKEOFF); } #endif // If arming is disabled and the ARM switch is on if (isArmingDisabled() && !ignoreGyro && !ignoreThrottle && IS_RC_MODE_ACTIVE(BOXARM)) { setArmingDisabled(ARMING_DISABLED_ARM_SWITCH); } else if (!IS_RC_MODE_ACTIVE(BOXARM)) { unsetArmingDisabled(ARMING_DISABLED_ARM_SWITCH); } } if (isArmingDisabled()) { warningLedFlash(); } else { warningLedDisable(); } warningLedUpdate(); } }
int main(void) { float distanceNear = kDistanceNearInitial; ControllMode currentMode = ControllModeSearching; int approachCount = 30000, backOffCount = 0; int iDontKnowCountPrimary = 30, iDontKnowCountSecondary = 500; bool USSensorWorking = false; distance = usSensor.getResult(); if(distance > kApproachDistanceMin && distance < distanceNear) USSensorWorking = true; int programCount = 0; systemConfig(); stopMove(); delay(200); beginMoveForward(); delay(75); beginTurnRight(); delay(9); stopMove(); delay(100); beginMoveForward(); delay(100); beginTurnRight(); delay(5); beginMoveForward(); delay(150); beginMoveBackward(); delay(8); beginTurnRight(); delay(40); beginMoveForward(); delay(60); beginMoveBackward(); delay(30); beginTurnRight(); delay(40); beginMoveForward(); delay(60); beginMoveBackward(); delay(30); while (true) { // Stop watchdog timer to prevent time out reset WDTCTL = WDTPW + WDTHOLD; /*programCount ++; if (programCount == 0xffff) { WDTCTL = WDTPW|0xff00; } */ //delay(10); usSensor.beginSensing(); distance = usSensor.getResult(); USSensorWorking = false; if(distance > kApproachDistanceMin && distance < distanceNear) USSensorWorking = true; switch (currentMode) { case ControllModeSearching: if (USSensorWorking) { beginMoveForward(); if (currentMode != ControllModeApproaching) { approachCount = kApproachCountMax; } currentMode = ControllModeApproaching; } else { beginTurnLeft(); iDontKnowCountPrimary --; if (iDontKnowCountPrimary == 0) { iDontKnowCountPrimary = 10; iDontKnowCountSecondary --; if (iDontKnowCountSecondary == 0) { iDontKnowCountSecondary = 500; currentMode = ControllModeIDontKnowWhatTheHellShouldIDo; } } } break; case ControllModeIDontKnowWhatTheHellShouldIDo: beginMoveForward(); iDontKnowCountPrimary --; if (iDontKnowCountPrimary == 0) { iDontKnowCountPrimary = 20; iDontKnowCountSecondary --; if (iDontKnowCountSecondary == 0) { iDontKnowCountSecondary = 500; currentMode = ControllModeSearching; } } break; case ControllModeApproaching: if(USSensorWorking) { beginMoveForward(); delay(1); if(distance < 0.2) { delay(240); approachCount = kApproachCountMax; currentMode = ControllModeBackingOff; } else if(distance < 0.5) { approachCount = 600; } else if(distance < 1.0) { approachCount = 1200; } } else { approachCount--; beginMoveForward(); delay(1); if (approachCount <= 0) { approachCount = kApproachCountMax; currentMode = ControllModeBackingOff; } } /* if (distance < kApproachDistanceMin) { approachCount = 0; currentMode = ControllModeBackingOff; } */ break; case ControllModeBackingOff: if (backOffCount == 0) { stopMove(); beginRotateBackward(MotorLeft); delay(60); } beginMoveBackward(); delay(120); /* backOffCount++; if (backOffCount >= kBackOffCountMax) { backOffCount = 0; */ currentMode = ControllModeSearching; //} break; } } }
void processRcAdjustments(controlRateConfig_t *controlRateConfig) { const uint32_t now = millis(); int newValue = -1; const bool canUseRxData = rxIsReceivingSignal(); for (int adjustmentIndex = 0; adjustmentIndex < MAX_SIMULTANEOUS_ADJUSTMENT_COUNT; adjustmentIndex++) { adjustmentState_t *adjustmentState = &adjustmentStates[adjustmentIndex]; if (!adjustmentState->config) { continue; } const uint8_t adjustmentFunction = adjustmentState->config->adjustmentFunction; if (adjustmentFunction == ADJUSTMENT_NONE) { continue; } if (cmp32(now, adjustmentState->timeoutAt) >= 0) { adjustmentState->timeoutAt = now + RESET_FREQUENCY_2HZ; MARK_ADJUSTMENT_FUNCTION_AS_READY(adjustmentIndex); #if defined(USE_OSD) && defined(USE_OSD_ADJUSTMENTS) adjustmentRangeValue = -1; #endif } if (!canUseRxData) { continue; } const uint8_t channelIndex = NON_AUX_CHANNEL_COUNT + adjustmentState->auxChannelIndex; if (adjustmentState->config->mode == ADJUSTMENT_MODE_STEP) { int delta; if (rcData[channelIndex] > rxConfig()->midrc + 200) { delta = adjustmentState->config->data.step; } else if (rcData[channelIndex] < rxConfig()->midrc - 200) { delta = -adjustmentState->config->data.step; } else { // returning the switch to the middle immediately resets the ready state MARK_ADJUSTMENT_FUNCTION_AS_READY(adjustmentIndex); adjustmentState->timeoutAt = now + RESET_FREQUENCY_2HZ; continue; } if (IS_ADJUSTMENT_FUNCTION_BUSY(adjustmentIndex)) { continue; } newValue = applyStepAdjustment(controlRateConfig, adjustmentFunction, delta); pidInitConfig(pidProfile); } else if (adjustmentState->config->mode == ADJUSTMENT_MODE_SELECT) { int switchPositions = adjustmentState->config->data.switchPositions; if (adjustmentFunction == ADJUSTMENT_RATE_PROFILE && systemConfig()->rateProfile6PosSwitch) { switchPositions = 6; } const uint16_t rangeWidth = (2100 - 900) / switchPositions; const uint8_t position = (constrain(rcData[channelIndex], 900, 2100 - 1) - 900) / rangeWidth; newValue = applySelectAdjustment(adjustmentFunction, position); } #if defined(USE_OSD) && defined(USE_OSD_ADJUSTMENTS) if (newValue != -1 && adjustmentState->config->adjustmentFunction != ADJUSTMENT_RATE_PROFILE) { // Rate profile already has an OSD element adjustmentRangeName = &adjustmentLabels[adjustmentFunction - 1][0]; adjustmentRangeValue = newValue; } #else UNUSED(newValue); #endif MARK_ADJUSTMENT_FUNCTION_AS_BUSY(adjustmentIndex); } }