Jenny 5 robot

Jenny 5 is a fully open-source robot. It has a mobile platform, a flexible leg, two arms with 7 degrees of freedom each and a head.

Similar projects worth following
Jenny 5 is an (almost) humanoid robot intended to be used mainly for research but also as a human assistant.

Jenny 5 has a mobile platform with rubber tracks, a pliable leg, two arms with 7 degrees of freedom each and one head

All source files (CAD, software etc) for Jenny 5 are freely available on GitHub.

Jenny 5 is easy and cheap to build. Most components can be purchased from robotics stores. Custom made parts can be printed with a 3D printer. The aluminum profiles can be cut and drilled with tools available for hobbyists.

Materials (excepting the computer) cost about 2500 USD.

Jenny 5 is an (almost) humanoid robot intended to be used mainly for research but also as a human assistant. More details about Jenny 5 can be found at: or

Jenny 5 was inspired by the Johnny 5 robot from the Short circuit movie. This a great movie that anyone must see.

Jenny 5 has a mobile platform with tracks, a pliable leg, two arms with 7 degrees of freedom each and one head

All source files (CAD, software etc) for Jenny 5 are freely available on GitHub. All code is released under MIT license so that anyone can freely use it in both personal and commercial applications.

Jenny 5 is easy and cheap to build. Most components can be purchased from robotics stores. Custom made parts can be printed with a 3D printer. Some aluminium profiles can be cut and drilled with tools available for hobbyists.

Materials (excepting the computer) cost about 2500 USD (please see the Bill of materials for more details).

Jenny 5 is designed in OpenSCAD which is a CAD software where you write instructions, instead of using the mouse, to create objects.

The platform is driven by 2 DC motors with planetary gearbox controlled by a RoboClaw board.

The leg is driven by 2 linear motors controlled by a RoboClaw board.

Each arm has 6 stepper motors and each joint has attached a magnetic sensor for reading its position. Motors and sensors are controlled by an A-Star 32U4 Miniboard.

The gripper is powered by a servo motor. The gripper is connected to the same A-Star 32U4 Mini board as the entire arm. The gripper has attached a webcam used for recognising objects closed to it.

The head has 2 degrees of freedom ensured by 2 stepper motors which have magnetic attached for reading the position. The head has a webcam for object detection and an ultrasonic sensor for distance measurement. All head components, except the camera, are connected to an Arduino Nano board.

The entire robot is powered by 2 LiPo batteries: one for platform and foot and one for arms and head.

A-Star / Arduino boards run a specially crafted firmware called Scufy which is able to control multiple stepper motors and read a variety of sensors: buttons, ultrasonic, potentiometers, infrared, LIDAR etc.

PC software is built around several libraries which send commands, on a serial port, to A-Star/ Arduino boards and to the RoboClaw controller.

The robot can be manually controlled by an HTML5 application running within browser on a smartphone. The HTML5 application connects with a server running on the robot. The server is the one that actually execute the commands(move, read sensors) etc. The server is built on a top of a light WebSocket server.

Having all these elements, the robot can be utilised in a wide range of scenarios. Here is a short list of things that the robot could do (if programmed correctly):

  • House cleaning
  • Food preparation
  • Cleaning kitchen table
  • Working in the garden
  • Surveillance
  • Rescue
  • Disaster management
  • Fire fighting
  • ...

For more details please read the technical report about Jenny 5.

You can also subscribe to Jenny 5 Google group

  • New plan for the arm electronics

    Mihai Oltean09/05/2019 at 08:55 0 comments

    The old arm PCB was capable of controlling all 7 arm motors and read all current (6 AS5147) sensors. This was good at that moment, but now more sensors are needed.

    This is why I have split the electronics into 2 smaller electronics, each capable or controlling 3 stepper motors and reading more sensors.

    My initial plan was to place both electronics on shoulder (where the previous electronic board was placed).

    But now, I have realized that I can place one of this small electronic on shoulder and the other one on elbow. In this way the length of the cables will be significantly reduced. There are 3 stepper motors, 1 servo, 3 AS5147 and 1 current sensor on the upper arm and all these can be connected to the elbow electronic. Huge reduction on wires and complexity!

  • Right arm support has been implemented

    Mihai Oltean08/25/2019 at 06:55 0 comments

    I just finished the modifications to the HTML5 client and websocket server required in order to control the right arm. This is the first time when support for both arms has been implemented.

    Updates have been pushed to the corresponding GitHub repository.

    Testing will begin soon. What is left now is to wire all sensors to PCB.

    Here is a picture from the HTML client:

  • Future plans for Jenny 5

    Mihai Oltean08/25/2019 at 06:36 0 comments

    Jenny 5 robot is under active development. 

    During the development of the Jenny 5 robot I have observed several weaknesses that I plan to address in future iterations.

    Some short term ideas (and their purpose) are listed below:

    • Rotatable body -- Could reach farther objects without moving the base platform.
    • Springs on upper arm-body articulation -- Will lift heavier weights.
    • Two legs -- More stability and could climb stairs.
    • Intelligent algorithm for grabbing a bottle -- More intelligence.
    • Change speed for stepper motors during run -- Finer control of the arms.
    • LiDAR on platform and head -- Better detection of obstacles.
    • Visualizing the LiDAR on the client application -- Can send the robot far away and see what it sees.
    • Visualizing the camera (real time video) on the client application -- Can send the robot far away and see what it sees.
    • Arms electronics build around Arduino Mega -- Could attach more sensors to arms.
    • Custom made PCBs for leg and platform -- Can have own software and can attach more sensors to them.
    • Carbon fiber sheets -- To reduce the total weight of the robot.
    • Body movable back and forward -- To make the robot more stable on inclined plane.
    • Magnetic rotary sensors on leg -- To determine the exact position of leg.
    • Magnetic rotary sensors on platform gears -- To determine the true speed of the platform.
    • Gyroscope on platform -- To determine if the robot will fall.

  • New electronics for platform and leg

    Mihai Oltean08/22/2019 at 10:29 0 comments

    Currently the leg and the platform are powered by 2 RoboClaw boards. It is difficult to add extra sensors to this board. It is easy to add encoders, but for other sensors one has to use another microcontroller (like Arduino) to read them and then to send proper commands to RoboClaw.

    Because of that, I have decided to design a new board which uses Arduino Nano as microcontroller and Pololu VNH5019 as motor driver. There is another small advantage if using this driver: if one fails due to some short circuit, the other ones will not be affected (see few posts ago on how I lost 2 RoboClaws).

    Below is the picture of the new board with components soldered. Currently it is only 1 driver, but the second one will be added after testing.

    Note that testing will take few more weeks before they will take place because first I have to update the Scufy (Arduino ) firmware, then Scufy-Lib and so on ... so it will take some time to do that ...

  • Arm PCB

    Mihai Oltean08/20/2019 at 19:48 0 comments

    The new arm PCB has arrived and I spent this evening for soldering it.

    Below is a picture with the old (right) and new (left) PCB. 

    Testing will begin in few days. First I have to connect motors and sensors to the new PCB and then to update the software for controlling the new arm (left arm will currently be controlled by the old electronics and the right arm will be controlled by the new electronics). The HTML5 client and server should be significantly updated since they don't include any code for controlling the right arm.

  • I just burnt electronics of 250 Euros

    Mihai Oltean08/20/2019 at 16:57 0 comments

    Due to some improper connected wires to the RoboClaw boards, I have just burned 2 of them. I saw the wires "almost" touching, but it worked in the past, so I said that it should not be a problem. After connecting the battery, the capacitor of the RoboClaw board for the robot leg has made pooc-fssss ... 

    The platform electronic was connected to the same USB hub as the one for leg. I do not understand what happens, but also the USB hub and the platform board are not recognized anymore by the PC. I suspect that the short has propagated through USB and affected the USB of the other board.

    So, I decided to play safe until things are more advanced. I ordered 2 USB opto isolators which will be connected to each board before entering in the USB hub.

  • Speed and torque of the arm

    Mihai Oltean08/15/2019 at 19:03 0 comments

    The motor lifting the arm is a Nema 17 with 50:1 gearbox reduction. Theoretically they are capable of a lot of force. According to the specifications the motors (without gearbox) have torque. That multiplied with 50:1 reduction means The efficiency of gearboxes is 73%, so the useful torque is around The motor does not rotate the arm directly, but through the help of a 47:14 pulley reduction and this means that the final torque is around 6370 At a distance of 70 cm (arm length) it means a 91, which means that it can lift about 9kgs at 70cm. Note that this is a theoretical upper bound because the gearbox does not support more than before damage can occur, so the practical upper bound is below 3kg at 70 cm. Also, note that neither friction nor arm's weight were taken into account here. However the arm weight can be canceled if a spring is used. One more aspect to consider is that the torque of stepper motor decreases at high speeds, so again the practical upper bound for torque is lower than the one computed before.

    Still, in our experiments (see for instance movie) we have been able to lift more than 3.5kg at 40cm (maybe a little bit more because the smallest weight that I had was of 0.5 kg). This means a torque of at least and no gearbox damage was observed in long term.

    Another problem is that 50:1 gearboxes are difficult to back-drive. In the near future we plan to replace the 50:1 gearboxes with 27:1 ones because the maximum allowed torque before damage can occur is similar.

    Regarding the speed of the 50:1 gearbox motors we have observed and made the following computations: The maximum speed that we were able to obtain with the motor (no gearboxes attached was 1500 steps/second. After that speed the motor just stops). Knowing that the motor has 1.8 degrees steps, it means that we can about 7.5 complete rotations in 1 second. After the 50:1 gearbox we can make 0.15 of a complete rotation in 1 second. After the external 47:14 reduction we make 0.044 of a complete rotation in 1 second, that is about 16 degrees in 1 second. Thus, a complete up-down move (180 degrees) of the arm will take about 11 seconds. We are currently investigating other stepper motor drivers to see if more steps per second are possible.

  • New electronics for arm

    Mihai Oltean08/13/2019 at 07:21 0 comments

    The current arm electronics is based on Pololu A-Star 32U4 mini board. My initial plan was to use Arduino Nano, but it did not have enough pins. Also, Nano, did have very small amount of RAM (2KB). Because of that I have decided to use A-Star 32U4 mini board.

    However, as the project advances, it has become clear that A-Star Mini is not enough. My next plan was to use Arduino Mega for this purpose, but I did not like the Mega pins layout (they are placed around the board and the space inside them is too small to place all 6 stepper driver inside). So, for now, I have dropped the plans with Arduino Mega.

    The latest idea is to split the arm electronics into 2 separate electronics, each controlling 3 stepper motors. Each electronics will be powered by Arduino Nano. In this way I would have available much more pins for sensors. Also, with the new Arduino Nano Every, the RAM is increased significantly to 6 KB which would be more than enough for the current version of Scufy firmware. The only drawback is that if the boards have to communicate, they have to do that through the serial board-pc-board path.

    Yesterday I have designed the new board based on Arduino Nano and I sent it for fabrication. Below is picture of the PCB. The size of the new board is about half of the original one (the one based on the A-Star Mini). I hope to have it by the next week. After testing I will post the design to GitHub.

  • Jenny 5 robot - technical report

    Mihai Oltean08/10/2019 at 09:35 0 comments

    I wrote a technical report about this robot which includes a lot of technical details about the design and the construction of the robot.

    It can be read from Research Gate:

  • Jenny 5 GitHub repositories

    Mihai Oltean08/10/2019 at 09:33 0 comments

    Jenny 5 is open source and the entire source code is stored as a GitHub organization at:

    Individual repositories can be downloaded from the above-indicated address. The Bill of Materials (BOM) and the assembly manual are also available online. 

    The source code is released under MIT license so that anyone can use it free or paid, open-source or closed-source, private or public projects. The only request is to mention the author(s).

    Below is the list of repositories and their web addresses:

    CAD files - can be downloaded from It requires OpenSCAD to view.

    Scufy - the Arduino firmware - can be downloaded from It is used by the arm and head electronics. It requires Arduino IDE to run and upload to boards.
    Scufy Lib - Arduino control library - can be downloaded from It is used for sending commands to Arduino firmware from a PC. It is written in C++ and requires a C++ compiler.
    WebSocket server and HTML5 client -  can be downloaded from It is used to control the robot from a browser. The server is a console application running on the robot PC.
    Custom PCBs - can be downloaded from They require Fritzing to view or modify.

    The assembly manual - can be read from Note that currently this is under construction and will not be completed until the robot is completed.

    The Bill of Materials (BOM) is stored as a Google Spreadsheet at:

View all 11 project logs

Enjoy this project?



Similar Projects

Does this project spark your interest?

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