void InputHandler::StateSwitched(SimulationState old, SimulationState cur) {
	int height = mMouse->getMouseState().height;
	int width = mMouse->getMouseState().width;
	if (old == SIMULATION && cur == SIMULATION_MOUSELOOK || cur == SIMULATION_TOPDOWNVIEW) {
		destroySystem();
		createSystem(true);
		//capture();
	} else if ((cur == SIMULATION) && old == SIMULATION_MOUSELOOK || old == SIMULATION_TOPDOWNVIEW) {
		destroySystem();
		createSystem(false);
		//capture();
	}
	setWindowExtents(width, height);
}
Exemple #2
0
//-----------------------------------------------------------------------------
// Function: apply()
//-----------------------------------------------------------------------------
void NewSystemPage::apply()
{
    // Create the system in a different way based on the mapping option selection.
    if (mapRadioButton_->isChecked())
    {
        Q_ASSERT(compTreeWidget_->currentItem() != 0);
        QVariant data = compTreeWidget_->currentItem()->data(0, Qt::UserRole);

        emit createSystem(data.value<VLNV>(), viewComboBox_->currentText(),
            vlnvEditor_->getVLNV(), selectedPath());
    }
    else
    {
        emit createSystem(VLNV(), "", vlnvEditor_->getVLNV(),selectedPath());
    }
}
// here we start the calc...
void ProjectSquareWell::slotStartCalc() {

	if (!checkValues(true)) return;

	// ok.. now start the game... we create a new temporary system, setting on it
	// all the input parameters. System is a package-class which holds input data
	// and output data. it's passed to the calc factory, the model, when the calc
	// start. However, it's not granted the model is effectively resting.

	System *s = createSystem();
	System *r = NULL;
	
	if (m_dialog->richardsonExtrapolation()) {
		r = createRichardsonSystem();
	}

	//   startCalc return false if the model is working on another system.
	//   in this case, we ask to wait, and discard the system we built.
	//   a smarter code should span another project, but i don't care to be
	//   too much smarter, since i want to preserve that little mental sanity i
	//   currently have. now let's go to see Model::startCalc()

	// new: r is the richardson system. Nothing more than a carbon copy system
	// with half of the points. We pass it to the model

    if (!m_model->startCalc(s,r)) {
		g_error->error("Another calculation in progress","The current project is currently busy. Unable to start new thread.\n Wait for the end or start a new project.");
		delete s;
		if (r) delete r;
		return;
	}

}
Exemple #4
0
int main(int argc, char *argv[]){

  int    nbParts=20000;
  float  minMax[3][2]={{-1,1},{-1,1},{-1,1}};
  float  cellSize=2*0.02*1.001;// 2*particle radius + 0.1%
  float  dt=0.002,simTime=5;
  float  dtFrame=0.02; //0.04 <=> 25 frames per seconds
  int    nbDtPerFrame,i;
  char   filename[]="toto.par";
  float  mass;
  System *sys;
  clock_t time;

/*
  FILE *file;
  float r[3];

  file=fopen("filter.plt","w");
  fprintf(file,"VARIABLES = x w\n");
  r[1]=r[2]=0;
  for(i=0;i<=100;i++){
    r[0]=i/100.;
    fprintf(file,"%e\t%e\n",i/100.,kernelPoly6(r,1));
  }
  fclose(file);
  return 0;*/


  nbDtPerFrame=dtFrame/dt;
  sys=createSystem(nbParts,minMax);
  tmpAddWalls_1(sys);
  setGrid(sys, cellSize);
  //printGrid(sys); //test nico
  //return 0;
  mass=1000*(minMax[0][1]-minMax[0][0])*(minMax[1][1]-minMax[1][0])*(minMax[2][1]-minMax[2][0])/nbParts;
  setParticles(sys,0,nbParts-1,mass/4); //for water, ro0=1000kg/m3, so 1000 parts/Liter => mi=1e-3kg
  setForces(sys);
  generateParFile(sys,filename,CREATE);

  i=0;
  time=clock();
  while(sys->time<=simTime){
    printf("time = %e (i=%d)\n",sys->time,i);fflush(stdout);
    updateSys(sys,dt);
    if((++i)%nbDtPerFrame==0)
      generateParFile(sys,filename,UPDATE);
  }
  time=clock()-time;

  generateParFile(sys,filename,CLOSE);
  deleteSystem(sys);

  updateSys(NULL,0);
#ifdef USE_MULTI_THREADING
  cleanThreads();
#endif
  printf("done in %f sec!\n", (double)(time)/CLOCKS_PER_SEC);
  return 0;
}
Exemple #5
0
Entity* Model::createEntity( String const& aClassname, FullID const& aFullID )
{
    if( aFullID.getSystemPath().isModel() )
    {
        THROW_EXCEPTION( BadSystemPath, "empty SystemPath" );
    }

    System* aContainerSystemPtr( getSystem( aFullID.getSystemPath() ) );
    Entity* retval( 0 );

    if ( !aContainerSystemPtr )
    {
        THROW_EXCEPTION( BadSystemPath,
                         "[" + aFullID.getSystemPath().asString()
                         + "] cannot be reached" );
    }
 
    switch( aFullID.getEntityType() )
    {
    case EntityType::VARIABLE:
        {
            retval = createVariable( aClassname );
            retval->setID( aFullID.getID() );
            aContainerSystemPtr->registerEntity(
                    static_cast< Variable* >( retval ) );
        }
        break;

    case EntityType::PROCESS:
        {
            retval = createProcess( aClassname );
            retval->setID( aFullID.getID() );
            aContainerSystemPtr->registerEntity(
                    static_cast< Process* >( retval ) );
        }
        break;

    case EntityType::SYSTEM:
        {
            retval = createSystem( aClassname );
            retval->setID( aFullID.getID() );
            aContainerSystemPtr->registerEntity(
                    static_cast< System* >( retval ) );
        }
        break;

    default:
        THROW_EXCEPTION( InvalidEntityType, "invalid EntityType specified" );
    }

    return retval;
}
InputHandler::InputHandler(Simulation *sim, unsigned long hWnd, Ogre::Camera *camera, EntityController * eCont, DataManager * dMan, Ogre::SceneManager * mSceneM)  
{	
	m_hWnd = hWnd;
	createSystem(false);
	m_simulation = sim;
	m_cam = camera;
	entController = eCont;
	dataMan = dMan;
	mSceneManager = mSceneM;
	

	// Get the camera node
	mPitchNode = camera->getParentSceneNode();
    mCamNode = mPitchNode->getParentSceneNode();
}
Exemple #7
0
int main (int argc, char *argv[])
{
	char *configFile = NULL;
	char *outputFile = NULL;

	// Declare objects
	struct system System;
	struct tip Tip;
	struct space Space;
	struct graphene Graphene;
	struct substrate Substrate;

	initSystem(&System, &Tip, &Space, &Graphene, &Substrate);
	parseOptions(argc, argv, &configFile, &outputFile, &System, &Tip);
	parseFile(configFile, &System, &Tip, &Space, &Graphene, &Substrate);

	createSystem(&System, &Tip);
	createGraphene(&System, &Graphene);
//	transformCylindric(&System);
//	createSpace(&System, &Space);
	createTip(&System, &Tip);
	createSubstrate(&System, &Substrate);

	// Spheroidal Tip
	assignPointers(&System, &Tip, &Space, &Graphene, &Substrate);
	assignPotential(&System, &Tip, &Space, &Graphene, &Substrate);

	laplaceSpheroidal(&System, &Tip);

	retransformSpheroidal(&Tip);
	retransformCylindric(&System);

	saveData(outputFile, &System);

	// Visualize System if necessary
	if (System.visual)
	{
		initVisual();
		drawObjects(&System, &Tip, &Space, &Graphene, &Substrate);
	}

	free(System.points); // Free all points

	return EXIT_SUCCESS;
}
void ProjectBarrier::slotStartCalc() {

	if (!checkValues(true)) return;

	System *s = createSystem();
	System *r = NULL;
	
	if (m_dialog->richardsonExtrapolation()) {
		r = createRichardsonSystem();
	}
		
    if (!m_model->startCalc(s,r)) {
		g_error->error("Another calculation in progress","The current project is currently busy. Unable to start new thread.\n Wait for the end or start a new project.");
		delete s;
		if (r) delete r;
		return;
	}

}
Exemple #9
0
void Model::setup()
{
    registerBuiltinModules();

    // initialize theRootSystem
    theRootSystem = createSystem( "System" );
    theRootSystem->setID( "/" );
    theRootSystem->setName( "The Root System" );
    // super system of the root system is itself.
    theRootSystem->setSuperSystem( theRootSystem );

    // initialize theSystemStepper
    theSystemStepper.setModel( this );
    theSystemStepper.setID( "___SYSTEM" );
    theScheduler.addEvent(
        StepperEvent( getCurrentTime() + theSystemStepper.getStepInterval(),
                      &theSystemStepper ) );

    theLastStepper = &theSystemStepper;
}
Exemple #10
0
// Import data.
void Database_Versifications::input (const string& contents, const string& name)
{
  // Delete old system if it is there, and create new one.
  erase (name);
  int id = createSystem (name);

  sqlite3 * db = connect ();
  database_sqlite_exec (db, "PRAGMA temp_store = MEMORY;");
  database_sqlite_exec (db, "PRAGMA synchronous = OFF;");
  database_sqlite_exec (db, "PRAGMA journal_mode = OFF;");
  database_sqlite_exec (db, "BEGIN;");
  
  vector <string> lines = filter_string_explode (contents, '\n');
  for (auto line : lines) {
    line = filter_string_trim (line);
    if (line.empty ()) continue;
    Passage passage = filter_passage_explode_passage (line);
    if ((passage.book == 0)
     || (passage.chapter == 0)
     || (passage.verse.empty ())) {
      Database_Logs::log ("Malformed versification entry: " + line);
      continue;
    }
    SqliteSQL sql = SqliteSQL ();
    sql.add ("INSERT INTO data (system, book, chapter, verse) VALUES (");
    sql.add (id);
    sql.add (",");
    sql.add (passage.book);
    sql.add (",");
    sql.add (passage.chapter);
    sql.add (",");
    sql.add (convert_to_int (passage.verse));
    sql.add (");");
    database_sqlite_exec (db, sql.sql);
  }
  
  database_sqlite_exec (db, "COMMIT;");
  database_sqlite_disconnect (db);
}
Exemple #11
0
boost::weak_ptr<IMixedSystem> SimController::LoadSystem(string modelLib,string modelKey)
{

    //if the model is already loaded
    std::map<string,boost::shared_ptr<IMixedSystem> >::iterator iter = _systems.find(modelKey);
    if(iter != _systems.end())
    {
        //destroy simdata
        std::map<string,boost::shared_ptr<ISimData> >::iterator iter2 = _sim_data.find(modelKey);
        if(iter2 != _sim_data.end())
        {
            _sim_data.erase(iter2);
        }
        //destroy system
        _systems.erase(iter);
    }
    boost::shared_ptr<ISimData> simData = getSimData(modelKey).lock();
    boost::shared_ptr<ISimVars> simVars = getSimVars(modelKey).lock();
    //create system
    boost::shared_ptr<IMixedSystem> system = createSystem(modelLib, modelKey, _config->getGlobalSettings(), _algloopsolverfactory, simData, simVars);
    _systems[modelKey] = system;
    return system;
}
Exemple #12
0
/*
   Calls parseAirports, parseSchedules, and calcRouteTimes if the required files exists.
 */
void timeRoutes(char* airports, char* schedules, char* routes) {
    FILE *airportFile, *scheduleFile, *routeFile;
    char* read = "r";
    airportFile = fopen(airports,read);
    if(!airportFile) {
	fprintf(stderr,"Cannot open file with list of airport names.");
	exit(EXIT_FAILURE);
    }
    flightSys_t* s = createSystem();
    if(s==NULL) {
	printf("createSystem unimplemented\n");
	return;
    }
    printf("***Parse and echo airports***\n");
    parseAirports(s,airportFile);
    fclose(airportFile);
    printAirports(s);
 
  scheduleFile = fopen(schedules,read);
    if(!scheduleFile) {
	fprintf(stderr,"Cannot open file with schedule.");
	exit(EXIT_FAILURE);
    }
    printf("\n***Parse and echo schedules***\n");
    parseSchedule(s,scheduleFile);  
    fclose(scheduleFile);
    routeFile = fopen(routes,read);
    if(!routeFile) {
	fprintf(stderr,"Cannot open file with routes.");
	exit(EXIT_FAILURE);
    }
    printf("\n***Parse and calculate route times***\n");
    calcRouteTimes(s,routeFile);
    fclose(routeFile);

    deleteSystem(s);
}
bool ProjectBarrier::XMLLoadSystem(const QDomElement &project) {
	System *s;
	unsigned int eigenfunctions = 0;
	QString str;

	QDomElement name = XMLUtils::childWithTag(project, "name");
	setName(name.text());

	QDomElement system = XMLUtils::childWithTag(project, "system");
	QDomElement barrierpotential = XMLUtils::childWithTag(system, "barrierpotential");
	
	// fill the dialog
	{
		QDomNode node;
		QDomElement elem;
		QLineEdit *edit = NULL;
		QString tag;
		bool status = true;
	
		for (node = system.firstChild(); !node.isNull(); node = node.nextSibling()) {
			elem = node.toElement();
			if (elem.isNull()) continue;
			tag = elem.tagName();
	
			if (tag == "points") m_dialog->m_numPoints_edit->setText(elem.attribute("value"));
			else if (tag == "lowervalue") m_dialog->m_lowIntegration_edit->setText(elem.attribute("value"));
			else if (tag == "highervalue") m_dialog->m_highIntegration_edit->setText(elem.attribute("value"));
			else if (tag == "particlemass") m_dialog->m_particleMass_edit->setText(elem.attribute("value"));
			else if (tag == "eigenfunction") eigenfunctions++; 
			else {}
		}

		str.setNum(eigenfunctions);
		m_dialog->m_eigenNumber_edit->setText(str);
	
		for (node = barrierpotential.firstChild(); !node.isNull(); node = node.nextSibling()) {
			elem = node.toElement();
			if (elem.isNull()) continue;
			tag = elem.tagName();
			if (tag == "lowedge") m_dialog->m_potentialLowEdge_edit->setText(elem.attribute("value")); 
			else if (tag == "highedge") m_dialog->m_potentialHighEdge_edit->setText(elem.attribute("value")); 
			else if (tag == "highpotential") m_dialog->m_extPotential_edit->setText(elem.attribute("value")); 
			else if (tag == "barrierlowedge") m_dialog->m_barrierLowEdge_edit->setText(elem.attribute("value"));
			else if (tag == "barrierhighedge") m_dialog->m_barrierHighEdge_edit->setText(elem.attribute("value"));
			else if (tag == "barrierheight") m_dialog->m_barrierHeight_edit->setText(elem.attribute("value"));
			else {}
		
		}

	}
		
	// check it

	if (checkValues(false)) {
		// fill system and potential
		s = createSystem();
	} else
		return false;
	
	// pass to model

	return m_model->XMLLoad(s, system);

}
Exemple #14
0
void vTaskSI (void* pvParameters)
{
  
  (void) pvParameters;
  portTickType xLastWakeTime;
  Module *entryDist, *asservPosDist, *asservVitDist, *measureDerivatorDist, *imeInIntegratorDist;
  Module *entryRot, *asservPosRot, *asservVitRot, *measureDerivatorRot, *imeInIntegratorRot;
  Module *ifaceMERight, *ifaceMELeft, *starter, *operatorIn, *operatorOut, *toggleSwitchLeft, *toggleSwitchRight;
  EntryConfig entryConfigDist, entryConfigRot;

  // Enregistrement de l'asservissement en distance
  ModuleValue posKpDist = 50;
  ModuleValue posKiDist = 0;
  ModuleValue posKdDist = 5;
  // ModuleValue derivDist = 16000;

  ModuleValue vitKpDist = 1000;
  ModuleValue vitKiDist = 0;
  ModuleValue vitKdDist = 15;
  // ModuleValue accelDist = 500;

  // ModuleValue commandDist = 2000;

  entryConfigDist.nbEntry = 9;
  entryConfigDist.value[0] = &posKpDist; // kp
  entryConfigDist.value[1] = &posKiDist; // ki
  entryConfigDist.value[2] = &posKdDist; // kd
  entryConfigDist.value[3] = &(trajDist.vit); // deriv
  entryConfigDist.value[4] = &vitKpDist; // kp
  entryConfigDist.value[5] = &vitKiDist; // ki
  entryConfigDist.value[6] = &vitKdDist; // kd
  entryConfigDist.value[7] = &(trajDist.acc); // accel
  entryConfigDist.value[8] = &(trajDist.pos); // command



  // Enregistrement de l'asservissement en rotation
  ModuleValue posKpRot = 50;
  ModuleValue posKiRot = 3;
  ModuleValue posKdRot = 15;
//  ModuleValue derivRot = 8000;

  ModuleValue vitKpRot = 1000;
  ModuleValue vitKiRot = 0;
  ModuleValue vitKdRot = 20;
//  ModuleValue accelRot = 1000;

//  ModuleValue commandRot = 200; // (200, -300) = max(command)

  entryConfigRot.nbEntry = 9;
  entryConfigRot.value[0] = &posKpRot; // kp
  entryConfigRot.value[1] = &posKiRot; // ki
  entryConfigRot.value[2] = &posKdRot; // kd
  entryConfigRot.value[3] = &(trajRot.vit); // deriv
  entryConfigRot.value[4] = &vitKpRot; // kp
  entryConfigRot.value[5] = &vitKiRot; // ki
  entryConfigRot.value[6] = &vitKdRot; // kd
  entryConfigRot.value[7] = &(trajRot.acc); // accel
  entryConfigRot.value[8] = &(trajRot.pos); // command

  // On ajoute un interupteur à notre shéma bloc 
  // qui empéche l'asserv de s'effectuer quand le pontH n'est pas alimenté
  EFBclearBit (DDR_HBRIDGE_ON, BIT_HBRIDGE_ON);
  ToggleSwitchConfig toggleSwitchConfig;
  toggleSwitchConfig.value = (uint8_t*) &(PORT_HBRIDGE_ON);
  toggleSwitchConfig.mask = _BV (BIT_HBRIDGE_ON);
  toggleSwitchConfig.off = TOGGLE_ON;
  

  xLastWakeTime = taskGetTickCount ();

  // Création du Starter
  starter = initModule(&ctlBlock, 1, 0, starterType, 0);
  if (starter == 0)
  {
   return;
  }
  // Création de l'interface systeme (IfaceMERight)
  ifaceMERight = initModule(&ctlBlock, 1, 2, ifaceMEType, 1);
  if (ifaceMERight == 0)
  {
   return;
  }
  // Création de l'interface systeme (IfaceMELeft)
  ifaceMELeft = initModule(&ctlBlock, 1, 2, ifaceMEType, 0);
  if (ifaceMELeft == 0)
  {
   return;
  }
  // Création de l'operateur asservs -> IMEs
  operatorIn = initModule(&ctlBlock, 2, 2, operatorType, 1);
  if (operatorIn == 0)
  {
   return;
  }
  // Création de l'operateur IMEs -> asservs
  operatorOut = initModule(&ctlBlock, 2, 2, operatorType, 0);
  if (operatorOut == 0)
  {
   return;
  }
  toggleSwitchRight = initModule(&ctlBlock, 1, 1, toggleSwitchType, 0);
  if (toggleSwitchRight == 0)
  {
   return;
  }
  toggleSwitchLeft = initModule(&ctlBlock, 1, 1, toggleSwitchType, 0);
  if (toggleSwitchLeft == 0)
  {
   return;
  }

  // Création de l'Entry
  entryDist = initModule(&ctlBlock, 0, entryConfigDist.nbEntry, entryType, 0);
  if (entryDist == 0)
  {
   return;
  }
  asservPosDist = initModule(&ctlBlock, 6, 1, asservType, 0);
  if (asservPosDist == 0)
  {
   return;
  }
  asservVitDist = initModule(&ctlBlock, 6, 1, asservType, 0);
  if (asservVitDist == 0)
  {
   return;
  }
  measureDerivatorDist = initModule(&ctlBlock, 1, 1, derivatorType, 0);
  if (measureDerivatorDist == 0)
  {
   return;
  }
  imeInIntegratorDist = initModule(&ctlBlock, 1, 1, integratorType, 0);
  if (imeInIntegratorDist == 0)
  {
   return;
  }
  // Création de l'Entry
  entryRot = initModule(&ctlBlock, 0, entryConfigRot.nbEntry, entryType, 0);
  if (entryRot == 0)
  {
   return;
  }
  asservPosRot = initModule(&ctlBlock, 6, 1, asservType, 0);
  if (asservPosRot == 0)
  {
   return;
  }
  asservVitRot = initModule(&ctlBlock, 6, 1, asservType, 0);
  if (asservVitRot == 0)
  {
   return;
  }
  measureDerivatorRot = initModule(&ctlBlock, 1, 1, derivatorType, 0);
  if (measureDerivatorRot == 0)
  {
   return;
  }
  imeInIntegratorRot = initModule(&ctlBlock, 1, 1, integratorType, 0);
  if (imeInIntegratorRot == 0)
  {
   return;
  }





 debug("H");
  if (createSystem(&ctlBlock, starter , 50) == ERR_TIMER_NOT_DEF)
  {
   return;
  }

   
   // debug("oii: %l %l\r\n", (uint32_t)getInput(parent, 0), (uint32_t)getInput(parent, 1));

// debug("cp\r\n");


  if (configureModule(starter, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(ifaceMELeft, (void*)&imes[0]) != NO_ERR)
  {
   return;
  }
  if (configureModule(ifaceMERight, (void*)&imes[1]) != NO_ERR)
  {
   return;
  }
  if (configureModule(operatorIn, (void*)funCalcValueForMotor) != NO_ERR)
  {
   return;
  }
  if (configureModule(operatorOut, (void*)funCalcValueForAsserv) != NO_ERR)
  {
   return;
  }
  if (configureModule(toggleSwitchRight, (void*)&toggleSwitchConfig) != NO_ERR)
  {
    return;
  }
     debug("E");
  if (configureModule(toggleSwitchLeft, (void*)&toggleSwitchConfig) != NO_ERR)
  {
    return;
  }
   debug("E");


  if (configureModule(entryDist, (void*)&entryConfigDist) != NO_ERR)
  {
   return;
  }
  if (configureModule(asservPosDist, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(asservVitDist, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(measureDerivatorDist, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(imeInIntegratorDist, NULL) != NO_ERR)
  {
   return;
  }

  if (configureModule(entryRot, (void*)&entryConfigRot) != NO_ERR)
  {
   return;
  }
  if (configureModule(asservPosRot, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(asservVitRot, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(measureDerivatorRot, NULL) != NO_ERR)
  {
   return;
  }
  if (configureModule(imeInIntegratorRot, NULL) != NO_ERR)
  {
   return;
  }
   debug("E");


  // DISTANCE
  linkModuleWithInput(entryDist, 8, asservPosDist, AsservCommand);
  linkModuleWithInput(entryDist, 0, asservPosDist, AsservKp);
  linkModuleWithInput(entryDist, 1, asservPosDist, AsservKi);
  linkModuleWithInput(entryDist, 2, asservPosDist, AsservKd);
  linkModuleWithInput(entryDist, 3, asservPosDist, AsservDeriv);
  linkModuleWithInput(operatorOut, 0, asservPosDist, AsservMeasure);
  linkModuleWithInput(asservPosDist, 0, asservVitDist, AsservCommand);

  linkModuleWithInput(entryDist, 4, asservVitDist, AsservKp);
  linkModuleWithInput(entryDist, 5, asservVitDist, AsservKi);
  linkModuleWithInput(entryDist, 6, asservVitDist, AsservKd);
  linkModuleWithInput(entryDist, 7, asservVitDist, AsservDeriv);
  linkModuleWithInput(operatorOut, 0, measureDerivatorDist, 0);
  linkModuleWithInput(measureDerivatorDist, 0, asservVitDist, AsservMeasure);
  linkModuleWithInput(asservVitDist, 0, imeInIntegratorDist, 0);

  linkModuleWithInput(imeInIntegratorDist, 0, operatorIn, 0);


  // ROTATION
  linkModuleWithInput(entryRot, 8, asservPosRot, AsservCommand);
  linkModuleWithInput(entryRot, 0, asservPosRot, AsservKp);
  linkModuleWithInput(entryRot, 1, asservPosRot, AsservKi);
  linkModuleWithInput(entryRot, 2, asservPosRot, AsservKd);
  linkModuleWithInput(entryRot, 3, asservPosRot, AsservDeriv);
  linkModuleWithInput(operatorOut, 1, asservPosRot, AsservMeasure);
  linkModuleWithInput(asservPosRot, 0, asservVitRot, AsservCommand);

  linkModuleWithInput(entryRot, 4, asservVitRot, AsservKp);
  linkModuleWithInput(entryRot, 5, asservVitRot, AsservKi);
  linkModuleWithInput(entryRot, 6, asservVitRot, AsservKd);
  linkModuleWithInput(entryRot, 7, asservVitRot, AsservDeriv);
  linkModuleWithInput(operatorOut, 1, measureDerivatorRot, 0);
  linkModuleWithInput(measureDerivatorRot, 0, asservVitRot, AsservMeasure);
  linkModuleWithInput(asservVitRot, 0, imeInIntegratorRot, 0);

  linkModuleWithInput(imeInIntegratorRot, 0, operatorIn, 1);



  linkModuleWithInput(operatorIn, 1, ifaceMERight, 0);
  linkModuleWithInput(operatorIn, 0, ifaceMELeft, 0);
  // linkModuleWithInput(toggleSwitchRight, 0, ifaceMERight, 0);
  // linkModuleWithInput(toggleSwitchLeft, 0, ifaceMELeft, 0);

  linkModuleWithInput(ifaceMERight, 0, operatorOut, 1);
  linkModuleWithInput(ifaceMELeft, 0, operatorOut, 0);

  // linkModuleWithInput(ifaceMERight, 0, starter, 1);
  linkModuleWithInput(ifaceMELeft, 0, starter, 0);
  
   debug("E");

  //resetSystem(&ctlBlock, portMAX_DELAY);
  for (;;)
  {
    if (startSystem(&ctlBlock) == NO_ERR)
    {

      if(waitEndOfSystem(&ctlBlock, 10000) == NO_ERR)
      {
        //resetSystem(&ctlBlock, portMAX_DELAY);
        //command += 500;
      }
    }
    // Cette fonction permet à la tache d'être périodique.
    // La tache est bloquée pendant (500ms - son temps d'execution).
     vTaskDelayUntil(&xLastWakeTime, 500/portTICK_RATE_MS);
  }