Systems and methods for compiling robotic assemblies

Systems and methods to systematize the development of machines using inexpensive, fast, and convenient fabrication processes are disclosed. In an embodiment, a robot compiler generates a fabrication system, including mechanical, electrical, and software assemblies, that can be used for assembling a robot according to a user design.

BACKGROUND

The creation of new machines requires significant development time, financial resources, and technical expertise. While a wealth of tools exist for many robot development steps, there is not a single end-to-end process which begins with a novice user specifying a desired task and resulting in a fully functional robot able to perform that task.

An alternative to traditional machine design and fabrication may be referred to as “printable” and/or “foldable” machines. Such designs may utilize tools which are readily available, inexpensive to operate, and require minimal technical knowledge by a user.

As an illustrative example of the concepts, systems, circuits, devices and techniques sought to be protected herein, assume a home owner needs a machine to explore areas of his basement in order to detect carbon monoxide and radon. The machine may be required to traverse a cluttered environment, carry a sensor, and report back to the user. Using traditional design and fabrication techniques to create such a machine may be time consuming and inconvenient for the user. However, if the user uses a foldable machine described below, the user may feed specifications to a foldable machine compiler, which chooses notional designs from a pre-populated library or database, refines geometries based upon the task to be performed, and produces detailed design and program files. The machine may then be fabricated from the design and program files, and the user may collect the machine and place it into operation.

In another example, a custom gripper may be desired for an electronics assembly line. The gripper could, for example, be utilized by a pick and place machine. The assembly line manager can specify traits of the part such as the mass and approximate geometry. These specifications may be provided to the foldable machine compiler and fabrication process to produce a custom gripper to meet the task needs.

Like numbers in the drawings denote like elements. Connectors within circuit or block diagrams may represent single wires, buses, or other types of connections between blocks. A single connector line should not be construed to limit the type of connection to a single wire.

The figures, including the flowcharts and block diagrams, are provided for exemplary purposes and are not intended to limit the scope of this disclosure. Although the figures depict diagrams and flowcharts with particular numbers of blocks connected in particular arrangements or sequences, these are examples only. Other arrangements and sequences are within the scope of this disclosure.

DETAILED DESCRIPTION

In an embodiment, to create a foldable machine, a user may provide specifications to a foldable machine compilation system, which may choose appropriate designs for completion of the specified task from a pre-populated library or database, refine geometries based upon the task to be performed, and produce detailed design and program files. The detailed design and program files may include electronics designs, software for operating and/or controlling the robot, and/or mechanical designs and instructions, The designs may include a cutting pattern for cutting a template out of a sheet of substrate material, a circuit pattern for creating and populating a circuit on the template, and/or a folding pattern that can be applied to the template in order to form the template into the final machine.

Laser cutters, lamination, and PCB-like component assembly followed by a final assembly that folds the substrate into its final form may be utilized. This so-called printable approach may allow for rapid development of low-cost machines using a general process that links specifications to prototypes, without requiring in-depth technical knowledge from the end user. The manufacturing process may include at least some or all of the following: (1) modeling of the machine; (2) parameter instantiation according to user specifications, i.e. modification of the model in order to tailor the machine to a particular task; (3) printed body fabrication; (4) printed electronics on the 2D body; (5) population of electronic components on the body; and (6) assembly of the 3D machine using folding. The resulting machines may be relatively light-weight (e.g. about 3 g in some instances) and may function as autonomous, programmable machines or robots. In an embodiment, a foldable machine may be fabricated in less than one day, less than 8 hours, less than four hours, less than two hours, less than one hour, or in any appropriate amount of time.

In an embodiment, the foldable machine compiler may generate a fabrication system for assembling the functioning robot. The fabrication system can include one or more of a mechanical design component, an electrical design component, and a software design component.

Compilation System

Referring toFIG. 1, a system100for generating applications for controlling a robot comprises an interface102to receive design specifications which may include input parameters104for a robot. The design specifications may refer to or may include the subcomponents110, which will be described below in greater detail. In embodiments, interface102is a user interface that allows a user to specify a robot design, including input parameters104for customizing or defining the robot. The interface102may be a graphical user interface, a textual user interface, or any type of user interface that allows a user to enter specifications for the robot design.

The input parameters104are data elements generated as a result of the user's input to interface102. A user may, for example, use the interface102to choose modular components that will become part of the final robot. The user may then customize or supply parameters of the modular components. Data identifying and customizing the chosen modular components is then provided by interface102as input parameters104. These input parameters may define the user's input into the robot design. For example, if the user is designing a robotic arm, the user can use interface102to choose an arm portion, a finger portion, and a mount portion for mounting the arm to a fixed object, as well as other modular components of the robotic arm.

Depending on the modular component, interface102allows the user to specify parameters that customize the modular component for the specific robot being designed. For example, in the case of the arm portion, the user may specify the number of segments and elbows in the arm, and the size and length of each segment. In the case of the finger portion, the user may specify the number of segments and knuckles in the finger. In the case of the mount portion, the user may specify the type and size of the mount. As another example, if the robot design contains a wheel, the user may specify the size of the wheel and the number of wheels included in the robot. The type of modular component, the number of each modular component, and parameters that customize the components may be included as input parameters104. Optionally, the user may also specify software components that can be used to control the robot.

User interface102also allows the user to arrange and connect the modular components as desired to form a robot design.

System100also includes a component library106. Library106is a library or database of predefined modular components each describing a modular element of the robot. Continuing the example above, library106may contain predefined modular components that define the arm, fingers, and mount of the robotic arm. Library106also contains other types of modular elements including, but not limited to arms, hinges, beams, motors, fingers, mounts, tendons, electrical- or software-based controllers, sensors, wheels, robot bodies, or any other type of element to be included in a robot. Library106may also include software elements for controlling the robot. These software elements may include drivers and other software modules for interfacing with the robot's hardware, and may also include graphical user interface (GUI) elements that can be compiled into an application for controlling the robot. For example, Library106may include code, libraries, and/or compiled software modules for GUI elements such as buttons, sliders, toggle switches, levers, wheels, etc. These GUI elements can be compiled into an app that may be executed by a user on a PC, mobile device, or other computing device for controlling the robot's actions.

At least some of the modular elements may be composite elements that include or call-out other modular elements from library106. For example, library106may include a robotic hand element, which in turn includes two or more finger elements and a base element to which the fingers attach. As another example, a wheeled platform element in library106may include a base element and at least two wheel elements, each of which may also be a component element in library106. The composite elements may also include GUI elements for controlling the composite element and/or for controlling individual elements that comprise the composite element.

In embodiments, each modular element in the library includes the predefined components including electrical, mechanical, software, and composite elements. The electrical components include lists of electrical or electromechanical components required by the electrical component, as well as definitions of electrical connections for connecting the electrical components to other elements of the robot. For example, a robotic arm may include electrical components such as servo-motors, LEDs, sensors, or other electrical components that may be included in a final assembly of the arm. The robotic arm, as defined in database106, may also include definitions of how the electrical components should be connected. The robotic arm may also include a modular controller as part of the electrical elements. The modular controller is an electrical element that includes a processor, that couples to and controls other electrical elements, and that facilitates communication between other modular controllers and a central controller. The modular controller will be described in greater detail below.

System100also includes a parameter inheritance module108coupled to receive the input parameters104from interface102. Parameter inheritance module108modifies the input parameters104and applies them to the modular components chosen by the user and received from library106. The modular components may also include fixed and/or predefined parameters such as a required voltage, a data type of a UI element, an angle of a fold, a non-adjustable width, etc. In embodiments, the modular components can also include parameters that may be calculated using functions that take other parameters (user modified parameters, fixed parameters, etc.), or other data, as inputs. The parameter inheritance module108may handle any of these types of parameters for producing a robot design.

The modular components may be modified or customized by the input parameters received from the user form sub-components110of the robot. As depicted inFIG. 1, the sub-components110contain parameters112, which provide customization of the modular components for the specific robot being designed. As discussed above, parameters112may include data to specify size, number of elements, connection details, etc. In the case of the robotic arm, parameters112may specify the number of segments and elbows of the arm, the size of the segments, information about how the elements of the arm are to be connected, etc.

System100also includes a compiler114that receives sub-components110and generates a robot design, as defined by a fabrication system116. Compiler114includes a composition algorithms module118and an implementation engine120.

Composition algorithms module118contains algorithms and processes that receive the sub-components110and produce a fabrication file. As noted above, the sub-components are modular components from library106that have been modified by applying user parameters112to the components. The composition algorithms module118may compile each of these sub-components110to enable them to be connected to and operable with the final robot design. For example, assume that a particular sub-component is a robotic arm having two segments and an elbow controlled by a servo-motor. The sub-component may be defined by the mechanical structure or assembly of the arm, the electrical components and connections that operate the arm, and software that can be used to control the arm. The composition algorithm module may compile each of these, within the context of parameters112, to generate a fabrication file that defines these elements for the specific robot.

To generate the electrical components, the composition algorithm module118may identify electrical connections to be made between the sub-components in order to effectuate the final robot design. To do so, the composition algorithm module118may form or define specific electrical connections that will allow the robot to operate. For example, in a robotic arm, the composition algorithm module118may specify that a servo-motor in the arm should be connected to, say, a power pin, a ground pin, and a pulse-width modulated output pin of a modular controller in the arm.

The composition algorithm module118may also generate electrical components and/or electrical connections based on the parameters112, which may include parameters set by the user, fixed parameters, parameters calculated by a function, etc. In embodiments, the composition algorithm module118can also choose/insert the controller modules into a robot design. For example, if the user specifies that a robotic arm has three segments and two joints, the composition algorithm module118may specify the number of electrical components needed and the type of components (e.g. two servo-motors in this example), and connections for two servo-motors, one at each joint.

The composition algorithm module118may also define inter-module connections. For example, the composition algorithm module118may specify that the modular controller in the arm will be connected to, say, communication pins 1 and 2 of a central controller of the robot, which may be a separate sub-component of the robot. The electrical interconnections can be subsequently used by the implementation engine20to create wiring diagrams, wiring instructions, etc.

To generate the mechanical components, the composition algorithm module118may identify mechanical interconnections and couplings between the sub-components. For example, if the user specifies that the robotic arm has two segments, the composition algorithm module118will define a joint between the two segments. If the user specifies that the robotic arm has three segments, the composition algorithm118will define two joints.

To generate the software components, the composition algorithm module118may identify software components associated with the sub-components110. The software components may comprise control elements, such as graphical user interface elements, that can be incorporated into a software application for controlling the robot. The software application may be executed by a personal computer, mobile phone, tablet computing device, etc. The software components may also include software that is programmed into the robot controller to operate the robot and its parts.

The robotic arm may include sliders, knobs, or other graphical software elements that can move individual segments of the arm. In another embodiment, the software is an API and/or software library for controlling the sub-component that can be accessed by other software applications.

The composition algorithm118may tailor the software elements in accordance with the parameters112. For example, if the robotic arm contains two servo motors, composition algorithm118may produce software with graphical control elements or API functions for controlling the two servo motors.

Composition algorithm118collects the electrical, mechanical, and software elements of the robot design as a so-called fabrication file, which is sent to implementation engine120.

In an embodiment, the composition algorithm module118takes, as an input, the individual design elements from each sub-component and compiles them into a single set of design elements. The single set of design elements is then sent to the implementation engine120. Mechanical design elements can be virtually arranged and connected according to the specified connections and combined into a mechanical design that incorporates the individual sub-components by unifying shared geometries and adding support material as necessary. The electrical elements are combined by combining all of the device requirements for assignment into available processor ports. For example, a component controller may be assigned to ports (or e.g. pins) 5 and 6, for example, of the central controller. These assigned ports are then codified into a software library and mapped to the software elements associated with each sub-component (e.g. software elements associated with the components in library106) to form a single software project that can be compiled into an application for controlling the robot by sending signals to the appropriate ports. The software project may include software that can run on the processor(s) of the robot, an application that can run on a computer or mobile device, or a combination thereof.

Implementation engine120receives the fabrication file and produces a fabrication system116that can be used to assemble the final robot. Implementation engine120comprises software drivers or algorithms that translate the fabrication file into output types that can be used by specific fabrication tools.

In one example, the mechanical elements of the robot are implemented as a foldable or printable robot that can be printed as a two-dimensional cutout and subsequently folded to form a three-dimensional structure. Such robots are described in U.S. patent application Ser. No. 13/723,364, which is incorporated here by reference in its entirety. In this example, implementation engine120may generate files that a printer, such as a vinyl or plastic sheet printer, can use to print the robotic structure. Compilation engine may also create a fold pattern or other printable file containing instructions for how to fold or assemble the mechanical elements of the robot. In another example, implementation engine120creates a 3D print file that can be sent to a 3D printer to print or grow the part.

The implementation engine120also generates electronic design components such as wiring diagrams and wiring instructions as part of fabrication system116. The wiring diagrams and instructions correspond to the electrical connections generated by the implementation engine. The wiring diagrams and instructions can be used by an assembler to connect the electrical components of the robot.

The implementation engine116also generates software design components. The software design components may be software code, a library, an API, and/or other software elements that can be used to control the robot such as GUI elements that can be incorporated into a software application to control the robot, a fully or partially compiled computer or mobile application for controlling the robot, or a combination thereof. The software components generated by the implementation engine116can also include software documentation for connecting to the API or for using the GUI elements or application.

Referring toFIG. 2A, a method200for generating the mechanical design for a robot begins in block202. In block204the system100receives user generated design parameters such as input parameters104from interface102. In block206, the system100receives modular components to be included in the robot design from library106.

In block208, compiler114generates an overall mechanical layout of the robot including mechanical portions of the components from library106, parameters104received from interface102.

In block210, the composition algorithm module118adds mechanical support structures. For example, if two components are to be mechanically coupled, then mounts, joints, fasteners, flanges, or other mechanical support structures are added to the robot design. Additionally or alternatively, composition algorithm module118adds mechanical support structures by, for example, adding mechanical supports such as straps or additional beams to strengthen the mechanical structure of the robot if needed.

In block212, composition algorithms module creates a fabrication file that defines the complete structure of the robot. In block214, implementation engine120translates the fabrication file into fabrication system116which can be used to print, build, and/or assemble the robot.

Referring toFIG. 2B, a method216for generating the electrical design for a robot begins in block218. In block220the system100receives user generated design parameters such as input parameters104from interface102. In block222, the system100receives modular components to be included in the robot design from library106.

In block224, compiler114generates and defines electrical connections based upon electrical portions of the selected components from library106and the parameters104received from interface102.

In block226, the composition algorithm module118generates wiring diagrams for some or all of the selected modular components. In block228a wiring diagram for the entire structure and/or for a portion of the structure is provided to the implementation engine120, which generates the electrical wiring diagram and instructions as part of fabrication system116.

Referring toFIG. 2C, a method230for generating software applications and/or software components for a robot begins in block232. In block234the system100receives user generated design parameters such as input parameters104from interface102. In block236, the system100receives modular components to be included in the robot design from library106.

In block238, compiler114generates software libraries, GUI elements, or other software elements for controlling the robot and/or the components of the robot as retrieved from library106. In block240, the software code is provided to implementation engine240.

Referring now toFIG. 3a robot300includes a central controller302and multiple component modules304,306,308, and310. The central controller may include a processor and hardware storage, such as a memory for example. The memory may contain software which, when executed by the processor, can directly control the robot, can provide an interface for external software to control the robot, or both. In an embodiment, the central controller may include a processor, microprocessor, custom processor or any type of processor that can be used to control the robot. In one embodiment, the central processor may be implemented by an Arduino™ system, a Raspberry Pi™ system, a custom microprocessor-based system, or the like.

The component modules can be modular elements added to the robot by the user and/or components automatically added to the robot by the composition module. For example, if the robot is a robotic arm, component modules304-310may be individual arms, fingers, displays, or other elements added to the robot by the user.

The component modules contain a component controller312for controlling the component modules. Coupled to the component controllers are one or more controllable elements320. The controllable elements are electrical or electromechanical elements that can be controlled and operated by the component controller. Controllable elements320may include, but are not limited to, motors, LEDs, displays, power supplies, digital or analog input or output ports, serial or parallel communication ports, sensors, speakers, microphones, and the like. Controllable elements320may be any type of electrical or electromechanical device that can be included in a robot. Each component controller314-318can be coupled to and control one or more controllable elements320. In other embodiments, the central controller302may directly control controllable elements320without the need for computer controllers314-318. In this case, the controllable elements320may be coupled directly to the central controller302. In other embodiments, the central controller302may optionally be omitted from robot300. In this case, one or more component controllers314-318(individually or in concert with each other) may act to control the robot functionality.

The component controllers can be in direct communication with central controller302, as shown by communication line322between central controller302and component controller304. Additionally or alternatively, component controllers can be in indirect communication with central controller302. For example, component controller318is coupled directly to component controller316via communication line324and communicates with central controller302indirectly by sending and receiving communication through component controller316.

In an embodiment, the communication lines such as322and324are serial communication lines, parallel communication lines, wireless communication lines, or any type of communication media between component controllers and/or central controller302.

As an example, if component module306is an articulable finger of a robotic arm, component controller314may communicate with central controller302, which may instruct component controller314as to how and when to articulate the finger. Controllable element320may be a servo-motor to move the finger and controllable element320amay be an LED, for example. Communications from the central controller instruct component controller314as to how and when to activate the servo-motor320to move the finger, and how and when to light the LED320a.

Referring now toFIG. 4, a component controller400may be the same as or similar to one or more of component controllers312-318. Component controller402includes a processor402and memory such as a ROM or Flash (not shown). Software, e.g. firmware, instructions may be stored on the memory and executed by the processor to effectuate functionality of the component controller400. In an embodiment, each component controller has the same software or firmware running on its processor.

The processor402may have one or more input and/or output (“I/O”) ports404,406, and408that can be coupled to controllable elements such as motor410, LED412, and sensor414. In an embodiment, ports404,406, and408can be programmed to be input ports, output ports, digital ports, analog ports, etc. in response to configuration commands received from central controller302. The compiler114may determine, during compilation of the robot design, how the ports404-408will be configured based on what type of controllable element is coupled to the port.

Component controller400also includes one or more communication ports such as communication ports420and422. Communication ports420and422may be configurable as so-called upstream ports for communicating with an upstream component controller (e.g. component controller316) or for communicating with central controller302. Communication ports420and422may also be configurable as so-called downstream ports for communicating with a downstream component controller (e.g. component controller318). Communication ports may be serial ports, parallel communication ports, wireless ports, networking or LAN ports, or any other type of communication port.

The software or firmware executed by processor402may provide an interface to initialize the IO ports404-408. For example, the software compiled by compiler114and executed by central controller302may initialize the IO ports404-408by sending initialization command to the component controller314based on the type of controllable element connected to the IO port. In this example, central controller302may send command to initialize port404as an analog output port to control motor410, to initialize port406as an analog output port to control LED412, and initialize port408as a digital input port to receive digital data from sensor418. Of course, if sensor418provides analog data, port408can be configured as an analog input port.

Once the ports are initialized, central controller302can send commands to processor402to control the elements attached to the ports. For example, central controller302may issue a command that instructs processor402to provide, say, a 2.5 V or other output voltage on port406to illuminate LED412.

Referring now toFIG. 5, component library500may be the same as or similar to library106inFIG. 1. Library500can store base or atomic level elements502. Base level elements are elements that do not call upon other elements. They include, but are not limited to, mechanical elements such as hinges, beams, extensions, tabs, etc. that can be incorporated into the robot design; electrical elements such as an Arduino board definition, an LED, a photo-sensor, a switch, etc.; and software elements such as software that can be executed by the central controller or other software elements that can be included in the robot design such as drivers, and/or software components, such as GUI elements like sliders, toggle switches, etc., that can comprise or be included in a software application used to control the robot.

Library500also includes composite elements504, which include elements that incorporate other elements from library500such as the base or atomic level elements502. As an example, a leg element may include one or more beams, firmware, motors, software, and/or GUI elements as part of the definition of the leg. Composite elements can include base elements and/or other composite elements as part of their definition. These base and composite elements can be accessed and used by the user to design the robot. In embodiments, the user can create the component elements and store them in library500.

Referring toFIG. 6, a hierarchical diagram600of library elements shows a particular design for the robotic arm or plotter700ofFIG. 7.

Diagram600includes a top level element called plotter601. Plotter602is the definition of the robot being designed. Referring also toFIG. 3, plotter602includes a brain604, which may comprise software to be downloaded into central controller302to effectuate the robot design and initialize the component controllers312-318in accordance with the design.

Plotter601also includes an arm604having one or more actuated hinges606and beams608. The actuated hinges606may correspond to elbows702and704inFIG. 7. The beams604may correspond to the arm beams706and708. Each actuated hinge606includes a servo motor610, which in turn includes a motor612, an EModule or motor driver614, and a mount616. Each mount may include a cutout element618. The servo motor elements can be seen as servo motors710and712inFIG. 7. The actuated hinges606also include a hinge element611that defines the mechanical structure of the hinge and a tendon element612that can be connected between the servomotor and the arm segments so that the motor can move the arm. The arm604also includes one or more beams608.

Plotter601also includes an actuated gripper element620, which in turns includes another servo622and a gripper element624. The actuated gripper element can be seen as the grip portion714of arm700. The actuated gripper element620also includes a gripper624, which includes a block626and one or more fingers628, each having one or more beams630. Servo622corresponds to servo motor716inFIG. 7, and fingers628correspond to fingers718and720of the gripping portion714.

The hierarchical definition of the plotter601informs the compiler114of the robot design. The compiler114may then compile the mechanical, electrical, and software components of fabrication system116that allow the robot to be assembled, as described above. As shown inFIGS. 6 and 7, the hierarchical definition of plotter601may produce a fabrication system which, when assembled, results in the assembled plotter arm as shown inFIG. 7.

Referring now toFIG. 8, another robot design800includes a definition for a plotter802, which may be the same as or similar to plotter601.FIG. 8illustrates that elements in the hierarchical design may include multiple instances. For example, the arm804includes k number of actuated hinge elements806and beam elements808, depending on the parameters input by the user. Similarly, the actuated gripper element810includes n number of fingers812, which each contain m number of beams814, depending on the parameters input by the user. The number k and n can be set by the user, or can be set by the system. In embodiments, the numbers k and n may have default values that are stored in library500or computed by the system during compilation.

In an embodiment, a computer (or a series of computers connected by a network) includes a processor or series of processors and a volatile or non-volatile memory or series of memories. Computer readable instructions stored in the memory may be executed by the processor.

The computer may also include a database or series of databases that can be stored on a hard drive or other storage device. The database may be any database, relational or otherwise, known in the art that can store data such as model data for foldable machines.