FOUND
|
FOUND is a system that Earth satellites can use to calculate their orbits using pictures taken by the satellite of Earth. It is being developed at Husky Satellite Lab, a CubeSat team at the University of Washington. It will be deployed and tested on HuskySat-2, the team's next mission.
If you are using Windows, you must download Windows Subsystem for Linux, and use a Linux distribution (Ubuntu by default) to run the following code.
For Linux Ubuntu/Oracle and MacOS (uses either apt-get
, yum
or brew
) obtain the required packages for this software:
sudo chmod +rwx install.sh
)sudo ./install.sh
)git clone https://github.com/UWCubeSat/found.git
)cd found
)make
)./build/bin/found
)./build/bin/found-test
)As this repository uses GNU Make to generate its artifacts, you'll need to rerun make
everytime you change the code.
The main executable, which is found in ./build/bin/found
, operates as a standard command-line based program. The usage is:
./build/bin/found <option> [flags]
There are currently two options:
calibration
: FOUND needs to know its own camera attitude, but does not find that information. Thus, this step produces a relative attitude based on a reference attitude that is always known, and one measurement of the FOUND camera's attitude. The output is to a .found
file that stores this information.distance
: FOUND then uses an image taken from space together with a .found
file to figure out the position of the image, and hence the satellite, relative to the Celestial Coordinate System (conversion to lattitude/longitude/altitude is also possible).To learn more about the different flags, execute ./build/bin/found --help
or ./build/bin/found -h
.
Here, we present a common usage for this program. After generating the binary via make
or simply make compile
, execute the command:
Here's what the flags mean:
You will notice in the your current directory the file example-df.found
has now appeared. You cannot directly read this file, but in particular, this file records a required Z rotation of -30 degrees to go from the reference to FOUND's attitude.
We can then use this calibration information to now make some position estimates of our satellite. Execute the command:
For the distance flags:
Feeding all this information, the program now analyzes the image, the calibration data and the rest of the parameters to give us its estimate, which is seen below:
This is close to the actual position, which is {10378137, 0, 0} m
. To be specific, the difference is 0.995379% in magnitude and 1339.65 arcsec in direction (this is especially good since we're using low quality edge detection).
Another thing to point out is the reference orientation, which was {190,0,0}
. The image specified in the command was taken at an attitude of {140,0,0}
, which if you remember, {190,0,0}-{30,0,0}={140,0,0}
(this doesn't general hold, since attitude "subtraction" doesn't actually look like this). This of course is important to specify, otherwise, you'll get the same magnitude, but wrong direction. Should you not want to use the calibration file to do this odd math, you can instead do the equivalent command:
Where --reference-as-orientation
tells the program to use whatever --reference-orientation
is as the orientation of FOUND.
Lastly, one thing you will not notice is that the temp.found
file has changed. In addition to storing calibration infomration, it also stores the calculated positions and their time stamps. This is important for the orbit
stage, which is currently not implemented. If you should not want to output to the same file, you can instead do:
FOUND currently has the following components/modules, which all function together produce an position estimates and orbital projections for a given satellite.
This is a "simplistic" algorithm, and simply figures out the relative attitude between our local and reference attitude. The main algorithm responsible for this is:
This algorithm is comprised of 3 main steps
After images from a satellite are received, their images are parsed to locate Earth's horizon in the image. FOUND is capable of:
The edge information is then used to evaluate the relative size of Earth in the image and find the distance of the satellite from Earth using principals of scale. FOUND is capable of:
The distance information will then be used to form a vector of the satellite relative to Earth's coordinate axes. FOUND is capable of:
This stage takes multiple vectors of the satellite at different points in the satellite's orbit to project the satellite's future path of travel. FOUND will be capable of: