en to fr translation catalogue (33 entries)

note: type: Title-text
en: Remote control #4
fr: Télécommande #4

note: type: Resume-text
en: Remote control a bot without using an information exchange post by defining a class for the orders.
fr: Télécommandez un robot sans station relais en utilisant une classe définissant un ordre.

note: type: \b; header
en: Exercise
fr: Exercice

note: type: Plain text
en: Remote control a slave robot without using an <a object|exchange>information exchange post</a>. The robot should pass over the 6 blue crosses. You must use a <code><a cbot|static>static</a></code> variable to pass the orders to the slave bot.
fr: Télécommandez un robot, sans utiliser une <a object|exchange>station relais</a>, pour qu'il passe par les 6 croix bleues. Il faudra utiliser une variable <code><a cbot|static>static</a></code> pour communiquer directement d'un programme à un autre.

note: type: Plain text
en: The two main actors of this exercise are:
fr: Les 2 acteurs principaux de cet exercice sont:

note: type: Bullet: '1)'
en: The <a object|botgr>wheeled grabber</a> without an energy pack and therefore immobile. This is the master you should program so it will transmit orders to the slave.
fr: Un <a object|botgr>robot préhenseur</a> sans batterie, donc immobile. C'est lui l'émetteur que vous devez programmer.

note: type: Bullet: '2)'
en: The slave <a object|bottr>practice bot</a> which is already programmed and just waits for orders from the master.
fr: Un <a object|bottr>robot d'entraînement</a> qui attend les ordres. Ce robot est déjà programmé.

note: type: \b; header
en: The slave
fr: Le robot récepteur

note: type: Plain text
en: First of all we must understand how the program of the slave works. The <a cbot|class>class</a> <code>order</code> contains two members: <code>m_type</code> is the order to execute (move or turn) and <code>m_param</code> is the distance to move or the rotation angle:
fr: Pour commencer, il faut comprendre le programme du robot d'entraînement qui attend les ordres.
    Une <a cbot|class>classe</a> <code>order</code> contient deux variables: <code>global_type</code> détermine l'ordre à effectuer (avancer ou tourner) et <code>global_param</code> détermine la distance à avancer ou l'angle de rotation:

note: type: Source code
en: {
    	<a cbot|int>int</a>    m_type = <a cbot|nan>nan</a>;
    	<a cbot|float>float</a>  m_param;
    }
fr: {
    	<a cbot|int>int</a>    global_type = <a cbot|nan>nan</a>;
    	<a cbot|float>float</a>  global_param;
    }

note: type: Plain text
en: A second <a cbot|class>class</a> <code>exchange</code> contains the mechanism for exchanging the orders. We declare a <code><a cbot|static>static</a></code> class member <code>m_order</code> which will contain the order to be executed. The word <code>static</code> insures that the member <code>m_order</code> is shared between all instances of the <a cbot|class>class</a> exchange.
fr: Une deuxième <a cbot|class>classe</a> <code>exchange</code> contient le mécanisme d'échange et de mémorisation des ordres. Il faut d'abord déclarer une variable <code><a cbot|static>static</a></code> appelée ici <code>global_order</code>. Cette variable contient l'ordre à effectuer. L'instruction <code>static</code> permet à tous les robots d'accéder à la même variable unique.

note: type: Source code
en: {
    	<a cbot|static>static</a> <a cbot|private>private</a> order m_order = new order;
fr: {
    	<a cbot|static>static</a> <a cbot|private>private</a> order global_order = new order;

note: type: Plain text
en: <n/>The <code>put</code> method will be used by the master robot for transmitting an order. As long as <code>m_order</code> is different from <code><a cbot|nan>nan</a></code>, the slave has not finished the order and the <code>put</code> method will return <code>false</code> and will do nothing:
fr: Une première méthode <code>put</code> sera utilisée par le robot émetteur pour donner un ordre. Si l'ordre est différent de <code><a cbot|nan>nan</a></code>, cela signifie qu'il n'a pas encore été effectué par le robot récepteur. Dans ce cas, la méthode <code>get</code> ne fait rien et retourne <code>false</code>:

note: type: Source code
en: 	{
    		if ( m_order.m_type == nan )
    		{
    			m_order = a;
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}
fr: 	{
    		if ( global_order.global_type == nan )
    		{
    			global_order = a;
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}

note: type: Plain text
en: Another method <code>get</code> will be used by the slave to retrieve the orders. This method returns the order to be executed:
fr: Une deuxième méthode <code>get</code> sera utilisée par le robot récepteur pour prendre connaissance d'un ordre à effectuer:

note: type: Source code
en: 	{
    		return m_order;
    	}
fr: 	{
    		return global_order;
    	}

note: type: Plain text
en: A third method <code>delete</code> will be used by the slave to indicate that the order has been executed:
fr: Une troisième méthode <code>delete</code> sera utilisée par le robot récepteur pour indiquer que l'ordre est terminé:

note: type: Source code
en: 	{
    		m_order.m_type = nan;
    	}
    }
fr: 	{
    		global_order.global_type = nan;
    	}
    }

note: type: Plain text
en: The main program of the slave contains an instance of the class <code>exchange</code> called <code>list</code>. We put () after the word <code>list</code> in order to create an instance of the class <code>exchange</code>.
fr: Le programme principal peut maintenant exister. La variable <code>list</code> est de type <code>exchange</code>, qui est une <a cbot|class>classe</a>. Il faut utiliser l'instruction <code><a cbot|new>new</a></code> pour créer immédiatement une instance.

note: type: Source code
en: {
    	exchange list();
    	order    todo;
fr: {
    	exchange list = new exchange();
    	order    todo;

note: type: Plain text
en: The outer <code>while</code> loop lasts for ever. The inner <code>while</code> loop waits for an order by using the <code>get</code> method of the <code>exchange</code> class. As soon as <code>get</code> returns a value different from <code>nan</code>, the while loop stops.
fr: La première boucle <code>while</code> exécute les ordres à l'infini. La deuxième boucle <code>while</code> attend un ordre en exécutant la méthode <code>get</code> de la classe <code>exchange</code>. Dès qu'un ordre contenant une valeur différente de <code>nan</code> est reçu, la boucle est stoppée.

note: type: Source code
en: 	{
    		<a cbot|while>while</a> ( true )
    		{
    			todo = list.get();
    			if ( todo.m_type != nan )  break;
    			wait(1);
    		}
fr: 	{
    		<a cbot|while>while</a> ( true )
    		{
    			todo = list.get();
    			if ( todo.global_type != nan )  break;
    			wait(1);
    		}

note: type: Plain text
en: Now we have received the order in the <code>todo</code> variable. All we have to do is execute it:
fr: Il ne reste plus qu'à exécuter l'ordre reçu:

note: type: Plain text
en: <c/><s/>		if ( todo.m_type == 1 )
fr: <c/><s/>		if ( todo.global_type == 1 )

note: type: Source code
en: 		{
    			move(todo.m_param);
    		}
    		else if ( todo.m_type == 2 )
    		{
    			turn(todo.m_param);
    		}
    		else
    		{
    			message("Unknown order");
    		}
fr: 		{
    			move(todo.global_param);
    		}
    		else if ( todo.global_type == 2 )
    		{
    			turn(todo.global_param);
    		}
    		else
    		{
    			message("Unknown order");
    		}

note: type: Plain text
en: As soon as the execution of the order is finished, we must call the <code>delete</code> method so the master knows that another order can be sent:
fr: Dès que l'exécution de l'ordre est terminée, il faut appeler la méthode <code>delete</code> pour indiquer au robot émetteur qu'il peut envoyer l'ordre suivant:

note: type: \b; header
en: The master
fr: Le robot émetteur

note: type: Plain text
en: In the master we write an function called <code>SendOrder</code> which will send an order to the slave:
fr: Dans le robot émetteur, il est plus simple d'écrire une procédure <code>SendOrder</code> qui se charge d'envoyer un ordre au robot récepteur:

note: type: Source code
en: {
    	exchange list();
    	order    todo();
    	
    	todo.m_type = order;
    	todo.m_param = param;
    	
    	while ( list.put(todo) == false )
    	{
    		wait(1);
    	}
    }
fr: {
    	exchange list = new exchange();
    	order    todo();
    	
    	todo.global_type = order;
    	todo.global_param = param;
    	
    	while ( list.put(todo) == false )
    	{
    		wait(1);
    	}
    }

note: type: Plain text
en: The <code>while</code> loop waits until a pending order has been terminated, that is the slaved has exited from the <code>get</code> method and the <code>delete</code> method has been called.
    Now the main program of the master is very simple:
fr: La boucle <code>while</code> attend qu'un éventuel ordre précédent soit terminé, ce qui arrive lorsque le robot récepteur exécute la méthode <code>delete</code>.
    Le programme principal est finalement d'une simplicité enfantine:

note: type: Plain text
en: <format key><key help/></format> show these instruction at any time.
fr: <format key><key help/></format> permet de revoir ces instructions en tout temps!

note: type: \t; header
en: See also
fr: Voir aussi

note: type: Plain text
en: <a command>Controls</a> and <a cbot>programming</a>.
fr: <a tremote3>Exercice précédent</a> et <a cbot>programmation</a>.
