Close
0%
0%

Open FURBY

Our goal is to modify FURBY toy manufactured by Hasbro Inc. and equipped him in a custom controller that allows to control him form PC.

Similar projects worth following
Multiple robotics projects are developed, aimed at providing the humans with friendly robots permanently accompanying them in their daily lives. In the majority they represent expensive robotic constructions with very limited possibilities. The establishment and maintenance of the robot-human communication, both verbal and non-verbal, depend essentially on capabilities of naturally and plausibly showing emotions by generating facial expressions by the robot.

FURBY toy manufactured by Hasbro Inc. has a friendly appearance with outstanding capabilities in such price segment. Unfortunately, manufacturer does not provide for the possibility of using its product as a HRI (human-robot interaction) research platform. There is no possibility of full behaviour control. Our goal is to modify current version of FURBY and equipped him in a custom controller that allows to control him form PC.

FURBY and the FURBY logo are trademarks of Hasbro Inc. registered in the U.S. and other countries.

Open FURBY uP controller is based on NXP Kinetis, Cortex M4. Firmware is managed by NXP MQX™ real-time operating system. Controller utilise Robotis Dynamixel protocol to communicate with PC. So, you can control him by any software that has implemented this kind of protocol. E.g. communication with motor, LCDs and all sensors may be realized in ROS which have their own dedicated dynamixel_motor node.

The PC control system that Open FURBY utilize as the main is an open-source software based on Gostai Urbi and compliant with the three-layer architecture paradigm. This system was developed by FLASH Robotics at the Wroclaw University of Technology to control their robots EMYS and FLASH.

www.flash-robotics.com

The lowest layer of the control system consists of modules called UObjects which enable the programmer to access motion controllers, sensors and external software. These modules, written in C++, can be dynamically loaded into Urbi engine, which takes care of their orchestration (e.g. scheduling and parallelization of tasks).

The middle layer of the control architecture is responsible for the implementation of competencies, which define what tasks the robot will be able to perform. The competencies are usually implemented as sets of functions delivered by the low level modules. Urbi delivers a script language called urbiscript that gives the programmer a quick way of creating and synchronizing complex behaviors. The designed control system enables accessing the robot hardware and competencies in a unified manner - using a tree structure called robot. It makes using the API, implemented in the middle layer, more convenient and helps to maintain the modularity of software. Elements of the robot structure have been grouped based on their role, e.g. audio, video, body, emotions, network. The middle layer also contains the competency manager which decides how the specific behaviors should be realized, depending on the current physical setup of the robot (oFURBY can operate as a standalone robot or be combined with cameras, Kinect, arms or even mobile platform) every combination requires a different set of scripts in the competency manager).

The highest layer should contain a dedicated decision system responsible for utilizing the behaviors provided by the middle layer with respect to a specific application. This layer can contain anything from a simple remote controller to a complex system simulating human mind.

Finally, Open FURBY possessed functions allowing him to move his body in the same way as original version, speak generation and recognition, generate emotions, equiped with cammera or Kinect detect person/objects, find and read news from the Internet (and communicate them with regard to emotional content), browse websites, RSS channels, TV guides, weather forecast, stock exchange, etc. Open FURBY can also provide many different communication channels such as: e-mails, Facebook, Google Contacts, etc.

More about FLASH's software you can find here:

www.doc.flash-robotics.com

and there is a special edition set of scripts for Open FURBY:

github.com/FLASHRobotics/urbi_scripts_OpenFurby

oFURBY API documentation (only body part, rest is the same) :

www.facebook.com/notes/open-furby/open-furby-full-api-documentation/1684065541816397

Software installation:

www.facebook.com/notes/open-furby/control-system-installation/1684211061801845

and some programming examples:


View all 9 components

  • 1
    Step 1

    Mechanical modification

    First we start to modify plastic casing of furby. It is necessary because we need some space for new OLED displays as eyes. We have to cut out the both side of furby. The holes were needed in the first version of mounting OLED displays, but we changed it, so you do not have to cut your furby so much. Next we grind the frame, which is around the LCD eyes. We also grind PCB of OLED displays.

    Adafruit displays' electronic should be also modified. We do not need voltage translators and voltage regulators because we use 3V3 in the whole system. Just remove and bypass them. SD card slots should be also removed to get more space inside.

    Next step is to fasten the switch, which is use to check if the tongue is pushed. We solder all wires (to displays and to the switch) and bring them out of furby casing.

    Then we assemble toy in one piece again. We use the original furby encoder and ‘zero position’ sensor. When the wire is out of furby we fasten original furby speaker. Then we twist with screws the casing.













    In the end, we have to stick copper tape as a touch sensor to: head, back, both sides and belly.

  • 2
    Step 2

    Open FURBY uC controller

    The original Furby controller from Hasbro we changed with our own. Now we can manipulate with different elements of Open FURBY and read values from sensors. Open Furby driver contains:

    • uC NXP Kinetis K40 (MK40DN512VLK10) with ARM Cortex-M4, 100MHz, 128kB RAM, 512kB FLASH
    • 5 touch sensors (TSI module)
    • H-bridge TB6612 and optical encoder to control DC motor
    • Audio codec SGTL5000 for sound playing
    • Micro SD card reader for storage eyes images (.bmp) and audio files
    • USB port for communication
    • Speaker and microphone
    • Two color OLED 128x96 px displays which communicate via SPI
    • Encoder is connected to FlexTimer which is working as a quadrature decoder
    • Sensor of position zero, mouth and tail which are connected to GPI
    Here is the Open FURBY electronic schematic.

    Here is also a pcb of Open FURBY project, but this is only a prototype. In the next version the whole electronic will be inside robot.

    1. 3
      Step 3

      PC control system

      Driver installation

      After connecting Open FURBY USB connector to the master PC controller you must install serial control port driver. Driver are usually installed automatically by Windows; if not install the following driver LINK.

      URBI control system installation

      • Create main URBI directory on your hard drive (or cloud drive) (see fig. below).
      • Download Urbi Engine 2.7.5 SDK LINK and extract all files to this folder.
      • For working with Urbi install Urbi console LINK and Urbi editor LINK.
      • From GitHub LINK, download modules LINK and urbi_scripts LINK folders and copy them to your main URBI folder.

      URBI control system configuration

      Before starting Open FURBY, you should configure his control system. The main configuration file is called _CONFIG_.u and is located in ubi_scripts catalog . For more information see Control system configuration in Software section.

      Check the number of Open FURBY Serial Port in Device Manager and modify _CONFIG_.u file in urbiscripts folder. You should change _com_furby variable (from “COM3” to appropriate COM number) in FURBY CONFIGURATION section.

      Starting robot.

      To start Open FURBY, run single.exe or single.bat (edit it if needed) from modules catalog; this will launch Urbi engine and load Open FURBY configuration file along with all the necessary functions.

      After loading all files, you should see "ROBOT READY :-)" info. By default, basic set of Open FURBY competencies is loaded, which can be called via Urbi console.

      Run GOSTAI Console (or other telnet type), set connection port settings and connect to the already running engine. Now you can load your commands into the engine. Call a simple behavior command to check how Open FURBY is running.

      // move to the position 100 in 3sec

      robot.body.position.Move(100,3s);

      // change eye graphics and enable scrolling

      robot.body.eye.image.val=102;
      robot.body.eye.scroll.val=2;

      // simple behaviors

      robot.body.MoveNeutral(2);

      robot.body.MoveBack(2);

      robot.body.MoveForward(2);

      robot.body.MoveCloseEye(1);

      robot.body.MoveCloseEye2(1);

      robot.body.Speak(10,200);

      t:robot.body.ActAlive(200), sleep(10s); t.stop;

      t:robot.body.ActSleep(200), sleep(10s); t.stop;

    View all 3 instructions

    Enjoy this project?

    Share

    Discussions

    Open FURBY wrote 08/01/2017 at 18:50 point

    Still interested in Open FURBY project? Would you like to have your own? Please, help us and fill out the survey. https://goo.gl/forms/AtYEvLmBCwgJkfYz1

      Are you sure? yes | no

    Open FURBY wrote 01/30/2016 at 22:04 point

    Sure. Our Open FURBY is based on Furby BOOM which is similar to Furby 2012.

      Are you sure? yes | no

    Yours Truly wrote 01/30/2016 at 20:43 point

    Does this work with 2012 Furbies? 

      Are you sure? yes | no

    Similar Projects

    Does this project spark your interest?

    Become a member to follow this project and never miss any updates