void rusEfiFunctionalTest(void) {
initializeConsole();
initFakeBoard();
initStatusLoop(&engine);
initDataStructures(engineConfiguration);
engine.engineConfiguration = engineConfiguration;
engine.engineConfiguration2 = engineConfiguration2;
resetConfigurationExt(NULL, FORD_ASPIRE_1996, engineConfiguration, engineConfiguration2);
initThermistors(&engine);
initAlgo(engineConfiguration);
initRpmCalculator();
initAnalogChart();
initTriggerEmulator();
initMainEventListener(&engine, engineConfiguration2);
initTriggerCentral(&engine);
startStatusThreads(&engine);
startTunerStudioConnectivity();
}
void DataTable::addSample(const DataPoint &sample)
{
if (getNumSamples() == 0)
{
numVariables = sample.getDimX();
initDataStructures();
}
if(sample.getDimX() != numVariables) {
throw Exception("Datatable::addSample: Dimension of new sample is inconsistent with previous samples!");
}
// Check if the sample has been added already
if (samples.count(sample) > 0)
{
if (!allowDuplicates)
{
#ifndef NDEBUG
std::cout << "Discarding duplicate sample because allowDuplicates is false!" << std::endl;
std::cout << "Initialise with DataTable(true) to set it to true." << std::endl;
#endif // NDEBUG
return;
}
numDuplicates++;
}
samples.insert(sample);
recordGridPoint(sample);
}
void
HCComponent::testModel()
{
trace_msg( modelchecker, 1, "Check component " << *this );
if( numberOfCalls++ == 0 )
initDataStructures();
//The checker will return always unsat
if( isConflictual )
return;
vector< Literal > assumptions;
computeAssumptions( assumptions );
//The checker will return always unsat
if( isConflictual )
return;
if( unfoundedSetCandidates.empty() )
return;
checkModel( assumptions );
clearUnfoundedSetCandidates();
assert( !checker.conflictDetected() );
if( assumptionLiteral != Literal::null )
checker.addClause( assumptionLiteral.getOppositeLiteral() );
assert( !checker.conflictDetected() );
statistics( &checker, endCheckerInvokation( time( 0 ) ) );
if( solver.exchangeClauses() )
sendLearnedClausesToSolver();
}
void DisplayManager::createNewDisplay(){
m_rightTrans = 8; //Count down
m_leftTrans = 8;
m_topTrans = 8;
m_bottomTrans = 8;
m_displayBufferIndex=0;
m_displayBufferSize=0;
initDataStructures();
}
void rusEfiFunctionalTest(void) {
printToWin32Console("Running version:");
printToWin32Console("TODO");
initIntermediateLoggingBuffer();
initErrorHandling();
engine->setConfig(config);
initializeConsole(&sharedLogger);
initStatusLoop(engine);
initDataStructures(PASS_ENGINE_PARAMETER_F);
// todo: reduce code duplication with initEngineContoller
resetConfigurationExt(NULL, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER);
prepareShapes(PASS_ENGINE_PARAMETER_F);
initAlgo(&sharedLogger, engineConfiguration);
commonInitEngineController(&sharedLogger);
initRpmCalculator(&sharedLogger, engine);
#if EFI_SENSOR_CHART || defined(__DOXYGEN__)
initSensorChart();
#endif /* EFI_SENSOR_CHART */
initTriggerCentral(&sharedLogger, engine);
initTriggerEmulator(&sharedLogger, engine);
#if EFI_MAP_AVERAGING || defined(__DOXYGEN__)
initMapAveraging(&sharedLogger, engine);
#endif /* EFI_MAP_AVERAGING */
initMainEventListener(&sharedLogger, engine);
startStatusThreads(engine);
initPeriodicEvents(PASS_ENGINE_PARAMETER_F);
setTriggerEmulatorRPM(DEFAULT_SIM_RPM, engine);
engineConfiguration->engineSnifferRpmThreshold = DEFAULT_SNIFFER_THR;
}
void rusEfiFunctionalTest(void) {
printToConsole("Running rusEfi simulator version:");
static char versionBuffer[20];
itoa10(versionBuffer, (int)getRusEfiVersion());
printToConsole(versionBuffer);
initIntermediateLoggingBuffer();
initErrorHandling();
engine->setConfig(config);
initializeConsole(&sharedLogger);
initStatusLoop();
initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE);
// todo: reduce code duplication with initEngineContoller
resetConfigurationExt(NULL, FORD_ESCORT_GT PASS_ENGINE_PARAMETER_SUFFIX);
prepareShapes(PASS_ENGINE_PARAMETER_SIGNATURE);
initAlgo(&sharedLogger);
commonInitEngineController(&sharedLogger);
initRpmCalculator(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
initTriggerCentral(&sharedLogger);
initTriggerEmulator(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_MAP_AVERAGING
initMapAveraging(&sharedLogger, engine);
#endif /* EFI_MAP_AVERAGING */
initMainEventListener(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
startStatusThreads();
runChprintfTest();
initPeriodicEvents(PASS_ENGINE_PARAMETER_SIGNATURE);
setTriggerEmulatorRPM(DEFAULT_SIM_RPM PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->engineSnifferRpmThreshold = DEFAULT_SNIFFER_THR;
}
int main(int argc, char **argv){
NumberLoads=0;
NumberStores=0;
if(argc != 4){
printf(" *** Error: Usage %s <instr_file> <num_registers> <map_file>\n",argv[0]);
return -1;
}
initDataStructures();
readInstructionsFromFile(argv[1]);
NumberRegisters = atoi(argv[2]);
if(NumberRegisters <= 0){
/* DO SOMETHING */
printf(" Number of Registers: %d\n",NumberRegisters);
printf(" Number Load Operations: 0\n");
printf(" Number Store Operations: 0\n");
return 0;
}
readVarMapFromFile(argv[3]);
/* YOUR CODE HERE */
printf(" Number of Registers: %d\n", NumberRegisters); // ok
registers=table_create(NumberRegisters);
// ciclo para usar o checkInstruction() em cada BasicBlock
checkBasicBlock(Code);
count_Loads_and_Stores();
// outputs the result
// printBasicBlock(Code);
dumpBasicBlock(Output);
printf(" Number Load Operations: %d\n", NumberLoads);
printf(" Number Store Operations: %d\n", NumberStores);
return 0;
}
void initHardware(Logging *logger, Engine *engine) {
engine_configuration_s *engineConfiguration = engine->engineConfiguration;
efiAssertVoid(engineConfiguration!=NULL, "engineConfiguration");
board_configuration_s *boardConfiguration = &engineConfiguration->bc;
printMsg(logger, "initHardware()");
// todo: enable protection. it's disabled because it takes
// 10 extra seconds to re-flash the chip
//flashProtect();
chMtxInit(&spiMtx);
#if EFI_HISTOGRAMS
/**
* histograms is a data structure for CPU monitor, it does not depend on configuration
*/
initHistogramsModule();
#endif /* EFI_HISTOGRAMS */
/**
* This is so early because we want to init logger
* which would be used while finding trigger synch index
* while config read
*/
initTriggerDecoder();
/**
* We need the LED_ERROR pin even before we read configuration
*/
initPrimaryPins();
if (hasFirmwareError()) {
return;
}
initDataStructures(PASS_ENGINE_PARAMETER_F);
#if EFI_INTERNAL_FLASH
palSetPadMode(CONFIG_RESET_SWITCH_PORT, CONFIG_RESET_SWITCH_PIN, PAL_MODE_INPUT_PULLUP);
initFlash(engine);
/**
* this call reads configuration from flash memory or sets default configuration
* if flash state does not look right.
*/
if (SHOULD_INGORE_FLASH()) {
engineConfiguration->engineType = FORD_ASPIRE_1996;
resetConfigurationExt(logger, engineConfiguration->engineType, engine);
writeToFlash();
} else {
readFromFlash();
}
#else
engineConfiguration->engineType = FORD_ASPIRE_1996;
resetConfigurationExt(logger, engineConfiguration->engineType, engineConfiguration, engineConfiguration2, boardConfiguration);
#endif /* EFI_INTERNAL_FLASH */
if (hasFirmwareError()) {
return;
}
mySetPadMode2("board test", boardConfiguration->boardTestModeJumperPin, PAL_MODE_INPUT_PULLUP);
bool isBoardTestMode_b = GET_BOARD_TEST_MODE_VALUE();
initAdcInputs(isBoardTestMode_b);
if (isBoardTestMode_b) {
// this method never returns
initBoardTest();
}
initRtc();
initOutputPins();
#if EFI_HIP_9011
initHip9011();
#endif /* EFI_HIP_9011 */
#if EFI_MAX_31855
initMax31855(boardConfiguration);
#endif /* EFI_MAX_31855 */
#if EFI_CAN_SUPPORT
initCan();
#endif /* EFI_CAN_SUPPORT */
// init_adc_mcp3208(&adcState, &SPID2);
// requestAdcValue(&adcState, 0);
// todo: figure out better startup logic
initTriggerCentral(engine);
#if EFI_SHAFT_POSITION_INPUT
initShaftPositionInputCapture();
#endif /* EFI_SHAFT_POSITION_INPUT */
initSpiModules(boardConfiguration);
#if EFI_FILE_LOGGING
initMmcCard();
#endif /* EFI_FILE_LOGGING */
// initFixedLeds();
// initBooleanInputs();
#if EFI_UART_GPS
initGps();
#endif
#if ADC_SNIFFER
initAdcDriver();
#endif
#if EFI_HD44780_LCD
// initI2Cmodule();
lcd_HD44780_init();
if (hasFirmwareError())
return;
lcd_HD44780_print_string(VCS_VERSION);
#endif /* EFI_HD44780_LCD */
addConsoleActionII("i2c", sendI2Cbyte);
// while (true) {
// for (int addr = 0x20; addr < 0x28; addr++) {
// sendI2Cbyte(addr, 0);
// int err = i2cGetErrors(&I2CD1);
// print("I2C: err=%x from %d\r\n", err, addr);
// chThdSleepMilliseconds(5);
// sendI2Cbyte(addr, 255);
// chThdSleepMilliseconds(5);
// }
// }
printMsg(logger, "initHardware() OK!");
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool MNcursesPlugin::init() {
_activeTag = Communication::CLIENTNAME_TAG;
initDataStructures(Communication::PROGRAMNAME_TAG, "prog");
initDataStructures(Communication::CLIENTNAME_TAG, "name");
initDataStructures(Communication::HOSTNAME_TAG, "host");
initDataStructures(Communication::TOTAL_MEMORY_TAG, "hmem");
initDataStructures(Communication::CLIENT_MEMORY_USAGE_TAG, "cmem");
initDataStructures(Communication::MEMORY_USAGE_TAG, "mem");
initDataStructures(Communication::CPU_USAGE_TAG, "cpu");
initDataStructures(Communication::MESSAGE_QUEUE_SIZE_TAG, "q");
initDataStructures(Communication::AVERAGE_MESSAGE_QUEUE_SIZE_TAG, "mq");
initDataStructures(Communication::UPTIME_TAG, "uptime");
initDataStructures(Communication::RESPONSE_TIME_TAG, "resp");
boost::thread thread1(boost::bind(&MNcursesPlugin::readUserInput, this));
thread1.yield();
return true;
}
void runRusEfi(void) {
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 512, "init s");
assertEngineReference();
initIntermediateLoggingBuffer();
initErrorHandling();
#if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__)
/**
* This is so early because we want to init logger
* which would be used while finding trigger sync index
* while reading configuration
*/
initTriggerDecoderLogger(&sharedLogger);
#endif /* EFI_SHAFT_POSITION_INPUT */
/**
* we need to initialize table objects before default configuration can set values
*/
initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE);
/**
* First thing is reading configuration from flash memory.
* In order to have complete flexibility configuration has to go before anything else.
*/
readConfiguration(&sharedLogger);
prepareVoidConfiguration(&activeConfiguration);
/**
* First data structure keeps track of which hardware I/O pins are used by whom
*/
initPinRepository();
/**
* Next we should initialize serial port console, it's important to know what's going on
*/
initializeConsole(&sharedLogger);
engine->setConfig(config);
addConsoleAction("reboot", scheduleReboot);
/**
* Initialize hardware drivers
*/
initHardware(&sharedLogger);
initStatusLoop();
/**
* Now let's initialize actual engine control logic
* todo: should we initialize some? most? controllers before hardware?
*/
initEngineContoller(&sharedLogger PASS_ENGINE_PARAMETER_SIGNATURE);
#if EFI_PERF_METRICS || defined(__DOXYGEN__)
initTimePerfActions(&sharedLogger);
#endif
#if EFI_ENGINE_EMULATOR || defined(__DOXYGEN__)
initEngineEmulator(&sharedLogger, engine);
#endif
startStatusThreads();
test557init();
rememberCurrentConfiguration();
print("Running main loop\r\n");
main_loop_started = true;
/**
* This loop is the closes we have to 'main loop' - but here we only publish the status. The main logic of engine
* control is around main_trigger_callback
*/
while (true) {
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 128, "stack#1");
#if (EFI_CLI_SUPPORT && !EFI_UART_ECHO_TEST_MODE) || defined(__DOXYGEN__)
// sensor state + all pending messages for our own dev console
updateDevConsoleState();
#endif /* EFI_CLI_SUPPORT */
chThdSleepMilliseconds(boardConfiguration->consoleLoopPeriod);
}
}
