Content uploaded by Mihai Oltean
Author content
All content in this area was uploaded by Mihai Oltean on Aug 10, 2019
Content may be subject to copyright.
Jenny 5 - the robot
Mihai Oltean
Faculty of Exact Sciences and Engineering,
”1 Decembrie 1918” University of Alba Iulia,
Alba-Iulia, Romania.
mihai.oltean@gmail.com
https://jenny5.org
https://jenny5-robot.github.io
August 10, 2019
Abstract
Jenny 5 is a fully open-source robot intended to be used mainly for
research but it can act as a human assistant too. It has a mobile platform
with rubber tracks, a flexible leg, two arms with 7 degrees of freedom each
and head with 2 degrees of freedom. The robot is actuated by 20 motors
(DC, steppers and servos) and its state is read with the help of many
sensors. The robot also has 3 webcams for computer vision tasks. In this
paper the current state of the robot is described.
1
CONTENTS 2
Contents
1 Introduction 4
2 Source code 7
3 Specifications 8
4 Hardware design 9
4.1 CADsoftware............................. 9
4.2 CAD project structure . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2.1 Parameters .......................... 10
5 Hardware 11
5.1 Materials ............................... 11
5.2 Tools required to build Jenny 5 . . . . . . . . . . . . . . . . . . . 11
5.3 Mobileplatform............................ 11
5.4 Leg................................... 12
5.5 Arms.................................. 12
5.6 Gripper ................................ 15
5.7 Body.................................. 15
5.8 Head.................................. 18
6 Electronics 19
6.1 Electrical / electronic materials . . . . . . . . . . . . . . . . . . . 19
6.2 Tools.................................. 19
6.3 ArmcustomPCB .......................... 19
7 The brain 21
8 Power supply 21
9 The software controlling the robot 22
9.1 Scufy - the Arduino firmware . . . . . . . . . . . . . . . . . . . . 22
9.1.1 General commands . . . . . . . . . . . . . . . . . . . . . . 22
9.1.2 Create controllers commands . . . . . . . . . . . . . . . . 22
9.1.3 Attach sensors to motors . . . . . . . . . . . . . . . . . . 23
9.1.4 Stepper Commands . . . . . . . . . . . . . . . . . . . . . 23
9.1.5 Servo commands . . . . . . . . . . . . . . . . . . . . . . . 24
9.1.6 Read sensors commands . . . . . . . . . . . . . . . . . . . 24
9.1.7 Others............................. 25
9.2 Scufy Lib - the PC library . . . . . . . . . . . . . . . . . . . . . . 25
9.2.1 General commands . . . . . . . . . . . . . . . . . . . . . . 25
9.2.2 Events processing . . . . . . . . . . . . . . . . . . . . . . . 25
9.2.3 Create commands . . . . . . . . . . . . . . . . . . . . . . 26
9.2.4 Stepper motor movements . . . . . . . . . . . . . . . . . . 27
9.2.5 Attach sensors to motors . . . . . . . . . . . . . . . . . . 28
CONTENTS 3
9.2.6 Reading Sensors . . . . . . . . . . . . . . . . . . . . . . . 28
9.2.7 State.............................. 29
9.2.8 Scufy Lib events . . . . . . . . . . . . . . . . . . . . . . . 29
9.2.9 Example of utilization . . . . . . . . . . . . . . . . . . . . 29
9.3 RoboClaw control library . . . . . . . . . . . . . . . . . . . . . . 31
9.4 HTML 5 client and PC WebSocket server . . . . . . . . . . . . . 33
9.5 Intelligent algorithms . . . . . . . . . . . . . . . . . . . . . . . . . 33
10 Weaknesses and future development 36
1 INTRODUCTION 4
1 Introduction
Jenny 5 represents an attempt to build a low-cost, almost humanoid robot, by
using tools and materials which are readily available.
Jenny 5 is inspired by the Johnny 5 robot from the Short circuit movie [6].
Work to Jenny 5 robot was started in April 2015. Until now 3 major versions
have been built and tested. At each iteration the robustness of the robot has
been significantly improved.
Jenny 5 (v3) has a mobile platform with tracks, a pliable leg, two arms with
7 degrees of freedom each and one head. The current design of the Jenny 5 is
given in Figure 1. A real world image is given in Figure 2.
All source files (CAD, software etc) for Jenny 5 are freely available on GitHub
[2, 1]. All code is released under MIT license so that anyone can freely use it in
both personal and commercial applications.
Several programming languages have been used for developing Jenny 5 hard-
ware and software. These are: C++ (for server and the Arduino firmware),
HTML5 and JavaScript (for the client controlling the server) and OpenSCAD
(for the hardware design).
Jenny 5 is easy and cheap to build. Most components can be purchased
from robotics stores. Some aluminum profiles can be cut and drilled with tools
available for hobbyists. Custom made parts can be printed with a 3D printer.
Materials (excepting the onboard computer) cost less than 2500 USD.
The robot can be utilized in a wide range of scenarios. Here is a short list of
things that the robot could do (if programmed properly): surveillance, rescue,
disasters management, house cleaning, food preparation, cleaning kitchen table,
working in the garden, fire fighting, combat missions etc.
The Jenny 5 robot is continuously developed and updated. This paper de-
scribes the current state of the robot (also called v3).
The document is structured as follows:
Section 2 contains the locations where the source code of the robot is stored.
Section 3 contains a list of technical specifications for Jenny 5.
Section 4 introduces OpenSCAD which is the software used to design the
robot. Later the CAD project structure is given.
Section 5 describes the main components of the robot (mobile platform, leg,
arms, body and head). A short list of materials and necessary tools is given in
sections 5.1 and 5.2.
Section 6 describes the electronic boards used for reading sensors and for
moving motors.
Section 7 gives the specifications of the computer controling the robot.
Batteries utilized in this project are listed in section 8.
Section 9 describes the software that controls the robot (Scufy - the Arduino
firmware, Scufy Lib - Arduino PC control library and the HTML 5 and Web-
Socket server). Several intelligent algorithms used by Jenny 5 are described in
section 9.5.
Section 10 contains a short description of some future development direc-
tions.
1 INTRODUCTION 5
Figure 1: Jenny 5 robot. Design view
1 INTRODUCTION 6
Figure 2: Jenny 5 robot. Real world view of the current iteration (v3).
2 SOURCE CODE 7
2 Source code
Jenny 5 is open source and the entire source code is stored as a GitHub orga-
nization at: https://github.com/jenny5-robot/. 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 [23] 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 https://github.com/jenny5-robot/
jenny5-cad. It requires OpenSCAD [7] to view.
•Scufy - the Arduino firmware - can be downloaded from https://github.
com/jenny5-robot/Scufy. It is used by the arm and head electronics. It
requires Arduino IDE [8] to run and upload to boards.
•Scufy Lib - Arduino control library - can be downloaded from https:
//github.com/jenny5-robot/jenny5-control-module. 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 https:
//github.com/jenny5-robot/jenny5-html5. 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 https://github.com/jenny5-robot/
jenny5-electronics. They require Fritzing [20] to view or modify.
•the assembly manual - can be read from https://jenny5.org/manual/.
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: https:
//docs.google.com/spreadsheets/d/1SwaC4woJEvUEqn66lIG9MLYkuADfTsWIQtvDKaCQT1s/
edit?usp=sharing.
3 SPECIFICATIONS 8
3 Specifications
Technical specifications are given in Table 1. Please note that some specifica-
tions are not computed, but based on my experience with the robot.
Parameter Value
Total Weight 40kg
Width 80cm (from left arm extremity to
right arm extremity)
Total height 1.8m (from ground to head tip)
Leg height 35cm (fully compressed) to 95cm
(fully extended)
Arm length (from shoulder con-
nection to gripper center)
70 cm
Arm weight lift <1kg (when fully extended).
Can more if a spring is used. See
section 5.5 for a discussion.
Arm (time for a up-down move) 11 seconds. See section 5.5 for a
discussion.
Speed <3km/h. Can run faster if a mo-
tor with a lower gear reduction is
used.
Leg (time to compress/extend) 7 seconds.
Autonomy Several hours (depends on the
capacity of the batteries).
Table 1: Technical specifications of the current iteration of Jenny 5. Please note
that some specifications can be improved when using better components.
4 HARDWARE DESIGN 9
4 Hardware design
This section describes the software used to design Jenny 5 and the structure of
the CAD project.
4.1 CAD software
Jenny 5 is designed in OpenSCAD [7]. I have chosen this environment because
it is mainly intended for programmers and I (the author) am a programmer.
Parts in OpenSCAD are designed using computer instructions instead of
using the mouse.
OpenSCAD IDE is very simple: one writes instructions in the left window,
and the result (after pressing F5 ) are seen in the top-right window. In the
bottom-right window the programmer can display various information by using
echo instruction.
The language offers several primitives (cube,cylinder,sphere etc), several
Boolean operations (union,difference,intersection) and several transforma-
tions (translate,rotate,mirror, etc). By using only these primitives and
operations is possible to create very complex geometries.
The programmer can write everything in the main file, but usually the in-
structions creating a part are grouped within a module.
For instance a simple program which creates a nut is the following:
module nu t ( e x t e r n a l r a d i u s , i n t e r n a l r a d i u s , t h i c k n e s s )
{
difference ( ) {
cylinder( h = t h i c k ne s s , r = e x t e r n a l r a d i u s , $fn
= 6) ;
cylinder( h = t h i ck n e s s , r = i n t e r n a l r a d i u s , $fn
= 50 ) ;
}
}
// now c all th e modu l e
nu t ( e x t e r n a l r a d i u s = 4 , i n t e r n a l r a d i u s = 2 , t h i c k n e s s =
3 . 2 ) ;
For visualizing a part the user should press F5 (Preview) or F6 (Render ).
One can use the mouse to navigate through the designed part. Left button
drag is used for rotate, right button drag for move and mouse wheel for zoom.
Note that for visualizing the entire robot we will use Preview mode only
because Render is too slow (can take several hours to render the entire robot).
However, when we need the stl file for 3D printing, we will use Render mode
for that particular part.
The user can uncomment each module of the project to show it on screen.
4 HARDWARE DESIGN 10
4.2 CAD project structure
CAD files for the robot can be downloaded from https://github.com/jenny5-robot/
jenny5-cad.
There are 2 main folders there: basic scad and robot.
•basic scad - contains general components like screws, nuts, motors, sen-
sors, pulleys, gears, bearings, etc. These components can be used in other
projects too.
•robot - contains components specific to Jenny 5 robot. Each part of the
robot has its own folder. Main file is called jenny5.scad. To view it just
open it in OpenSCAD and press F5.
The robot folder contains 5 subfolders:
•arm. The main file is arm.scad.
•base platform. The main file is base platform.scad
•body. The main file is body.scad. Please note that arms are connected to
body only in the main file of the project (jenny5.scad ).
•head. The main file is head.scad.
•leg. The main file is leg.scad.
4.2.1 Parameters
The current position of the leg and arms is stored as numerical values (angles).
These parameters are stored in the following files:
•robot/arm/arm params.scad - here we have the angles for arms.
•robot/leg/leg params.scad - here we have the angle for leg.
One can modify these parameters in order to simulate a new position for leg
or arms.
One can change the color of the plastic parts from file basic scad/material colors.scad.
5 HARDWARE 11
5 Hardware
This section describes the most important mechanical components of the robot
which are the mobile platform (see section 5.3), the leg (see section 5.4), two
arms (see section 5.5), a body (see section 5.7) and a head (see section 5.8).
5.1 Materials
In Table 2 the materials needed for the mechanical parts are listed. Please
note that electrical / electronic components (including sensors, cameras, micro-
controllers, etc) are not listed here, but the motors are. The quantities are
not always exact. For more details the user is encouraged to read the online
assembly manual from [1].
Material Quantity
M3, M4, M8, M12 screws Many (of various lengths)
M3, M4, M6, M8, M12 nuts Many
Washers Many
Aluminum rectangular tube Several meters (various sizes)
Aluminum sheets Many of various sizes and thick-
nesses(3mm, 5mm and 10mm)
Carbon fire tube Several meters
PLA (for 3D printers) About 2 kgs
Rubber tracks 2
Radial bearings Many (of various types)
Linear motors (for leg) 2
DC motor(for platform)s 2
Stepper motors with planetary
gearbox
12 (Nema 17 - for arms) + 2
(Nema 11 - for head)
Servo motors (for grippers) 2
Table 2: A short list of materials needed for building Jenny 5. Some lengths
and quantities are approximate. Details are given in the assembly manual.
5.2 Tools required to build Jenny 5
Tools required to build Jenny 5 are given in Table 3.
5.3 Mobile platform
The platform is driven by 2 DC motors with planetary gearbox controlled by a
15 Amps RoboClaw board [14].
The platform has two rubber tracks.
Several components of the robot are placed on platform: batteries, motor
controllers etc.
5 HARDWARE 12
Tool Use Comment
Digital
caliper
For measuring vari-
ous sizes
A 150mm and a 300mm caliper are re-
quired.
Mitre Saw Cutting aluminum
profiles
I have a Bosch GCM 10 MX, but any
other models should work. Make sure
that it has a blade which cuts alu-
minum!
Column
drilling
machine
Drilling aluminum,
wood parts
I have a Optimum B16 model, but any
other models should work.
Hole saw Cutting holes in
aluminum profiles
15-44 mm diameter. I have a Bosch
Progressor with changing heads.
Screw
drivers
screwing... Various sizes and types (slot, Philips,
hex, hex socket) are needed.
Drill bits for
metal
Making various
holes in aluminum
2.5 mm, 3.3 mm, 3.9 mm, 6 mm, 8 mm,
12mm diameter.
Wrenches for tightening
screws
Various sizes are needed (mostly for
M3, M4, M6, M8 and M12 nuts).
Table 3: Tools to make the mechanical part of Jenny 5.
The platform is depicted in Figure 3.
Currently, the platform is quite small and the robot can become unstable
(can fall) if abruptly moved when the leg is fully extended. However, if the leg is
compressed, the robot is much more stable. So, the idea is to make only moves
with low acceleration when the leg is extended. In the near future we plan to
add the possibility to move the body back and forth so that we can control the
center of gravity easily.
5.4 Leg
The leg is driven by two, 750N, linear motors with 100mm stroke, controlled by
a 5 Amps RoboClaw board. Note that the motors were disassembled in order
to increase the useful stroke.
In Figure 4 we have a picture with the lateral and frontal leg design view.
The leg can be compressed so that arms can grab things from ground.
5.5 Arms
Each arm has 6 stepper motors with various gearbox reductions (27:1 and 50:1).
Joint position is read using a magnetic rotation sensor (AS 5147 [16]). Motors
and sensors are controlled with a Pololu A-Star board [10].
The 50:1 motors are used for lifting the entire arm and for moving the elbow.
Theoretically they are capable of a lot of force. According to the specifications
[24] the motors (without gearbox) have 52N.cm torque. That multiplied with
5 HARDWARE 13
Figure 3: Jenny 5 platform with rubber tracks
5 HARDWARE 14
Figure 4: Jenny 5 leg. Lateral and frontal view.
5 HARDWARE 15
50:1 reduction means 2600N.cm. The efficiency of gearboxes is 73%, so the
useful torque is around 1900N.cm. 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 N.cm. At a distance of 70 cm (arm length) it means
a 91 N.cm, 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
600N.cm before damage can occur [24], 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 [25], so again the practical upper bound for torque is lower than the one
computed before.
Still, in our experiments (see for instance movie at https://www.youtube.
com/watch?v=Rc-ppA9-12I we have been able to lift more than 3.5kg at 40cm.
This means a torque of at least 1400N.cm 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.
Each arm is controlled independently. The electronic boards are placed on
each arm separately.
The arm is depicted in Figure 5.
5.6 Gripper
Each arm has attached a gripper which is moved by a servo motor. The gripper
is connected to the same board as the rest of the arm. The gripper has attached
a web-cam used for recognizing the objects in the front of it.
The gripper is depicted in Figure 6.
5.7 Body
The body is a carbon-fiber frame which has support for 2 arms and connectors
for leg (at the bottom) and head (at the top).
Body is depicted in Figure 7.
5 HARDWARE 16
Figure 5: Jenny 5 arm.
Figure 6: Jenny 5 gripper.
5 HARDWARE 17
Figure 7: Jenny 5 body.
5 HARDWARE 18
5.8 Head
The head has 2 degrees of freedom ensured by two Nema 11 stepper motors.
Position of the motors is read by 2 AS5147 sensors.
The head has a web-cam for object detection and an ultrasonic sensor for
distance measurement.
All head components, except the camera, are connected to an Arduino Nano
board.
6 ELECTRONICS 19
6 Electronics
This section describes the electronics components utilized by Jenny 5. First we
list the materials and tools required to build the electrical part of the robot.
The we describe the custom PCBs build for arms and head.
6.1 Electrical / electronic materials
A list of materials is given in Table 4. Note that motors were listed in Table 2
(see the hardware section 5).
Component QuantityComment
Arduino Nano 1 for head
RoboClaw 7Amps 1 Controls the leg motors
RoboClaw 15Amps 1 Controls the base platform motors
Pololu A-Star mini 2 Controls the arms. We have chosen this
board instead of Arduino Nano because A-
Star has more pins.
Custom PCBs 4 For arms and head. More custom PCBs for
platform and legs are under development.
Pololu A4988 step-
per driver
15 for driving motors on arms and head.
AS5147 rotary en-
coder [16]
14 for reading the position of each arm and
head articulation
Logitech C920 web-
cam
3 for video capture. It is place on head and
arms (for detecting the grabbed objects).
HC-SR04 ultra-
sonic
1 for raw obstacles detection
wires Many AWG 18 (for leg and platform), AWG 22
(for motors and sensors on arms and head).
resistors Several
capacitors Many
connectors Many
Table 4: Electrical materials required to build Jenny 5.
This section describes the electronic used to control the robot.
6.2 Tools
Tools requires to build the electrical parts for robot are given in Table 5.
6.3 Arm custom PCB
The PCB for arm is depicted in Figure 8. The electronics was designed using
Fritzing [20].
6 ELECTRONICS 20
Figure 8: Jenny 5 arm electronics. Design view (top) and actual implementation
(bottom).
7 THE BRAIN 21
Tool Use Comment
Digital multime-
ter
for measuring currents and voltages
Soldering iron for soldering electrical components A 20-30W iron is
OK.
Table 5: Tools required to build the electronics / electrical part of Jenny 5
7 The brain
The brain of the robot is a 13” laptop, with i7-6700 processor, 128GB SSD, and
4GB RAM and is placed on the platform. The laptop has 3 USB-A ports (more
ports is better, otherwise some USB-hubs are needed).
The laptop sends commands to A-star, Arduino and RoboClaw boards and
read images from webcams.
Obviously, any other laptop can be utilized, preferably small and powerful.
A low-cost computer like Raspberry Pi [21] can be used too if the robot is not
doing any high costs tasks like computer vision.
8 Power supply
The Jenny 5 robot is powered by multiple Li-Po rechargeable batteries. Cur-
rently a 16 Ah battery powers both arms and the head and a 10 Ah battery
powers the platform and the leg. The laptop is powered by its own battery.
9 THE SOFTWARE CONTROLLING THE ROBOT 22
9 The software controlling the robot
The robot components are controlled by various programs. Arms and head run
the Scufy - the Arduino firmware which accepts commands sent from PC with
the help of Scufy Lib. The RoboClaw boards run a proprietary firmware and
accepts commands sent by a C++ library running on a PC.
9.1 Scufy - the Arduino firmware
A-star and Arduino boards run a specially crafted firmware called Scufy (see
the source code in reference [3]) which is able to control multiple motors and
read a variety of sensors: buttons, AS5147 magnetic rotary encoders, HC-SR04
ultrasonic, potentiometers, infrared, TeraRanger One etc.
The firmware is asynchronous and does not block the board when performing
long running operations (such as moving a motor to a new position (which can
take sometimes several seconds) or reading an ultrasonic sensor).
Scufy firmware accepts commands sent through the serial port.
All commands are terminated by # character.
Almost all commands send a response to the serial port. The response is
terminated by # character.
Commands related to motors and sensors required an object (controller) to
be created internally for each type of motor or sensor. This controller stores how
many sensors of that type we have and more information about the Arduino
pins where that motor/sensor is connected. etc. So, before moving motors or
reading sensors the user must create a controller for them. The motors / sensors
inside a controller are indexed from 0.
The list of most important Scufy commands is given below. The user should
read the entire / updated list of commands from the source code of the program.
9.1.1 General commands
•T# - Test connection. - Outputs T#.
•V# - Outputs version string (year.month.day.build number). eg: V2019.05.10.0#.
9.1.2 Create controllers commands
•CS n dir0step0en0dir1step1en1... dirn−1stepn−1enn−1#
Creates the stepper motors controller and set some of its parameters.
nis the number of motors, dirk,stepk,enkare the Arduino pins which
command the direction, step and the enable state.
Outputs CS # when done.
Example: CS 3 5 4 12 7 6 12 9 8 12#
•CV n pin0pin1... pinn−1#
Creates the servo motors controller and set its pins.
9 THE SOFTWARE CONTROLLING THE ROBOT 23
nis the number of motors, pinkare Arduino pins where the motors are
connected.
Outputs CV # when done.
•CA n pin0pin1... pn−1#
Creates the AS5147 controller.
nis the number of sensors, pkare Arduino pins where the sensors are
connected.
Outputs CA# when done.
Example: CA 3 18 19 20#
9.1.3 Attach sensors to motors
•ASx n Pyend1end2home direction Akend1end2home direction#
Attach, to stepper motor x, a list of n sensors (like Potentiometer y, Button
z, AS5147 etc).
yis the sensor index in the list of sensors of that type.
end1and end2specify the sensor angular position guarding the motor
movement.
home specifies the home position of the motor.
direction specifies if the increasing values for motor will also increase the
values of the sensor.
Outputs ASx# when done.
Example: AS0 1 A0 280 320 300 1#
9.1.4 Stepper Commands
•SM x y#
Moves stepper motor xwith ysteps. If yis negative the motor runs in the
opposite direction. The motor remains locked at the end of the movement.
The first motor has index 0.
Outputs SM x d# when motor rotation is over. If the movement was
complete, then dis 0, otherwise is the distance to go.
Example: SM 1 100#
•SH x#
Moves stepper motor xto the home position.
The first sensor in the list of sensors will establish the home position. The
motor does nothing if no sensor is attached.
Outputs SH x# when done.
9 THE SOFTWARE CONTROLLING THE ROBOT 24
•SDx#
Disables stepper motor x.
Outputs SDx# when done.
•SLx#
Locks stepper motor xin the current position.
Outputs SLx# when done.
•SSx speed acceleration#
Sets the speed of stepper motor xto speed and the acceleration to acceleration.
Outputs SSx# when done.
•ST x#
Stops motor x.
Outputs ST x# when done.
•SGx position#
Moves stepper motor xto position sensor position. The first sensor in list
will give the position.
Outputs SM x d# when motor rotation is over. If the movement was
complete, then dis 0, otherwise is the distance left to go.
Example: SG1 100#
9.1.5 Servo commands
•V Mx position#
Moves servo motor xto position.
Outputs V Mx d# when done. If the move is completed dis 0, otherwise
dis 1.
•V Hx#
Moves servo motor xto the home position. Home position is given by the
first sensor in the list of attached sensors. Outputs V Hx#.
9.1.6 Read sensors commands
•RAx#
Read the value of AS5147 sensor.
Outputs RAx angle#.
9 THE SOFTWARE CONTROLLING THE ROBOT 25
9.1.7 Others
•E#
The firmware can output this string if there is something wrong with a
given command.
•Iinformation#
The firmware can output this string containing useful information about
the progress of a command.
9.2 Scufy Lib - the PC library
Scufy Lib [4] is a C++ library that sends commands (as strings) and reads results
to / from the electronic boards powering the arms, head etc. Communication
between on board computers and the electronic boards happens on a serial port.
The following methods are a part of the Scufy Lib. The user should read the
entire list of commands from the source code of the library.
9.2.1 General commands
// c o n n e c ts t o g i v e n s e r i a l p o r t
bool c on n ec t ( cons t char∗port , i n t ba ud ra te ) ;
// t e s t i f t h e c o nn e ct io n i s op en ; F or t e s t i n g i f t he
Ard ui no i s a l i v e p l ea s e s e n d i s a l i v e me th od a nd w a it
f o r IS ALIVE EVENT e v e n t
bool is open(void ) ;
// c l o s e s e r i a l c o nn e c ti o n
void close connection(void ) ;
// s en d s ( t o A rd ui no ) a command (T#) f o r t e s t i n g i f t h e
c on n ec t io n i s a l i v e
// when t he A rduino w i l l r es po nd , t h e e v en t w i l l b e ad de d
in t he l i s t
void s e n d i s a l i v e ( void) ;
9.2.2 Events processing
// r ea d s d at a from s e r i a l an d u p da t es t h e l i s t of
r e c e i v e d e v e n t s f ro m A rd ui no
// t h i s s h ou l d b e c a l l e d f r e q u e n t l y f rom t h e ma in l o op o f
t h e p ro gr am i n o r d er t o r e ad t h e d a ta r e c e i v e d f ro m
Arduino
9 THE SOFTWARE CONTROLLING THE ROBOT 26
bool update commands from serial(void) ;
// s e a r c h i n t h e l i s t o f e v e n t s f o r a p a r t i c u l a r e v e nt
ty pe
// i t r e t u r n s t r u e i f t h e e v e n t i s f o un d i n l i s t
// t he f i r s t o ccu rr enc e o f th e e ve nt i s r emov ed fr om t he
l i s t
bool query for event(in t e ve nt ty p e ) ;
// s e a r c h i n t h e l i s t o f e v e n t s f o r a p a r t i c u l a r e v e nt
ty pe
// i t r e t u r n s t r u e i f t h e e v e n t i s f o un d i n l i s t
// pa ram1 par am et er w i l l b e s e t t o t he in fo rm a ti o n fr om
t h e pa ra m1 mem ber o f t h e e v e n t
bool query for event(in t e ve nt ty p e , i nt ∗p aram 1 ) ;
// s e a r c h i n t h e l i s t o f e v e n t s f o r a p a r t i c u l a r e v e nt
ty pe
// i t r e t u r n s t r u e i f t h e e v e n t i s f o un d i n l i s t
// pa ram1 par am et er w i l l b e s e t t o t he in fo rm a ti o n fr om
t h e pa ra m1 mem ber o f t h e e v e n t
// pa ram2 par am et er w i l l b e s e t t o t he in fo rm a ti o n fr om
t h e pa ra m2 mem ber o f t h e e v e n t
bool query for event(in t e ve nt ty p e , int ∗param1 ,
intptr t ∗pa ram 2 ) ;
// s e a r c h i n t h e l i s t o f e v e n t s f o r a p a r t i c u l a r e v e nt
ty pe
// r e t u r n s t r u e i f t h e e v e n t t y p e m a tc h es a nd i f t h e
pa ram 1 memb er i s e q u a l t o t h e p ar a m et e r g i v e n t o t h i s
function
bool query for event(in t e ve nt ty p e , int pa ram 1 ) ;
9.2.3 Create commands
// s e nd s ( t o A rd ui no ) a command f o r c r e a t i n g a s t e p p e r
mo to r c o n t r o l l e r
// s e v e r a l a r r ay s o f p i n i n d e x e s f o r d i r e c t i o n , s t e p a nd
e na b le mus t b e s p e c i f i e d
// t h i s me th o d s h o u l d b e c a l l e d o nc e a t t h e b e g i n n i n g o f
th e prog ram
// c a l l i n g i t m u l t i p l e t i m e s i s a l l o we d , b u t t h i s w i l l
on l y f r ag m en t t he Ar d u i no memory
void send create stepper motors(int num motors , i nt ∗
dir pins , i n t ∗step pins , i n t ∗enable pins ) ;
9 THE SOFTWARE CONTROLLING THE ROBOT 27
// s e nd s a command f o r c r e a t i n g a AS 51 47s c o n t r o l l e r
// t h i s me th o d s h o u l d b e c a l l e d o nc e a t t h e b e g i n n i n g o f
th e prog ram
// c a l l i n g i t m u l t i p l e t i m e s i s a l l o we d , b u t t h i s w i l l
on l y f r ag m en t t he Ar d u i no memory
void s e n d c r e a t e a s 5 1 4 7 s ( in t num as5147s , i n t ∗ou t p i n s ) ;
// s e nd s a command f o r c r e a t i n g a Te ra R an ger One
c o n t r o l l e r
// t h i s m eth od s ho u l d b e c a l l e d o nc e
// o n l y o ne s e n s o r i s p e r m i t t e d p e r A rd u in o b o ar d
void s e n d c r e a t e t e r a r a n g e r o n e ( void) ;
9.2.4 Stepper motor movements
// s e nd s ( t o A rd ui n o ) a command f o r mo vi ng a s t e p p e r
mo to r t o home p o s i t i o n
void se nd go ho m e s te pp er mo to r ( i nt m ot or in de x ) ;
// s e n ds a command f o r m ov in g a m ot or w i t h a g i v e n nu mb er
o f s t e p s
void se nd mo ve ste pp er mo to r ( int motor index , i n t
num s tep s ) ;
// s e nd s a command f o r m ov in g t wo m ot or s
void send move stepper motor2(i n t m ot o r inde x 1 , int
num steps1 , i n t m ot o r i n de x 2 , int n um s tep s2 ) ;
// s e nd s a command f o r m ov in g t h r e e m o to rs
void send move stepper motor3(i n t m ot o r inde x 1 , int
num steps1 , i n t m ot o r i n de x 2 , int num steps2 , i nt
mot o r in de x 3 , in t n um s te ps3 ) ;
// s e n ds a command f o r m ov in g f o u r m o to r s
void send move stepper motor4(i n t m ot o r inde x 1 , int
num steps1 , i n t m ot o r i n de x 2 , int num steps2 , i nt
mot o r in de x 3 , in t num steps3 , int m o t o r i nd e x 4 , i nt
num s te ps4 ) ;
// s en d s a command f o r mo vi ng m u l t i p l e m o to rs
void send move stepper motor array(i n t num motors , i nt ∗
motor index , i n t ∗num s te ps ) ;
// s e nd s a command f o r s t o p p i n g a s t e p p e r m ot or
9 THE SOFTWARE CONTROLLING THE ROBOT 28
void send stop stepper motor(in t m ot or ind e x ) ;
// s e nd s a command f o r m ov in g a mo to r t o a new s e n s o r
position
void send stepper motor goto sensor position(int
motor index , i n t sensor position) ;
// s en d s a command f o r b l o c k i n g a m oto r t o c u r r en t
position
void send lock stepper motor(in t m ot or in de x ) ;
// s en d s a command f o r d i s a b l i n g a m ot or
void send disable stepper motor(in t m ot or in de x ) ;
// s en d s a command f o r s e t t i n g t he s pe e d an d a c c e l e r a t i o n
o f a g i v e n m ot or
void s e n d s e t s t e p p e r m o t o r s p e e d a n d a c c e l e r a t i o n ( i n t
motor index , i n t motor speed , i nt motor acceleration ) ;
9.2.5 Attach sensors to motors
// s en d s ( t o A rd ui no ) a command f o r a t t a c h i n g s e v e r a l
s e n s o r s t o a g i v e n m ot or
void send attach sensors to stepper motor(int motor index
,
int n u m pote n t io m et e r s , i nt ∗potentiometers index ,
i nt ∗l o w , i nt ∗h i gh , int ∗home , i n t ∗direction
,
int num AS5147s , i nt ∗AS5147 index ,
i nt ∗AS5147 low , i n t ∗AS5147 high , i nt ∗
AS5147 home , i n t ∗AS 51 47 d i re ct ion ,
int num infrared , int ∗infrared index ,
int num but t o ns , i nt ∗buttons index , in t ∗
button direction
) ;
// s e nd s a command f o r r e a d i n g r e mo v i ng a l l a t t a c h e d
s e n s o r s o f a m ot or
void send remove attached sensors from stepper motor(in t
mo t or ind e x ) ;
9.2.6 Reading Sensors
// s e nd s ( t o A rd ui no ) a command f o r r e a d i n g a AS 5147
position
9 THE SOFTWARE CONTROLLING THE ROBOT 29
void send get AS5147 position(i n t s e n s o r i n d e x ) ;
9.2.7 State
// r e t u r n s t h e s t a t e o f a mo to r
int get stepper motor state (i n t m ot or ind ex ) ;
// s e t s t h e s t a t e o f a m ot or
void s e t s t e p p e r m o t o r s t a t e ( i n t motor index , int
ne w s t at e ) ;
9.2.8 Scufy Lib events
Strings received from Scufy firmware are translated by update commands from serial()
to events which are stored into a queue. Each event has a particular type. A
short list of event types is given in Table 6. For more events the user is encour-
aged to read the scufy events.h file from the Scufy Lib repository.
Event Meaning
IS ALIVE EVENT Received if the Scufy firmware responded to a
T# command
STEPPER MOTORS
CON-
TROLLER CREATED EVENT
Received after the stepper motor controller
has been created.
ATTACH SENSORS
EVENT
Received after sensors have been attached to
motors
AS5147 READ EVENT Received after the sensor has been successfully
read.
STEPPER MOTOR MOVE
DONE EVENT
Received after the motor has finished the re-
quested move.
Table 6: Some of the events of Scufy Lib.
9.2.9 Example of utilization
In this section we give some example of utilization for the Scufy Lib.
After sending a command to Arduino firmware, the PC program should wait
for an answer in an asynchronous way. Since the answer is not instantaneous
the programmer should create a loop where it waits for an answer. The basic
idea is the following:
•send a command,
•use update commands from serial() to extract strings sent by firmware,
•use query for event() to determine if a particular event has been received.
9 THE SOFTWARE CONTROLLING THE ROBOT 30
Below is an example of code which creates a stepper controller. This code
is actually used by the server to create a controller for the left arm of the robot
[4].
bool t l e f t a r m c o n t r o l l e r : :
create stepper motors controller(char ∗error string)
{
int left arm motors dir pins [6] = {5 , 7 , 9 , 1 1 ,
3 , 1 };
int left arm motors step pins [6] = {4 , 6 , 8 , 10 ,
2 , 0 };
int l e f t a r m m o t o r s e n a b l e p i n s [ 6 ] = {12 , 1 2 ,
12 , 12 , 12 , 1 2 };
a r d u i n o c o n t r o l l e r . s e n d c r e a t e s t e p p e r m o t o r s ( 6 ,
left arm motors dir pins ,
l e f t a r m m o t o r s s t e p p i n s ,
l e f t a r m m o t o r s e n a b l e p i n s ) ;
bool motors controller created = f a l s e ;
c l o c k t s t a r t t i m e = c l o c k ( ) ;
while ( 1 ) {
i f (! arduino controller .
update commands from serial () )
S l e e p ( 5 ) ; // no new d at a from
s er i a l . . . we make a l i t t l e
p au s e s o t h a t we d on ’ t k i l l
t h e p r o c e s s o r
i f ( a r d u i n o c o n t r o l l e r . q u e r y f o r e v e n t (
STEPPER MOTORS CONTROLLER CREATED EVENT
, 0 ) ) {/ / h a ve w e r e c e i v e d t h e e v e n t
fr om S e r i a l ?
motors controller created = true ;
break ;
}
// m easure t he p a ss ed t i me
c l o c k t e n d t im e = c l oc k ( ) ;
double w a i t t i m e = ( d oubl e ) ( en d ti m e −
s t a r t t i m e ) / CLOCKS PER SEC ;
// i f more t ha n 3 s ec ond s t he n game o ver
i f ( w ai t t im e >
NUM SECONDS TO WAIT FOR CONNECTION) {
i f (! motors controller created )
s p r i n t f ( e r r o r s t r i n g , ”
9 THE SOFTWARE CONTROLLING THE ROBOT 31
Ca nno t c r e a t e l e f t ar m
’ s m ot or s c o n t r o l l e r !
Game o v er ! \n ” ) ;
re tu rn f a l s e ;
}
}
retur n tru e ;
}
//
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
9.3 RoboClaw control library
RoboClaw library [5] is C++ library which send commands, on a serial port, to
the RoboClaw board.
Currently the platform and the leg are controlled by RoboClaw boards.
The following functions are included in library:
// r e t u r n s t h e l i b r a r y v e r s i o n
// t h e c a l l e r m ust n ot d e l e t e t h e p o i n t e r
co nst char ∗g e t l i b r a r y v e r s i o n ( void ) ;
bool c on n ec t ( cons t char∗port , i n t ba ud r a te ) ;
void close connection(void ) ;
bool is open(void ) ;
// Re ad t h e b o ar d t e m p e r at u r e . / / Va l ue r e t u r n e d
i s i n 10 t h s o f d e g r e e s .
double get board temperature (void) ;
// Re ad t h e mai n b a t t e r y v o l t a g e l e v e l c o nn e c te d
to B+ and B−terminals
double g e t m a i n b a t t e r y v o l t a g e ( void ) ;
// Re ad R obo Cla w f ir m w ar e v e r s i o n .
// R et u rn s up t o 48 b y t e s
// ( d e p e n d in g o n t h e R obo Cl aw mo d el ) an d
// i s t e r m i n a te d b y a l i n e f e e d c h a r a c t e r a nd a
n u l l c h a r a c t e r .
void g e t firmware version(char ∗firmware version)
;
// Dri v e mot or 1 f o rw a rd .
// V a li d d a ta r an ge i s 0 −127.
// A v a l u e o f 1 27 = f u l l s p ee d f o rw a rd ,
9 THE SOFTWARE CONTROLLING THE ROBOT 32
// 6 4 = a b ou t h a l f s pe e d f or w ar d and 0 = f u l l
s t o p .
bool drive forward M1(unsigned char speed ) ;
// Dri v e mot or 2 f o rw a rd .
// V al i d d a ta r an g e i s 0 −127.
// A v a l u e o f 1 27 = f u l l s p ee d f o rw a rd ,
// 6 4 = a b ou t h a l f s pe e d f or w ar d and 0 = f u l l
s t o p .
bool drive forward M2(unsigned char speed ) ;
bool drive backward M1(unsigned char speed ) ;
bool drive backward M2(unsigned char speed ) ;
// Re ad t h e c u r r e n t dr aw f ro m e a ch mo to r i n 1 0ma
increments .
// The amp s v a l u e i s c a l c u l a t e d b y d i v i d i n g
t h e v a l u e b y 1 0 0 .
void get motors current consumption(double &
cu r ren t m o to r 1 , double &c u r r e n t m o t o r 2 ) ;
// Re ad t h e c u r r e n t PWM o u t p u t v a l u e s f o r t h e
mo tor ch a nne l s .
// The v a l u e s r e t u r n ed a r e + −32767.
// The d u ty c y c l e p e r ce n t i s c a l c u l a t e d b y
d i v i d i n g t h e v a l u e b y 3 2 7 . 6 7 .
void rea d moto r PWM ( double &pwm motor 1 , double &
pw m moto r 2 ) ;
// The d u t y v a l u e i s s i g n e d a nd t h e r a n ge i s :
// −3 2768 t o + 32 76 7( e g . + −100 % du ty ) .
// The a c c e l e r a t i o n v a lu e r a ng e i s 0 t o 6 5 53 59
// ( e g . maximum a c c e l e r a t i o n r a t e i s −100 % t o
10 0 % i n 100ms ) .
bool drive M1 with signed duty and acceleration (
i n t 1 6 t du ty , u i n t 32 t a c c e l e r a t i o n ) ;
// The d u t y v a l u e i s s i g n e d a nd t h e r a n ge i s :
// −3 2768 t o + 3 2767 ( e g . + −100 % du ty ) .
// The a c c e l e r a t i o n v a lu e r a ng e i s 0 t o 6 5 53 59
// ( e g . maximum a c c e l e r a t i o n r a t e i s −100 % t o
10 0 % i n 100ms ) .
bool drive M2 with signed duty and acceleration (
i n t 1 6 t du ty , u i n t 32 t a c c e l e r a t i o n ) ;
// Se t Motor 1 Maximum Cu r r e nt Li m i t .
// C u rr e nt v a l u e i s i n 1 0ma u n i t s .
// To c a l c u l a t e m u l t i pl y c ur r en t l i m i t b y 1 00 .
9 THE SOFTWARE CONTROLLING THE ROBOT 33
bool set M1 max current limit(double c max ) ;
// Se t Motor 1 Maximum Cu r r e nt Li m i t .
// C ur r en t v a l u e i s i n 1 0ma u n i t s .
// To c a l c u l a t e m u l t i pl y c ur r en t l i m i t b y 1 00 .
bool set M2 max current limit(double c max ) ;
9.4 HTML 5 client and PC WebSocket server
The robot can be manually controlled by an HTML5 application running within
the browser of a smartphone. The HTML5 application connects to the server
running on the robot. The server is the one that actually execute the commands
(move motors, read sensors) etc.
The server is built on a top of a light WebSocket server (single source file)
written by Eduard S
,uic˘a [17]. The server uses TLSe library [18] for the secured
communication protocol.
The server requires a certificate to run. A sample certificate has been gen-
erated and stored in the certificates folder of the server. This will work with no
problems on smartphones running Android. However, for iOS a new certificate
must be generated. More details on how to do this for iOS can be found in
reference [22].
The Jenny 5 web client allows to control one motor (as in the case of arms)
or maximum two motors (as in the case of platform, leg and head) at a time.
In such scenario the utilization of the application is very simple:
•the user presses a button (to select the motor that he wants to move),
•the tilts the smartphone,
•the client application read the gyroscope of the smartphone,
•the client application send the angle to the server on the robot,
•and the robot acts accordingly.
The client can request a picture from robot and then displays it in the
browser window.
The web client also accepts voice commands. This feature is implemented
by using Speech Recognition from HTML 5 [19].
An screenshot of the HTML5 client is depicted in Figure 9.
9.5 Intelligent algorithms
Currently there are two intelligent algorithms implemented on the robot:
•An algorithm which finds the closest face and moves the head’s motors in
order to center it on the camera view. Only the head is involved in this
operation.
9 THE SOFTWARE CONTROLLING THE ROBOT 34
Figure 9: Jenny 5 HTML 5 web client. Red circle indicates the tilt of the
smartphone.
10 WEAKNESSES AND FUTURE DEVELOPMENT 36
10 Weaknesses and future development
Jenny 5 robot is under active development.
During the development of the Jenny 5 robot we have observed several weak-
nesses that we plan to address in future iterations.
Some short term ideas are listed in Table 7.
Table 7: Future work on Jenny 5.
Task Purpose
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 ap-
plication
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 for-
ward
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
10 WEAKNESSES AND FUTURE DEVELOPMENT 37
Acknowledgement
The author likes to thank to the following of his students which have helped
him while working to older prototypes of Jenny 5:
•2017 students from Intelligent Robots class: Alexandru Donea, Daniela
Onit¸a, Flaviu Suciu, Tudor Samuila, Daniel Leah, Leontin Neamt¸u, Todor
Ut¸, Marius Penciu, Florin Jurj, Alin Simina, Mihaela Ro¸sca.
•2016 students from Intelligent Robots class: Pop Ioana, Mure¸san Andreea,
Kisari Andrei, Turtoi Cristian, Mate¸s Ciprian, Chereghi Adrian, Buciu-
man Mircea, Bochi¸s Bogdan.
•2015 students from Intelligent Robots class: Andra Ristei, Horea Mure¸san,
Baciu Iulian, Bica Ioana, Bonte Aurelian, Ilie¸s Daniel, Lonhard Cristian,
Lungana Niculescu Alexandru Mihai, Marian Cristian, Sorban Timea,
Tiperciuc Corvin.
REFERENCES 38
References
[1] Jenny 5 website, https://jenny5.org or https://jenny5-robot.
github.io, last accessed on 2019.06.10
[2] Source code for Jenny 5 robot on GitHub, https://github.com/
jenny5-robot, last accessed on 2019.06.10
[3] Scufy - the Arduino firmware, https://github.com/jenny5-robot/
Scufy, last accessed on 2019.06.10
[4] Scufy Lib, https://github.com/jenny5-robot/Scufy-Lib, last accessed
on 2018.11.18
[5] RoboClaw control library, https://github.com/jenny5-robot/
jenny5-control-module, last accessed on 2018.11.18
[6] Short circuit movie, https://www.imdb.com/title/tt0091949/, last ac-
cessed on 2017.04.15
[7] OpenSCAD, https://www.openscad.org, last accessed on 2018.11.18
[8] Arduino, https://www.arduino.cc, last accessed on 2017.04.15
[9] Arduino Nano, https://www.arduino.cc/en/Guide/ArduinoNano, last
access on 2018.11.10
[10] Pololu A-Star, https://pololu.com/product/3145, last accessed on
2018.11.10
[11] Terra Ranger One, https://teraranger.com/, last accessed on 2017.04.15
[12] OpenCV library, https://opencv.org, last accessed on 2017.04.15
[13] A4988 Stepper Motor Driver Carrier, https://pololu.com/product/
1182, last accessed on 2018.11.10
[14] RoboClaw website, http://www.basicmicro.com/, last accessed on
2019.06.10
[15] Sharp GP2Y0D805Z0F senzor, https://pololu.com/product/1132, last
accessed on 2018.11.10
[16] Rotary Position Sensor, Magnetic, https://digikey.com/
product-detail/en/ams/AS5147-TS_EK_AB/AS5147-TS_EK_AB- ND/
5452350, last accessed on 2018.11.10
[17] Eduard S
,uic˘a’s repositories on GitHub, https://github.com/eduardsui,
last accessed on 2019.06.20
[18] TLSe, https://github.com/eduardsui/tlse, last accessed on 2019.06.20
REFERENCES 39
[19] Speech Recognition in HTML5, https://developer.mozilla.org/
en-US/docs/Web/API/Web_Speech_API, last accessed on 2018.11.18
[20] Fritzing, electronics designed software, http://fritzing.org/home/, last
accessed on 2018.11.19
[21] Raspberry Pi, https://www.raspberrypi.org/, last accessed on
2018.11.19
[22] Generating certificates for iOS, https://github.com/mattdesl/
budo/blob/dcbc05866f583e172d6b46c898048436ab84ddae/docs/
command-line-usage.md#ssl-on- ios, last accessed on 2018.11.19
[23] MIT license, https://opensource.org/licenses/MIT, , last accessed on
2019.07.08
[24] Stepper Online website, https://www.omc-stepperonline.com, last ac-
cessed on 2019.07.08
[25] Nick Johantgen, Torque vs speed of stepper motors, Oriental Motor
USA Corporation, https://www.orientalmotor.com/stepper-motors/
technology/speed-torque-curves-for- stepper-motors.html, last ac-
cessed on 2019.07.08