I recently spent over a week in full research-promotion mode, and I’m finding it tough to switch back into research-doing mode. Coincidentally, I don’t think I’ve actually written a blog about my graduate research yet, though I’ve put descriptions of it on both my personal web site and Cornell group web site. So, I’m going to try and get it all out of my system…
Suppose you ask: Hey, Joe! What’s your research about?
Well, it’s about building Transformers in space out of Legos connected by tractor beams. Seriously. Okay, fine, they’re not “tractor beams,” more like…”tractor fields.” But other than that, not a bad description. Here’s an old-ish video version:
There are a lot of possible reasons why we ought to be thinking about building large-scale structures in space. Imagine assembling a huge space telescope out of hundreds of mirror segments, giving the telescope an effective light-gathering area of hundreds of meters and letting us peer into the dimmest corners of the Universe – from the most distant objects to extrasolar planets. Or, if we’re interested in space-based solar power (putting solar power collectors in space, where they could gather sunlight 24 hours a day without atmospheric filtering, and then beaming that power down to Earth) we would want to make the biggest collector area we can. Proponents of geoengineering approaches to climate change mitigation have been seriously considering constructing a giant sunshade to reduce solar incidence on the Earth, a short-term solution that could stave off environmental impacts while we work up longer-term fixes. And finally, if we want to maintain a long-term human presence in space – from Mars explorers to microgravity research and manufacturing technicians to paying space tourists – we will need vehicles and stations with enough room to accommodate many people, hold life support and other supplies, and provide equipment to stave off the detrimental effects of microgravity on human physiology.
All of these possible applications – any one of which would have tremendous implications for our lives on Earth – demand that we build a large structure in orbit out of smaller components. The reason for this is simple: launch vehicles can only carry so much mass and volume into orbit. Those limits are on the “stowed” size of spacecraft, so we do have the option to build craft that deploy, or unfold, out of their tightly-packed, mostly cylindrical launch configuration and into some more spindly and useful shape. For example, most Earth-orbiting satellites get their power from large solar panel “wings” that would not fit into a launch vehicle fairing unless rolled up in some clever way. There’s a lot of research these days on inflatable spacecraft, that could expand to many times their stowed size and get structural support from their internal pressure, but even those balloon-like craft cannot get indefinitely bigger than their launch envelope. Deployments and inflatables only make the volume or length of the spacecraft larger – so, for the same mass, you end up with spindlier structures, which might be fine for some applications but not others. So, in order to get the really big spacecraft, we must assemble smaller pieces to make the final system. Think of the International Space Station assembly process.
The concept of modularity is simple: build your spacecraft out of smaller pieces, each of which has only a small fraction of the functionality you want out of the entire system, such that the whole can do more than the sum of its parts. This might sound like it fits the description of anything build out of more than one component, but the key to modularity lies in the interfaces between components. Interfaces should be standardized such that you should be able to connect two modules together without really worrying about which function each module performs. So, if you want a space telescope, you build your spacecraft from a power module, propulsion module, telemetry and command module, communications module, and science instrument module. If you want a GPS satellite, you can take the same power, propulsion, T&C, and comm module, but instead of instruments have a GPS transmitter module. If you want to send the telescope to a Lagrange point, you just substitute a beefier propulsion module. Once the initial modular design is complete, development costs go way down – you just pick your parts. These modules are the “Legos” of the spacecraft. Each Lego brick has some basic function (its shape) and they have standardized interfaces (the studs). The selection of bricks, and the way in which you connect them together, determine the functionality of the final system – but you never have to worry about whether bricks of different shapes will connect, or have to mold all the bricks yourself.
A great example of a modular system is the USB architecture. If you go out and buy a USB device, it doesn’t really matter what that device is – keyboard, webcam, printer, or hard drive, you are pretty much guaranteed that there is some software that will let the device work with your computer as long as you have a USB interface and can run the software. Imagine having to buy a new computer built specifically for and around the new mouse! Such modular designs are very common in the computing industry, from IDE and ATA devices to object-oriented code to browser extensions. Even software itself: when I install a program, I don’t expect the process to involve reinstalling a new version of the operating system!
The spacecraft industry, however, has been slow to adopt modular design principles. There are some very good reasons for this! One reason involves the high expense of getting things into space and the harsh space environment (radiation is not kind to electronics). So, engineers typically want to be absolutely sure that their spacecraft will work once in orbit. They carefully design most systems around a small set of specific functions (space telescope, weather radar, GPS, …) and integrate everything together to work exactly right, subject to extensive testing. This makes sense: nobody wants to launch a multi-million-dollar satellite only to have it fail right after launch because some piece of code doesn’t play nice with some hardware component. After all, the engineers can’t just go online and download missing USB drivers like we can when our new printer doesn’t work immediately after we plug it in! A second important reason why most spacecraft are “monolithic” rather than modular designs has to do with how optimized spacecraft have to be. All these interfaces between components are little bits of mass and volume that take away from a spacecraft’s payload.
There’s an interesting (though not perfect!) parallel here with desktop Macs and PCs. External devices and third-party software aside, Macs tend to be monolithic, while PCs tend to be modular. PC users can swap out different graphics cards, DVD drives, hard disks, RAM, CPUs, Ethernet cards, et cetera. That makes PCs, typically, cheaper than Macs for comparable functionality, upgradeable and expandable when any new functionality comes out, and gives end users the ability to replace old or broken components – even build their own computers – without specialized training or equipment. However, that also tends to make desktop PCs larger in form factor than Macs and potentially less reliable, as PC software must allow for many more possible combinations of hardware. Right now, spacecraft tend to be like Macs because the spacecraft industry is risk-averse and already must deal with high costs. I want them to be like PCs to bring costs down, allow upgrades, and introduce the potential for more functionality.
Modular spacecraft do exist. Great examples are the Hubble Space Telescope and International Space Station. The Hubble was built with modular instrument bays inside its structure; this allowed astronauts on the five HST Servicing Missions to open up the bay doors, pull out the old modules, and slot in new ones without having to disassemble the whole telescope on a spacewalk. That design decision has kept Hubble operating and returning stellar (ha!) imagery for almost twenty years. The Space Station was designed and built with the idea that the components could be brought into orbit and assembled using the Space Shuttle as a work platform, and so we end up with Shuttle-cargo-bay sized modules that astronauts, working with the STS and ISS Canadarms, pieced together. Each module has some set of functions (laboratories, living quarters, nodes, airlocks, truss segments, solar panels, logistics, …) and some of them have even been disconnected from temporary berths and moved to different locations during the ISS assembly process.
What would make modularity easier to achieve on spacecraft is a better way to build the interfaces between components. Something that doesn’t require a lot of mass and volume on the ends of the modules, and doesn’t require a lot of finesse from astronauts or robot arms to assemble. We get this by, essentially, abstracting the interface away: transfer data and power wirelessly between modules, and you don’t have to have any connectors. More radically than that, though, we want to have an interface that works by some principle that ties the dynamics of neighboring modules together (a general statement of what a mating adapter or truss does) but without physical contact.
This is kind of like spacecraft formation flight – in which a swarm of small vehicles form a sort of “virtual structure,” perhaps with a time-varying shape, that lets them perform some function as a group. For example, a space-based interferometry mission like the proposed Terrestrial Planet Finder consists of a cluster of spacecraft that must hold a particular shape and cooperate their motions and actions. All of this usually gets accomplished by extensive feedback control. However, our idea is that we can come up with technological solutions to those challenges, rather than control-based solutions, by using force-field interactions to establish passive dynamic relationships between spacecraft modules.
The Electromagnetic Formation Flight (EMFF) and Coulomb Formation Flight (CFF) projects at MIT and UC Boulder, respectively, are similar to our approach in that they use attractive and repulsive forces between spacecraft to keep them in some desired configuration. However, they must use control to stabilize the interaction, or else the formation will either collapse and collide or fly apart. Our choice of physics is magnetic flux pinning, which gives spacecraft passively stable dynamics when they get very close to one another.
Magnetic flux pinning is an interaction between a magnetic field and a type II high-temperature superconductor. “High temperature” is very relative here: these materials have zero electrical resistance below a critical temperature that is often around 80-100 Kelvin, liquid nitrogen temperatures, instead of 1-5 K, liquid helium temperatures. The favorite in our lab is yttrium barium copper oxide (YBCO), one of the first HTSC’s discovered.
When the YBCO is above critical temperature, it’s just a piece of ceramic. We can place a permanent magnet near it and the magnetic field will happily penetrate the YBCO. But when the YBCO cools, interesting things start to happen. The magnetic field starts to induce currents – and those currents have magnetic fields of their own. Since there is zero electrical resistance in the superconductor, the fields from all those little supercurrents exactly oppose the field of the magnet. But YBCO is a special type of superconductor, laced with impurities – little regions of nonzero resistance. That leads to a far more subtle interaction than the YBCO simply repelling all applied magnetic fields.
What happens is that the YBCO sort of tries to maintain the magnetic flux distribution that was present within its volume when it cooled. The net effect is that the YBCO exerts a restoring force on the magnet, pushing it back to the same position and orientation it had when the YBCO temperature crossed below critical. The interaction provides nonlinear stiffness and damping, effects which get stronger as the magnet and YBCO get closer together, and the equilibrium position of the magnet and superconductor depends on their initial positions. All this comes without any power or control: all you need to do is keep the superconductor cool. Away from Earth’s reflected light, that could be done with a sunshade – and beyond about the orbit of Mars, the superconductors would be below critical temperature without any shielding at all. The magnet and YBCO stick together passively, with a several-centimeter gap between them.
For my first couple years of graduate study, I spent my time characterizing this flux pinning interaction for spacecraft applications. We needed to know how stiff the interaction is in all six rigid-body degrees of freedom (three translations and three rotations), simultaneously. First, we did quasistatic stiffness measurements of a magnet pinned to 19 tiled hexagonal pieces of YBCO. We used a (supposedly precision) robot arm to make small displacements and rotations of the magnet, and a 6-degree-of-freedom load cell to measure all the restoring forces and torques simultaneously. From that data, we estimated the 6D stiffness matrix of the pinned magnet and YBCO. Later, we did dynamic measurements: we hung a magnet from a long pendulum and pinned it to an upright, much higher-quality YBCO disk next to the pendulum’s equilibrium position, excited vibrations of the pendulum by feeding white noise to an electromagnet coil, and tracked the response of the flux-pinned pendulum by motion capture. That experiment gave us both stiffness and damping information, and we used the pendulum experiments to explore how shaping the flux-pinned magnetic field affected the macroscopic properties of the magnet-YBCO interaction.
I was able to determine that a permanent magnet flux-pinned to a YBCO disk can have stiffnesses up to hundreds of Newtons per meter when they are separated by a centimeter or so at the time of field-cooling. The stiffness drops off exponentially as the field-cooling separation increases, out to a maximum range of 7-9 cm for the magnet and superconductor I tested. That’s not exactly the stiffness of a steel girder, or even of a truss segment on ISS, but it is high enough to withstand the typical perturbation forces in the space environment: gravity gradient, solar pressure, atmospheric drag, and others. So flux pinning could be enough to hold multiple spacecraft together into a single structure, passively, once they come within close range. We can also change the stiffness and damping of the interface, by design, if we place metals that interact with magnetic fields near the YBCO.
Last summer, I participated in a NASA microgravity flight that grew out of this research. Our team devoted one of our two flight days to an attempt at testing the 6DOF stiffness of a CubeSat-sized spacecraft mockup flux-pinned to a superconductor in a nitrogen-filled 3U-CubeSat-sized Dewar. That was our first microgravity flight, and the lack of experience really impacted our ability to get good data. Which is to say, we didn’t. Get good data, that is. We did see low-stiffness pinning of the CubeSat to the Dewar, but weren’t able to get a measure of that stiffness. Now that we have that experience under our belts, though, we should have a much better-designed experiment this coming summer!
How many times has this happened to you: you build a multimilliondollar spacecraft, drop a few tens of millions of bucks on a launch, get it into orbit, and suddenly you smack your forehead and cry, “Man, I wish this spacecraft could do X?” Or maybe your spacecraft just up and broke, and you’d like to fix it. Or maybe it’s done with its mission, but it still has propellant and functional systems, and you’d like to do some more stuff with it, but the payload isn’t any good for what you’d like now. In all three cases, it’s time to build a new spacecraft!
Spacecraft are typically one-shot vehicles, built for a very specific function. But if we consider modular spacecraft, as above, we can start to consider changing functionality by adding, removing, and swapping out components – or even just by altering their physical layout. A couple examples of current vehicles that change functionality by changing shape might be the F-14 Tomcat – a “swing-wing” aircraft, which uses different wing shapes to optimize its performance at super- and sub-sonic speeds – or the V-22 Osprey, which changes shape to go between “helicopter-like” flight and “airplane-like” flight. A more dramatic example is the Terrafugia vehicle that transforms between a road-drivable “car mode” and FAA-compliant “airplane mode.”
In the space world, there are also a few great cases in which the craft experienced some change in functionality as a result of changing components or component layouts. One is the Hubble Space Telescope, which has had several servicing missions, each of which added or changed parts of the spacecraft. Another is the International Space Station. Take a careful look at this animation of the assembly process, and you will notice not only steps in which components get added to the station, but steps in which a component disappears from one part of the station and reappears in another. What’s going on in both cases is a process of reconfiguration – a generalized word that encompasses adding things, removing things, and rearranging things.
Both of these examples involve lengthy and complicated maneuvers with dexterous robotics and human spacewalks. When engineers think about reconfiguration, if they think about reconfiguration, they typically think about the control process necessary to accomplish such gymnastics. Even the most reconfigurable space systems envisioned, such as the SPHERES project at MIT, view reconfiguration as a process of simultaneously undocking the modular components from their current configuration, maneuvering them to their target positions and orientations, avoiding collisions with all the other maneuvering vehicles, and then docking again in their new configuration. That’s a tremendous control problem, and the usual solutions generally involve many vehicles sensing their state very accurately and communicating it near-perfectly to each other. If the communication gets garbled, a sensor develops a bias, or an actuator goes wonky, the risk of modules colliding and ruining the whole system skyrockets.
For the last year, I’ve been working on an approach to reconfiguration that involves picking the system kinematics so that the physics of the problem naturally drive and regulate the reconfiguration maneuvers in a very power-efficient and reliable way. “Kinematics” are the set of paths in space along which a set of bodies can move – usually defined by system joints. For instance, a typical door can swing open and closed, but cannot move sideways – likewise, a sliding door can translate in and out along one line, but cannot rotate. The question I’m asking boils down to this: Can we take a modular space system and get it to reconfigure by changing the way the modules are allowed to move with respect to one another?
What inspired us to look at this question was the sight, common in our lab, of a cylindrically symmetric magnet flux-pinned to a superconductor. The magnet’s axis of symmetry allows it to act as a revolute joint – a hinge – with one rotation degree of freedom about its axis and stiffness in all other degrees of freedom. But in addition, if that symmetry gets spoiled – perhaps by an electromagnet or another permanent magnet – then the free rotation gets locked out with some stiffness. So, with flux pinning, we actually have a way to change joint kinematics on the fly, simply by changing magnetic fields.
Now, if we have a modular space system held together by flux-pinned connections, we can specify whether each interface is completely fixed, or has some degrees of freedom. We can reconfigure the vehicle by releasing some of those degrees of freedom. If the spacecraft is in orbit around a planet, or near the radiation of a star, or in a magnetic field, or spinning, then there will be some set of forces and torques on the individual modules making up the craft which will push the craft – bending it along the kinematic pathways we specified. Eventually, the modules will naturally tumble down into an equilibrium. Then we can pick a new set of kinematics and allow the spacecraft to tumble again. And again, and again, and again…. Once it gets to the configuration we want, we have the spacecraft lock out its kinematics. So, we could have spacecraft modules “walk” around to new locations without ever disconnecting them from the rest of the spacecraft, or even have the entire system move like a mechanism with gears, chains, and linkages.
Some interesting features of this method of reconfiguration are that it doesn’t require any power input (except when the kinematics change) and the spacecraft doesn’t need active control when it is moving between these intermediate stepping-stone configurations. We let the natural physics of the system determine how the spacecraft moves. That lets us enforce collision prevention – and other undesirable behaviors – simply by choosing kinematics that we know will lead to safe motions. Computers on board the spacecraft need only keep track of the possible equilibrium configurations and the sets of kinematics that lead between them; then, when the spacecraft gets a command to reconfigure, it does a graph search to figure out which intermediate steps to go through. Each configuration is a “safe step” – since we let ambient forces in the space environment drive the process, each set of dynamics is passively stable. If something breaks, it just gets stuck at the equilibrium configuration where it is and ground controllers can troubleshoot the problem from a stable point.
Right now, I’m working on some of the math behind this reconfiguration stuff; I’m trying to develop algorithms that a spacecraft could implement. In the near future, my lab will be trying out these algorithms on an air-levitated testbed of nanosatellite-scale vehicles. We’re also working up to more involved microgravity experiments that will include several vehicles with flux-pinned interfaces maneuvering around one another. We recently ordered a cryocooler to keep our superconductors superconducting, and my labmates have started machining parts and designing electronics. Further afield, we may try to get an actual CubeSat designed and built to demonstrate flux pinning on spacecraft.
In general, all this flux pinning stuff could evolve into a technology that helps make in-orbit modular spacecraft assembly much easier, and gives engineers more options to reconfigure existing systems. Imagine spacecraft that you could add new capabilities to whenever a small-satellite launch comes up, spacecraft with “recyclable” parts that can be repurposed into entirely different systems at the end of their designed life, or spacecraft that can split into several different sub-missions.
For instance, imagine sending a probe to Jupiter, having it leave some of its instruments in orbit around Europa, pointing half of the spacecraft at Jupiter and half at Ganymede as it swings around, picking up the Europa instruments on another flyby, and eventually receiving some extra fuel tanks, replacement computer parts, and upgrade instruments from Earth. Or, imagine building a spacecraft out of power modules, fuel tanks, crew habitats, centrifuge modules, and lab modules in Earth orbit…sending up a propulsion modules to blast the whole thing to Mars…and having astronauts go down to the surface in lander modules, leaving the habitats in orbit. Imagine supplying the orbiting habitat with more fuel, propulsion, and habitat modules on subsequent launches. Imagine building up an orbital station and return vehicles at the same time as we build up a ground station. And if there’s any problem, we can reconfigure the spacecraft to repair it.
I like to think that technologies like this will help us expand our exploration out into the Solar System. And in the meantime, I’ll get a Ph.D. out of it!