Can I build an EMYS myself? 

EMYS is an open project. All of the details necessary to build your own robot (drawings, software, BOMs, etc.) are accessible via this website. You can find your own local suppliers for custom components used in the robot based on the supplied documentation. Compare their prices with the ones available here: www.order.flash-robotics.com. If prices offered by your supplier are higher, contact us and we'll help you contact the suppliers that we cooperate with. 

Is the price for an assembled robot higher than the price of its components?

Yes it is. Our team charges a small fee for assembling and fine-tuning the robot. EMYS is built on request. Its components are manufactured at different locations and require slight processing to fit together. We also tune all of the robots drives after assembly to compensate for any differences that might arise due to manufacturing issues. Remember that ordering an assembled head supports our team and allows us to continue working on EMYS and making him a better. 

How long do I have to wait if I order an assembled robot?

Lead time for a basic EMYS configuration is 10 weeks.

What materials is EMYS made of?

EMYS support structure is made out of milled aluminum components (aluminum designation: 2017A/PA6). Head covers and various elements located inside of the robot are 3D printed (technology: SLS, material: PA2200).

Are EMYS' drives commercially available?

Yes. All of the drives that we use can be bought directly from their respective manufacturers. Some of them do require slight mechanical adjustments. 

Can I order the robot in a different color?

Yes, just send us the color designation for the paint you would like us to use.

Can I buy spare parts (drives, mechanical elements, wires, etc.)?

Yes. Remember, however, that we usually don't stock spare parts so you will have to wait until they are manufactured/delivered.

Can I modify EMYS by adding new sensors, changing parts, drilling new mounting holes, etc.?

Yes, EMYS is first and foremost a research platform so that's what it's for. Just remember that we do not issue a warranty for the whole robot. Some of its commercially available parts do have a warranty issued by their manufacturer and we'll gladly replace those if such need arises.

Can I order the robot with custom modifications such as new sensors/components??

Yes, we process every order individually and can customize EMYS to suit your specific needs. If we like a modification that you suggested, we'll introduce it into our permenent offer and we'll implement it for you for free.

Can EMYS be powered from a battery?

Yes, just remember not to exceed the allowed voltage levels (recommended 12V DC, max. 14V DC).

What is the average power required by the head?

The current is drawn mostly by the neck motors (Robotis Dynamixel servos) so the total current draw will depend heavily on how much you use these drives. There are 1 MX-28 servos (1.4A), 2x MX-106 servos (5.4A each) and 1x MX-64 servo (4.1A). So, theoretical total current may be quite high. But, of course there is no chance to apply so high load in every joints at the same time, even during jerk movements. During normal operation average current is 2-3A.

Is the robot software free?

Yes, most of the libraries integrated with EMYS' control system are free. There is a fee for some features such as additional voices in speech synthesizers, navigation, user recognition, etc.

Can I use EMYS' control system with another robot?

Yes, if you manage to integrate the low-level controllers with your hardware. In the Tutorials section, you'll find examples on how to integrate an evaluation board with our control system. Moreover, if your robot utilizes servomotors compliant with Dynamixel protocol and popular sensors such as Kinect or a webcam, you will not need to make any modifications at all. 

How can I add a new sensor to the robot?

Firstly, you have to enable communication between the sensor and the master PC. This can be done using a serial interface (you can use the ready and tested USerial module). Then, you have to implement a module (UObject) integrating the new device with the URBI engine. The last thing to do is to write a script including the device into the robot structure and that's it. After you manage to integrate the device with EMYS, be sure to share your solution with all the other EMYS users around the world!

How are various tasks synchronized in the robot's control system? Is access to the resources safe?

The Urbi engine, operating in the main thread, runs the low-level modules synchronously using the data and functions that they provide. Modules which consume a significant amount of CPU time can be run asynchronously in separate threads. The thread, that the Urbi engine runs in, will not be blocked and the engine will be able to effectively perform other tasks in the background. Urbi is thread-safe since it provides synchronization and extensive access control for tasks that are run in separate threads. It is possible to control access to resources at the level of modules, instances created within the system or single functions. An example could be the detection of objects within an image. Urbi can run the time-consuming image processing process in a separate thread leaving the other operations (e.g. trajectory generation) unaffected. Components that use the data that are the result of image processing will be waiting for the results of the module's operation. The above mechanism meets the criteria of a soft real-time system. Hardware robot drivers whose operation is critical (e.g. balancing controller) are implemented on microprocessors using a lightweight hard real-time operating system.

Where in the robot's three-layer control architecture should I place my new module?

When adding a new component to the system, yoy should take care to integrate it into the existing architecture with regards to its three layers. Low level modules of the control system should provide a minimal set of features that allow to utilize the full capabilities of the devices or software they are an interface to. Due to the flexibility of the control architecture, modules can span more than one layer. This feature allows to avoid the artificial partitioning of some components. This happens most often in the case of components that use external libraries that provide both low-level drivers and competencies that belong in the middle layer. For example, OpenNI software can be used to retrieve data from an RGB-D sensor (lowest layer) and provide data on silhouettes detected by the sensor (middle layer).

What can Emys do out of the box?

Emys is not typical out of the box product – you always need some easy installation and configuration as described in First steps. If you want to see EMYS playing out one of the ready scenarios, chose in the configuration file (via _FSMFile variable) one of the existing scenarios (from urbi_scripts/FSM folder) and launch the windows batch file for starting the robot. However, the best way to start work with the robot is to launch it with a simple configuration (without any scenario file), connect to Urbi engine via console and try to program EMYS yourself.

How to prepare my own program for EMYS?

Firstly, you have to prepare your own configuration file. The best way to do it is editing _CONFIG_.u from urbi_scripts folder. Detailed instruction on how to create a custom configuration file can be found in Control system configuration. Within the configuration file you must indicate, among others, a list of competency manager files (_CompetencyManagerFiles variable) and a scenario file (_FSMFile variable). In the competency manager files you have to define all of EMYS' functions which you would like to use in your scenario. A lot of EMYS' functions can be found in scripts in competencyManager folder. You can also look at Urbiscript examples where some competency functions are explained. Scenario file should contain a script that will be executed after startup. This script can be written directly in urbiscript or generated from Gostai Studio software (the latter allows creating scenarios based on finite state machines). The last step is to prepare your own startup file (windows batch file), which will start URBI engine and load your configuration – details can be found in Creating startup file section.

I want to EMYS to understand and say more, what should I do?

EMYS speech recognition is based on MSP or SAPI, whereas speech synthesis solely on MSP. In order for EMYS to understand more, you should extend the number of rules that he will understand. Grammar files currently used by EMYS can be found in grammars folder. To get more information about creating grammars see LINK. EMYS’ speech is currently stored in EmysDialogs.u and SpeechSequences.u competency files. The idea is to store all EMYS' utterances in all of the utilized languages in robot.dialogue.speech_sequences vector, and refer to particular phrases by vector index. To add new uterrences, simply extend the vector size and add new utterances at the end of it (or instead of existing ones if you do not plan to use them). You can also directly use EMYS API functions to say the utterance given as function parameter. EMYS control system is open, so you can integrate other speech synthesis/recognition software with it. For this purpose you should create a new module, which will serve as an interface to the chosen software – for more details see Creating single module. Afterwards, the new module should be integrated with the EMYS API (to see how it is done check out other FAQ questions and Urbiscript examples.)

How to add my own component to EMYS API?

EMYS API is based on tree-like structure called robot. To add a new component simply write:
    robot.addComponent("myNewComponent");   //adds a new, empty component
To copy a slot from a UObject module to the structure write:
    MyModule.getSlot("MySlot").copy(robot.myNewComponent,"MySlotApiName");
To add a new function to the structure write:
    do (robot.myNewComponent)
    {
       Function MyApiFunction() {call.MyFunction();};
    };
To see examples on extending the API see Urbiscript examples.

What is the difference between direct module access and API access, e.g. to Kinect device?

If API contains a copy of the module's slots – none. To access the image from Kinect depth stream you can write both: 
    Global.Kinect.depthImage; 
and

    robot.video.kinect.depthImage; 
and achieve the same effect. However, using robot structure is preferred, because it assures unified access to all robot components. Functions or attributes accessed via the robot structure often also have more to offer than raw data from a module (e.g.
    robot.video.humanDetector.head.orientation;
stores user head 3D orientation relative to the robot after considering the offset between Kinect and EMYS and can be used directly for following the user's face, whereas
    Kinect.facePosition();
returns a raw vector of [x, y ,z, pitch, yaw, roll] which needs to be preprocessed before the data it provides can be used for tracking).

How to cite EMYS?

  • J. Kędzierski, R. Muszyński, C. Zoll, A. Oleksy, and M. Frontkiewicz. 2013. "EMYS Emotive Head of a Social Robot". International Journal of Social Robotics, 10.1007/s12369-013-0183-1, pages 237-249, Springer Netherlands
  • J. Kędzierski, P. Kaczmarek, M. Dziergwa, K. Tchoń, "Design for a Robotic Companion", International Journal of Humanoid Robotics, 10.1142/S0219843615500073, January 2015

Could you provide details on the parameter position of movement of neck pitch using Move command? The position variable when I pass +2 and then -2, shouldn't the neck return back to original position?

1. First of all, EMYS’ has two pitch joints:
Neck (q1) use this command to check the value:

robot.body.neck.pitch.val;

Head (q3) use this command to check its value:

robot.body.neck.head.pitch.val;

2. If you set new value directly to the joint like this:

robot.body.neck.pitch.val += 2;
robot.body.neck.pitch.val -= 2;

Emys moves to the new position as fast as he can (not recommended).

3. You can also use URBI build-in trajectory generators:

var tmp = robot.body.neck.pitch.val;
robot.body.neck.pitch.val = tmp + 10 smooth: 1s;

More info about generators you can find here: LINK and LINK

4. And as you mentioned, you can use Move function (actually it use trajectory generators as above):

robot.body.neck.pitch.Move(10, 1s);
robot.body.neck.pitch.Move(0, 1s);

NOTE! This time first argument is a new position relative to the joint neutral position, second argument it’s just a time of execution. Neutral positions for your robot for all joints you can find in the "_Config_.u" file in the variable "_Head_ZeroPosition" like this:

// Head zero positions [deg/mm]
// [neckPitch, headYaw, headPitch, downDisc, upDisc, leftEyeLid, leftEyeBrow, leftEyeTrans, rightEyeLid, rightEyeBrow, rightEyeTrans]
var _Head_ZeroPosition = [...];

By default, EMYS is configured to "angled starting position" (scroll down to see the option LINK ). Last thing, after command

robot.body.neck.head.BehaveNormal(1);

EMYS will be exactly in the starting position according to the variable "_Head_ZeroPosition".

 

 

EMYS and FLASH are Open Source and distributed according to the GPL v2.0 © Rev. 0.9.1, 15.05.2017

FLASH Documentation