U.S. patent application number 11/893348 was filed with the patent office on 2007-12-06 for systems and methods for programming motion control.
This patent application is currently assigned to Siemens Technology-To-Business Center LLC. Invention is credited to Farshid Arman, Hartmut Ludwig, Lingyun Wang, Michael Wynblatt.
Application Number | 20070282481 11/893348 |
Document ID | / |
Family ID | 34576958 |
Filed Date | 2007-12-06 |
United States Patent
Application |
20070282481 |
Kind Code |
A1 |
Wynblatt; Michael ; et
al. |
December 6, 2007 |
Systems and methods for programming motion control
Abstract
Systems, methods and computer program code for the programming
of motion control in load transportation systems are provided which
may include programming motion control by specifying desired load
motions.
Inventors: |
Wynblatt; Michael; (Moraga,
CA) ; Arman; Farshid; (Lafayette, CA) ;
Ludwig; Hartmut; (West Windsor, NJ) ; Wang;
Lingyun; (Plainsboro, NJ) |
Correspondence
Address: |
SIEMENS CORPORATION;INTELLECTUAL PROPERTY DEPARTMENT
170 WOOD AVENUE SOUTH
ISELIN
NJ
08830
US
|
Assignee: |
Siemens Technology-To-Business
Center LLC
|
Family ID: |
34576958 |
Appl. No.: |
11/893348 |
Filed: |
August 14, 2007 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
10845392 |
May 12, 2004 |
|
|
|
11893348 |
Aug 14, 2007 |
|
|
|
60520515 |
Nov 14, 2003 |
|
|
|
Current U.S.
Class: |
700/219 |
Current CPC
Class: |
G05B 2219/35585
20130101; G05B 2219/45054 20130101; G05B 15/02 20130101 |
Class at
Publication: |
700/219 |
International
Class: |
G06F 17/00 20060101
G06F017/00 |
Claims
1-23. (canceled)
24. A system, comprising: a processor; and a hard disk drive having
stored therein instructions that when executed by a machine result
in the following: receiving a command associated with a desired
behavior of one or more loads; selecting a control signal for one
or more load actuators, the control signal selected to cause the
one or more loads to undertake the desired behavior; and applying
the control signal to the one or more load actuators.
25. An article of manufacture, comprising: a storage medium having
stored thereon programming code, comprising: code to receive a
command associated with a desired behavior of one or more loads;
code to select a control signal for one or more load actuators, the
control signal selected to cause the one or more loads to undertake
the desired behavior; and code to apply the control signal to the
one or more load actuators.
26. A system, comprising: a plurality of load actuators for moving
one or more loads; an interface for receiving commands associated
with a desired behavior of the one or more loads; and a processor
operable to: select a control signal for at least one of the
plurality of load actuators, the control signal selected to cause
the one or more loads to substantially undertake the desired
behavior; and apply the control signal to the load actuator.
27. The system of claim 26, further comprising: a sensor for
determining information associated with the current behavior of the
one or more loads; and a sensor interface for receiving the
information from the sensor.
28. The system of claim 27, wherein the control signal is selected
at least in part based on the information.
29. The system of claim 26, further comprising: program code
operable to be executed by the processor to select the control
signal and apply the control signal to at least one of the
plurality of actuators.
30. The system of claim 29, wherein the program code includes: code
to determine a desired velocity of the one or more loads; code to
convert the desired velocity of the one or more loads to an
obtainable velocity; and code to modify the obtainable velocity to
substantially conform to a velocity profile.
31. The system of claim 30, further comprising: code to determine
if the one or more loads will collide with at least one other load.
Description
CROSS-REFERENCE TO RELATED APPLICATIONS
[0001] This application claims benefit and priority under 35 U.S.C.
.sctn. 119(e) to commonly-owned U.S. Provisional Patent Application
Serial No. 60/520,515 entitled "A System for Programming Motion
Control by Specifying Load Motions", filed in the name of Wynblatt
et al. on Nov. 14, 2003, the contents of which are hereby
incorporated by reference in their entirety for all purposes.
BACKGROUND
[0002] The present disclosure relates generally to the programming
of motion control and, more particularly, to programming motion
control by specifying desired load motions. Load transportation
systems such as those used in warehouses, package distribution
plants, assembly plants, and manufacturing plants are often
utilized to move loads from one location to another. These loads
are often moved using load motion actuators such as conveyor belts,
rollers, robotic arms, or pin-hole air jets. Current load
transportation systems typically must be programmed to cause a load
to undertake a desired behavior.
[0003] Referring to the load transportation system 100 in FIG. 1a,
for example, a load 102 may be moveable by load actuators 104a-b.
As shown in FIG. 1a, the load actuators 104a-b may include a left
conveyor belt 104a and a right conveyor belt 104b. If the load 102
must be rotated (e.g., as indicated by the rotational arrow 106),
the speeds and directions (e.g., represented by the motion vectors
108a-b) of the conveyor belts 104a-b must typically be directly
specified. For example, the left conveyor belt 104a may be
programmed to move in accordance with a reverse motion vector 108a,
while the right conveyor belt 104b may be programmed to move in
accordance with a forward motion vector 108b. The speeds of the
conveyor belts 104a-b may be specified, for example, to control the
rate at which the load 102 is rotated. Similarly, the timing of
actuator commands may need to be specified in order to cause the
load 102 to undergo a desired behavior or set of behaviors (e.g.,
rotate ninety degrees, then stop). The system programmer must
therefore determine and code each speed, direction, and all timing
information for each actuator 104a-b needed to rotate the load
102.
[0004] Similarly, with reference to the system 150 of FIG. 1b, load
A 152a and load B 152b may be moveable by an actuator 154a that
moves all loads rigidly, as well as actuators 154b-c which move
only loads that sit on top of the them. The system 150 may be, for
example, a crossbelt conveyor system. If loads A 152a and B 152b
must be moved from first locations (locations A and B,
respectively) to second locations (locations A' and B',
respectively), a programmer would have to specify the speeds and
directions of the actuators 154a-c, including the times at which
each of the specified motion vectors must be initiated and/or
stopped.
[0005] These speed, direction, and timing decisions require the
programmer to be highly skilled in selecting settings for all of
the various actuators in a given load transportation system, and
require many programming hours to configure the system to properly
transport a given load. Where multiple loads are transported by the
same system, the required speeds, directions, and timing of the
actuators become increasingly complex for the programmer to
determine, and require substantially more programming hours to
configure.
[0006] Accordingly, there is a need for systems and methods for
programming motion control that address these and other problems
found in existing technologies.
SUMMARY
[0007] Methods, systems, and computer program code are therefore
presented for programming motion control in load transportation
systems.
[0008] According to some embodiments, systems, methods, and
computer code are operable to receive a command associated with a
desired behavior of one or more loads, select a control signal for
application to one or more load actuators, the control signal
selected to cause the one or more loads to undertake the desired
behavior, and apply the control signal to the one or more load
actuators.
[0009] According to some embodiments, systems, methods, and
computer code are operable to determine a desired velocity of one
or more loads, convert the desired velocity to an obtainable
velocity, determine a velocity profile to be associated with the
one or more loads, and modify the obtainable velocity to
substantially conform to the velocity profile.
[0010] With these and other advantages and features of embodiments
that will become hereinafter apparent, embodiments may be more
clearly understood by reference to the following detailed
description, the appended claims and the drawings attached
herein.
BRIEF DESCRIPTION OF THE DRAWINGS
[0011] FIG. 1a is a block diagram of a system for transporting
loads;
[0012] FIG. 1b is a block diagram of a system for transporting
loads;
[0013] FIG. 2 is a flowchart of a method according to some
embodiments;
[0014] FIG. 3 is a block diagram of a system according to some
embodiments;
[0015] FIG. 4 is a flowchart of a method according to some
embodiments;
[0016] FIG. 5 is a block diagram of a system according to some
embodiments; and
[0017] FIG. 6 is a block diagram of a system according to some
embodiments.
DETAILED DESCRIPTION
[0018] Some embodiments described herein are associated with an
"actuator", "load actuator", or "load motion actuator". As used
herein, the terms "actuator", "load actuator", and "load motion
actuator" may be used interchangeably and may generally refer to
any devices and/or systems capable of causing, directing,
controlling, and/or otherwise contributing to the movement of an
object. Examples of load motion actuators may include, but are not
limited to, rollers, conveyor belts, pin-hole air jets, motors,
servos, cables, valves, magnets, and various robotic devices such
as arms, gates, cranes, and hydraulic lifts. In some embodiments,
an actuator may be or include an electronic device or component
such as a processor, a Printed Circuit Board (PCB), and/or any
other type of electrical connection and/or circuit associated with
the movement of an object.
[0019] Some embodiments described herein are associated with a
"control signal". As used herein, the term "control signal" may
generally refer to any data, bit, packet, pulse, tone, waveform,
and/or other type or configuration of signal. Control signals may
be or include information packets transmitted, for example, in
accordance with Power-Line Control (PLC), field bus, or industrial
Ethernet transmission standards. In some embodiments, a control
signal may be or include a command and/or other information
associated with a desired setting, action, and/or behavior of one
or more load actuators. The control signal may cause, for example,
an actuator to move a load in accordance with a desired load
behavior.
[0020] Referring to FIG. 2 (and with continuing reference to FIG.
1a and FIG. 1b), a flow diagram of a method 200 for programming
motion control in accordance with some embodiments is shown. The
method 200 may be associated with and/or performed by, for example,
the systems 100, 150, 300, and/or 600 (or one or more of the system
components) described in conjunction with FIG. 1a, FIG. 1b, FIG. 3,
and FIG. 6, respectfully herein. The flow diagrams described herein
do not necessarily imply a fixed order to the actions, and
embodiments may be performed in any order that is practicable. Note
that any of the methods described herein may be performed by
hardware, software (including microcode), firmware, or any
combination thereof. For example, a storage medium may store
thereon instructions that when executed by a machine result in
performance according to any of the embodiments described
herein.
[0021] In some embodiments (such as shown in FIG. 2), the method
200 may begin by receiving a command associated with a desired
behavior of a load, at 202. For example, a programmer and/or other
entity may enter information indicative of a desired load motion
into a computer, Graphical User Interface (GUI), and/or any other
type or configuration of interface device. The interface may be,
for example, an Application Programming Interface (API) used to
facilitate and/or standardize the programming of motion control. In
some embodiments, a programmer may enter information associated
with a desired rotation 106 of a load 102 (as shown in FIG. 1a).
For example, the programmer may use a programming interface to
indicate that the load should be rotated ninety degrees clockwise.
Similarly, the programmer may also or alternatively specify that
load A 152a and load B 152b are to be moved from positions A and B,
respectively, to positions A' and B', respectively (as shown in
FIG. 1b). In some embodiments, a programmer or other user may issue
a command relating to both the translational (e.g., movement of
loads A 152a and B 152b to positions A' and B') and rotational
(e.g., desired rotation 106) movement of loads. According to some
embodiments, commands associated with desired behaviors of multiple
loads and/or collections of loads may be received.
[0022] For example, a programmer and/or other user may utilize an
API to manipulate and/or manage multiple loads. In some
embodiments, one or more loads may be associated, for example, by
grouping them into virtual collections (e.g., electronically
indicating that the loads are associated). Similarly, multiple
loads may be partitioned into one or more groups and/or categories
(e.g., loads that are located in the same geometric area and/or
loads that are of similar types may be associated). Other API
functions may, according to some embodiments, also or alternatively
be available to the programmer and/or user. For example, the
programmer and/or user may submit a query to determine various
characteristics associated with one or more loads. In some
embodiments, the programmer may, for example, determine and/or
request a predicted future position of one or more loads. The
programmer may, according to some embodiments, determine the
nearest neighboring load of one or more selected loads,
collections, and/or groups. In some embodiments, the programmer
may, for example, determine the distance between two or more loads
(e.g., to determine a likelihood of collision, to try and keep
similar loads together, etc.).
[0023] In some embodiments, the command may be received from a
computer, a computer program, a software module, and/or any other
type or configuration of code, device, and/or object. For example,
the command may be received from and/or by a computer server, a
computer workstation, or a Personal Computer (PC) connected to a
network. The network may be, according to some embodiments, any
known or available wired or wireless communication network
including, but not limited to, a Local-Area Network (LAN), a
Wide-Area Network (WAN), a PLC network or field bus network, the
Internet, and/or an intranet or extranet. In some embodiments, the
command may be received by a processor, an actuator (such as
actuators 104a-b, 154a-c), and/or any other network-enabled and/or
communication-enabled device. For example, a computer and/or load
transportation system programmer may utilize a computer workstation
to send a command to a software package and/or API for programming
motion control. In some embodiments, the command may be sent,
transmitted, and/or received by and/or within a single device,
system, and/or object.
[0024] The method 200 may continue, for example, at 204 where a
control signal for application to a load actuator may be selected.
The control signal may be selected, according to some embodiments,
to cause a load to undertake the desired behavior associated with
the received command. For example, where the programmer specifies,
requests, commands, and/or otherwise indicates that the load is to
be rotated ninety degrees clockwise, one or more control signals
operable to cause the load to move in such a manner may be selected
and/or otherwise determined. In some embodiments, the control
signal may be selected based only in part on the received command.
For example, other factors, commands, metrics, parameters, and/or
other information may be utilized in selecting a control
signal.
[0025] In some embodiments, the control signal may be automatically
determined, selected, and/or created. With reference to FIG. 1a,
for example, the motion vectors 108a-b and/or the timing of
actuator movements may be automatically determined. The motion and
timing parameters may then, for example, be automatically converted
to and/or encoded in an appropriate control signal. In some
embodiments, a computer, processor, and/or software package may
determine speeds, directions, and/or timing required to make the
load undergo the desired behavior (e.g., as indicated by the
received command). In such a manner, for example, the programmer
need not directly specify, code, and/or determine the necessary
speed, direction, and/or timing parameters. The amount of time the
programmer must spend developing custom logic for any given load
transportation system may accordingly be significantly reduced.
[0026] In some embodiments, the required speeds, directions, and/or
timing may be embedded in, converted to, and/or otherwise may be
associated with one or more specific control signals. For example,
an electronic signal capable of causing an actuator to perform in
accordance with the required parameters may be created, selected,
identified, and/or otherwise determined. In some embodiments, one
or more appropriate control signals may be retrieved from a
database or lookup table of known or available control signals. The
control signal may be any type or configuration of signal,
transmission, and/or communication that is or becomes known or
available and/or is described herein. In some embodiments, the
control signal may be encoded, encrypted, and/or compressed.
[0027] In some embodiments, such as where a programmer specifies
that loads A 152a and B 152b are to be moved from locations A and B
to locations A' and B' (as shown in FIG. 1b), there may be many
methods that the loads may be appropriately transported to the
desired locations. While each method may achieve the desired
result, each method may require different speed, direction, and
timing settings for the different actuators 154a-c. In some
embodiments, the programmer may only need to specify that the loads
152a-b need to be moved to locations A' and B'. The particular
method and corresponding actuator settings required to achieve the
desired results may be automatically determined. In some
embodiments, a method may be automatically chosen from a plurality
of available methods, strategies, and/or routes. For example, a
programmer may command that load A 152a be moved to position A', as
described above. Of the many possible methods available to move the
load to position A', the most desirable route may be automatically
chosen. The various actuator settings required to implement the
chosen method may also be determined automatically. In some
embodiments, a control signal may then be created, selected, and/or
otherwise determined that represents, is indicative of, and/or
includes the automatically determined actuator settings.
[0028] According to some embodiments, at 206, the control signal
may be applied to the load motion actuator. For example, the
control signal selected at 204 may be sent to the actuator. In some
embodiments, the control signal may cause the actuator to move
and/or assist in moving the load in accordance with the desired
behavior. In some embodiments, the control signal may be applied to
the actuator through the use of one or more converters, filters,
and/or controllers. For example, the control signal may be a
digital signal sent to an Analog-to-Digital Converter (ADC). The
ADC may then, for example, convert the digital control signal to
one or more analog commands and/or settings recognized by the
actuator.
[0029] In some embodiments, the control signal may be applied to
the actuator via multiple component and/or composite signals. For
example, where the control signal is directed to moving load B 152b
from location B to location B' (as shown in FIG. 1b), an initial
signal may be selected and/or transmitted, for example, causing the
first actuator 154a to move load B 152b to the second actuator
154c. Once load B 152b is positioned on or partially on the second
actuator 154c, a second signal may be transmitted causing the
second actuator 154c to move load B 152b to the desired destination
B'. The selection and/or transmittal of actuator-specific signals
may continue, for example, until load B 152b reaches another and/or
final destination (not shown). In some embodiments, the various
control signals and/or signal components may be applied to an
actuator prior to the load arriving at the actuator. In some
embodiments, the actuator (such as actuator 154c) may be controlled
as a load nears the actuator. In some embodiments, the various
components of the selected control signal (and/or various selected
control signals) may be applied directly to one or more actuators
as required to appropriately move the load.
[0030] Turning now to FIG. 3, a block diagram of a system 300 for
programming motion control according to some embodiments is shown.
The system may be associated with and/or carry out, for example,
methods 200 and/or 400 as described herein. The system 300 may
include a programming device 302, a load programming library 304, a
sensor interface 306, sensors 308, a motion control programming
library 310, and actuators 312. In some embodiments, the actuators
312 may be, include, and/or be similar to the actuators 104a-b,
154a-c described in conjunction with FIG. 1a and FIG. 1b herein.
Fewer or more components than shown in FIG. 3, and different types,
layouts, quantities, and configurations of systems may be used
without deviating from the scope and/or purpose of some
embodiments.
[0031] In some embodiments, the programming device 302 may be or
include a PC, a computer workstation, a computer server, a GUI, an
API, and/or any other device that is or becomes known or available.
For example, the programming device 302 may be a computer
workstation and/or console used by a load motion programmer or load
transportation system operator. In some embodiments, the
programming device 302 may be or include a motion control
programming environment such as Microsoft.RTM. Visual Studio.RTM.
or Siemens.TM. Simatic.TM. STEP7, for example. The programming
device 302 may be used, according to some embodiments, to allow a
programmer to specify motion control commands. The programming
device 302 may interface with, be connected to, include, and/or
otherwise be in communication with the load programming library
304.
[0032] In some embodiments, the load programming library 304 may be
or include a software package or program installed, for example, on
a computer server and/or on or within the programming device 302.
The load programming library 304 may, according to some
embodiments, carry out, effectuate, and/or otherwise be associated
with methods 200 and/or 400 as described herein. For example, the
load programming library 304 may convert a programmer's load motion
command into actuator commands. The actuator commands may, for
example, be operable to move a load in accordance with the
specified load motion command. In some embodiments, the load
programming library 304 may include and/or provide access to an API
for programming load motion (not shown).
[0033] In some embodiments, the load programming library 304 may
include a load motion store 320. The load motion store 320 may be
any type and/or configuration of storage device that is or becomes
known or available. For example, the load motion store 320 may be
or include one or more databases, tables, files, and/or memory
devices for storing information. In some embodiments, the load
motion store 320 may include storage for proposed load behaviors
322 and/or current load behaviors 324. The proposed load behaviors
322 may include, for example, desired load motions specified by a
load motion programmer. In some embodiments, the proposed load
behaviors 322 may be or include and/or otherwise be associated with
a command received from and/or through the programming device
302.
[0034] The current load behaviors 324 may be or include information
associated with the current position, behavior, and/or relating to
a characteristic of a load. In some embodiments for example,
current information regarding a load may be obtained from the
sensor interface 306 and/or the sensors 308. The load motion store
320 may, according to some embodiments, also or alternatively store
information associated with future and/or predicted positions,
characteristics, and/or qualities related to one or more loads. In
some embodiments, the load motion store 320 and/or the load
programming library 304 may also or alternatively store other
information associated with a load transportation system, such as
the size and/or boundaries of the system and default or normal
paths and/or plans for moving loads. In some embodiments, a
programmer may utilize the programming device 302, for example, to
query the information contained within the load information store
320. For example, the programmer may enter a query command such as
"GetVelocity", which may for example, request the current load
behavior 324 (e.g., the velocity) of a particular load.
[0035] The load programming library 304 may, according to some
embodiments, include an actuator information store 330. The
actuator information store 330 may, for example, contain
information associated with each actuator in a load transportation
system. Examples of actuator information may include, but are not
limited to, the numbers, sizes, characteristics, and/or positions
of actuator areas of influence, default values for actuator
settings, and speed and/or directional capabilities of actuators.
In some embodiments, the information stored within the actuator
information store 330 may be used by the load programming library
304 to convert desired load motions into appropriate actuator
commands.
[0036] In some embodiments, the actuator information store 330 may
include a history buffer 332 and/or may store information
associated with current actuator behaviors 334. The history buffer
332 may store, for example, information associated with the past
positions, behaviors, and/or characteristics relating to actuators.
The current actuator behaviors 334 may be or include the present,
future and/or predicted actuator commands and/or settings. In some
embodiments, the actuator information store 330 and/or the load
programming library 304 may also or alternatively store other
information associated with a load transportation system, such as
the size and/or boundaries of the system and default or normal
paths and/or plans for moving loads.
[0037] The sensor interface 306 may generally be any device and/or
component for communicating with sensors that is or becomes known
or available. In some embodiments for example, the sensor interface
306 may be or include a computer and/or computer processor, a
network processor, a Network Interface Card (NIC), and/or a
converter, filter, or other logic and/or computational device. The
sensors 308 may be any devices and/or components that are operable
to gather, sense, and/or otherwise determine information associated
with loads and/or load movements or behaviors. The sensors 308 may
include, for example, motion sensors, weight sensors, light sensors
(including lasers), thermal sensors, acoustic sensors, triggers,
gates, switches, and/or barcode or other electronic readers and/or
scanners.
[0038] In some embodiments, the motion control programming library
310 may be or include a system or device capable of managing,
creating, issuing, sending, and/or receiving actuator commands. The
motion control programming library 310 may include, according to
some embodiments, an API (not shown) for defining, programming,
and/or managing motion control functions or commands. The motion
control programming library 310 may be or include, for example, a
Siemens.TM. SIMOTION.RTM. motion control system. In some
embodiments, the API provided by the motion control programming
library 310 may be operated in accordance with the IEC-61131
standards published by the International Electrotechnical
Commission (IEC) and/or as defined by PLCopen. The motion control
programming library 310 may, according to some embodiments,
implement or apply actuator commands to the actuators 312. For
example, the motion control programming library 310 may cause the
actuators 312 to behave in accordance with one or more actuator
commands determined by the load programming library 304.
[0039] As an illustrative example, a programmer may require a load
to be moved from one location to another (such as from location A
to location B, as shown in FIG.1b). The programmer may utilize the
programming device 302, which may be, for example, a computer
workstation. The computer workstation 302 may include an installed
software program that includes the API provided by the load
programming library 304. Through the load programming API, the
programmer may enter and/or code various commands relating to the
transportation of the load. For example, the programmer may enter a
command such as "SetPosition" to identify the desired position of
the load (e.g., location B).
[0040] The desired load behavior (e.g., movement from location A to
location B) may, for example, be stored by the load programming
library 304 as a proposed load behavior 322 in the load information
store 320. For example, the desired behavior may be stored in a
proposed load behavior section and/or table 322 of a load database
320. In some embodiments, the load programming library 304 may
communicate with the sensor interface 306 (and/or sensors 308) to
determine a current status of the load. According to some
embodiments, the sensors 308 may provide information to the load
programming library 304 (e.g., via the sensor interface 306) on a
continuous or intermittent basis.
[0041] The current load information may be stored by the load
programming library 304 as a current load behavior 324 in the load
information store 320. In some embodiments, when the proposed load
behaviors 322 do not match the current load behaviors 324, the load
programming library 304 may initiate and/or transmit commands to
move the load in accordance with the desired load behaviors 322. In
other words, the load programming library 304 may determine that
the load needs to move and may trigger an event and/or initiate a
process to move the load as required. In some embodiments, the
current load behaviors 324 and the proposed load behaviors 322 may
not be compared and/or related until a particular commit command,
such as a "Go" command, is received from the programmer.
[0042] Continuing the illustrative example, once the load
programming library 304 has determined that the load must be moved,
the desired velocity of the load may be determined. In some
embodiments, the programmer may enter and/or set the desired
velocity. Where a simple "SetPosition" command is entered however,
an appropriate velocity for the load may need to be determined. The
velocity may be determined, for example, in accordance with the
method 400 as described hereinafter. In some embodiments, once the
intended velocity of the load is determined and/or set, the desired
load behavior (movement direction, velocity, etc.) may be converted
and/or mapped to appropriate actuator commands. An example of how
the desired load behaviors may be mapped to actuator commands is
described in the co-pending U.S. Patent Application Serial No.
______ titled "Systems and Methods for Controlling Load Motion
Actuators", concurrently filed in the name of Wynblatt et al. on
______, 2004, the contents of which are hereby incorporated by
reference in their entirety for all purposes.
[0043] In some embodiments, information from the actuator
information store 330 may be utilized to determine commands that
are directed to operating the actuators 312 in accordance with
various limits, capabilities, and/or characteristics of the
actuators 312. Similarly, stored and/or entered information
regarding the load transportation system, such as default load
paths or speeds, may be utilized to determine and/or modify
actuator commands. For example, the desired load behaviors and/or
velocities determined, processed, and/or received from the load
programming library 304 may be converted to one or more actuator
commands, such as commands defined by the API provided by the
motion control programming library 310.
[0044] In some embodiments, the commands defined by the motion
control programming library 310 (and/or an associated API) may be
the commands that typically must be determined by a load motion
programmer to operate current load transportation systems.
According to some embodiments herein, the load programming library
304 may allow the programmer to simply enter desired load motions,
which the load programming library 304 may then, for example,
convert to appropriate actuator commands recognized and/or defined
by the motion control programming library 310.
[0045] In some embodiments, the actuator commands determined,
defined, and/or mapped from desired load motions may then be
applied to the actuators 312. For example, the motion control
programming library 310 may transmit the determined actuator
commands directly to the actuators 312. In some embodiments, a
separate motion control device (not shown) may receive actuator
commands and/or other signals (such as the control signal described
in conjunction with method 200 herein). The motion control device
may then, for example, cause the actuators 312 to move in
accordance with the determined actuator commands.
[0046] Turning now to FIG. 4, a flowchart of a method 400 for
programming motion control in accordance with some embodiments is
shown. The method 400 may be performed by and/or associated with,
for example, the system 300 described in conjunction with FIG. 3
above. In some embodiments, the method 400 may be carried out by
the load programming library 304 of system 300. The method 400 may
begin, according to some embodiments, by determining a desired
velocity of a load, at 402.
[0047] For example, a programmer may enter a command, such as
"SetVelocity", specifying a desired velocity for a load. If no
specific velocity is specified by the programmer (such as when the
programmer enters a "SetPosition" command), a normal or default
plan for moving loads may be determined. For example, default load
movement information, such as preferred load paths, may be stored
in a database (such as load information store 320) or in a file
and/or computer program (such as in or by the load programming
library 304). The velocity for the load may then be determined
based on the default movement plan, in accordance with a default
velocity setting, and/or within limits stored regarding system
and/or actuator capabilities.
[0048] In some embodiments, the method 400 may continue at 404, by
converting the desired load velocity into an obtainable load
velocity. For example, various stored and/or entered information
regarding the capabilities of the system and/or the actuators may
be utilized to determine if the desired velocity is capable of
being implemented by the given load transportation system. If the
desired velocity is obtainable, then no change to the desired
velocity may be necessary, for the desired velocity may already be
an obtainable velocity. If the desired velocity is not obtainable,
the desired velocity may need to be adjusted to an obtainable
velocity. In some embodiments, an obtainable velocity substantially
similar to the desired velocity may be selected and/or determined.
For example, the desired velocity may be converted to the closest
obtainable velocity (e.g., the obtainable velocity having the
smallest deviation from the desired velocity).
[0049] The method 400 may continue, according to some embodiments,
at 406, by determining a velocity profile to be associated with the
load. For example, the obtainable velocity may need to be smoothed
to avoid undue and/or inappropriate acceleration of the load.
Information may be stored and/or entered, for example, regarding
the limits within which a load may be accelerated, rotated, and/or
moved. Fragile and/or eccentric loads may require smooth
acceleration to avoid damage and/or tipping, for example. In some
embodiments, a velocity profile (i.e., an acceleration plan) may be
selected which conforms to the limits established for the load. For
example, an expected change in velocity (i.e., acceleration) may be
determined by comparing the current velocity of the load (such as
may be stored in the current load behaviors 324 of the load
information store 320) to the obtainable velocity of the load (such
as may be stored in the proposed load behaviors 322 of the load
information store 320).
[0050] At 408, the obtainable velocity may be modified to
substantially conform to the determined velocity profile. Where the
difference between the obtainable load velocity and the current
load velocity exceeds certain values, for example, the obtainable
load velocity may be modified so that the load is accelerated
within acceptable limits. In some embodiments, the obtainable load
velocity may be changed to match the maximum, average, median,
and/or minimum velocity that is acceptable according to the
selected velocity profile. In some embodiments, the change in load
velocity from the current load velocity to the obtainable load
velocity may be spread out over an appropriate length of time to
achieve the desired acceleration.
[0051] In some embodiments, the velocity of the load may be further
adjusted. For example, the path of the load (route, velocity,
timing, etc.) may be analyzed to determine if the load is likely to
collide with other loads. Proposed paths for various loads may be
compared at specific, various, and/or random time intervals, for
example, to determine if any loads will occupy the same location at
the same time (i.e., a collision). Information regarding the loads,
such as load size and/or shape, may be utilized to assist in
determining if loads will collide. In some embodiments, if a
collision between two loads is predicted, one or more of the
velocities and/or paths of the two competing loads may be altered
to avoid the collision.
[0052] For example, the modified obtainable velocity of the load
with the lowest priority may be adjusted to avoid the collision. In
some embodiments, the proposed velocities of either or both loads
may be iteratively reduced, for example, until no collision appears
likely. The method 400, and/or any of the velocity determinations,
conversions, alterations, and/or modifications therein, may be
repeated at various time intervals, continuously, and/or after
changes are made to avoid a predicted collision. Changes made to
avoid a collision may, for example, create the possibility of new
collisions which may need to be investigated.
[0053] Referring now to FIG. 5, a system 500 is shown to illustrate
the programming of load motion according to some embodiments. The
system 500 may, for example, implement and/or be associated with
methods 200 and/or 400 as described above. In some embodiments, the
system 500 may include loads A, B, and C. Load A may be moved to
position A', according to some embodiments, in accordance with a
desired motion vector 502. In some embodiments, loads B and C may
be moved in accordance with desired motion vectors 504 and 506,
respectively. The desired motion vectors 502, 504, 506 may,
according to some embodiments, be specified motion vectors,
obtainable motion vectors, modified obtainable motion vectors,
and/or other motion vectors associated with the respective
loads.
[0054] As an illustrative example, a programmer may specify that
load A is to be moved to position A', load B is to be moved at an
heading of forty degrees at a velocity of one and a half meters per
second (vector 504), and load C is to be moved at a heading of zero
degrees at one meter per second (vector 506). The
programmer-specified vectors for loads B and C may be selected as
initial desired vectors 504, 506. Because no vector was specified
for load A however, a normal or default plan of load movement
associated with the particular load transportation system may be
determined.
[0055] Where system 500 includes a matrix of roller diverter
actuators (not shown), for example, movement may only be permitted
in the directions of headings zero, forty-five, and one hundred and
thirty-five degrees. Typical and/or desired movement may therefore,
consist of moving a load at a heading of zero degrees until it is
aligned at either a forty-five degree or one hundred and
thirty-five degree angle with the intended destination (e.g.,
location A'), then by moving in the requisite diagonally-aligned
direction to reach the destination. Because the desired destination
location A' is oriented at a heading of zero degrees from the
current position of load A, a default path of zero degrees may, for
example, be chosen for load A. The velocity of load A may,
according to some embodiments, be set to a default velocity, such
as one meter per second. In such a manner, the initial desired
vector 502 for load A may be determined.
[0056] In some embodiments, the vectors 502, 504, 506 may be
compared with the capabilities of the actuators to determine if the
vectors 502, 504, 506 are obtainable by system 500. For example,
the roller diverter actuators may be capable of achieving
velocities between zero and two meters per second, in one meter per
second increments, at headings as described above. Because the
desired vector 502 for load A was selected based on system 500
defaults and/or capabilities, the vector 502 conforms to actuator
capabilities (e.g., one meter per second at a heading of zero
degrees is obtainable). The vector 506 for load C is, in this
illustrative example, equivalent to the vector 502 selected for
load A, and is therefore also obtainable.
[0057] The desired vector 504 for load B however, includes both
headings and velocities that are not obtainable. In other words,
the actuators are not capable of obtaining the fractional velocity
of one and a half meters per second, and they are not capable of
movement at a heading of forty degrees. In some embodiments, the
desired vector 504 for load B may be converted to an obtainable
vector 508. The obtainable vector 508 may be, for example, set to
both headings and velocities that are substantially similar and/or
as similar as possible to those originally specified by the
programmer. For example, the obtainable vector 508 for load B may
be set to a velocity of two meters per second (or one meter per
second if rounding down is desired) and the heading may be set at
forty-five degrees. Any method of rounding, converting, and/or
altering the desired velocity and heading to obtainable velocities
and headings that is or becomes known or available may be used.
[0058] In some embodiments, the possibility of collision may be
investigated. Predicting the locations of loads A, B, and C over
time, for example, it may be determined that loads A and B are
likely to collide. In some embodiments, the velocity of load B may
be adjusted to avoid the collision. For example, the conversion of
the original desired velocity for load B into an obtainable
velocity for load B may be revisited. The conversion may be
recalculated, for example, to round the original desired velocity
of load B down instead of up. The resulting obtainable velocity of
one meter per second may therefore be selected. If analysis of
predicted future load positions using the new setting shows that
the collision has been avoided by the change, no further changes
may be required. If the collision remains likely however, either or
both of the obtainable vectors 502, 508 for loads A and B may be
appropriately adjusted to avoid the collision. In some embodiments,
only imminent collisions (e.g., collisions likely to occur within
one machine cycle and/or within a small amount of time) may be
considered. This may, for example, allow the loads to be
transported as similarly to the desired behaviors as is possible
and/or reduce computation time.
[0059] Turning now to FIG. 6, a block diagram of a system 600 for
programming load motion according to some embodiments is depicted
for use in explanation, but not limitation, of described
embodiments. Different types, layouts, quantities, and
configurations of systems may be used without deviating from the
scope or intent of some embodiments. In some embodiments, the
system 600 may be or include a computer such as a computer server,
computer workstation, PC, and/or any other type or configuration of
computational or logic device. The server 600 may include one or
more processors 602, which may be any type or configuration of
processor, microprocessors, and/or micro-engines that is or becomes
known or available. In some embodiments, the server 600 may also
include one or more communication interfaces 604, an output device
606, an input device 608, and/or a memory device 610, all and/or
any of which may be in communication with the processor 602.
[0060] The communication interface 604 may be or include any type
and/or configuration of communication device that is or becomes
known or available. In some embodiments, the communication device
604 may allow the system 600 (and/or the processor 602) to
communicate with, for example, a load transportation system such as
systems 100, 150, 300 and/or with a matrix of actuators such as the
matrix 104a-b, 154a-c described herein. In some embodiments, the
processor 602 may send signals to the matrix of actuators and/or
any of the various individual actuators. The signal may be, for
example, the control signal as described in conjunction with method
200 herein. The output device 606 and the input device 608 may be
or include one or more conventional devices such as displays,
printers, keyboards, a mouse, a trackball, etc. The devices 606,
608 may be utilized, for example, by an operator and/or system user
to program a load transportation system in accordance with
embodiments described herein.
[0061] The memory device 610 may be or include, according to some
embodiments, one or more magnetic storage devices, such as hard
disks, one or more optical storage devices, and/or solid state
storage. The memory device 610 may store, for example,
applications, programs, procedures, and/or modules 612, by which
the server 600 may allow programming of load actuators. The load
programming library 612, for example, may be a program and/or API
for facilitating and/or standardizing the programming of load
motion actuators. The load programming library 612 may be or be
similar to, according to some embodiments, the load programming
library 304 described in conjunction with FIG. 3 herein. For
example, the load programming library 612 may permit a programmer
to enter desired load behaviors to control load motions. The load
programming library 612 may, for example, convert desired load
behaviors into appropriate actuator commands and/or actions for
moving loads as desired.
[0062] The several embodiments described herein are solely for the
purpose of illustration. Persons skilled in the art will recognize
from this description that other embodiments may be practiced with
modifications and alterations limited only by the claims.
* * * * *