Basilisk Release Notes¶
We are very excited by the great capabilities that this software already has, and plan to be updating this
software regularly. There is some documentation in terms of Sphinx generated HTML documentation, but also
documentation within the code, and several Basilisk modules that are math heavy have LaTeX’d documentation
folders as well. Best place to start is to run the integrated tutorial scripts inside the
folder, described in Integrated Example Scripts. To learn how to use and program Basilisk, see Learning Basilisk.
This next generation of Basilisk 2.0+ introduces a new messaging system and file architecture. As a result using BSK2 requires upgrading existing Basilisk simulation scripts (see Migrating Basilisk Scripts from Version 1.X to 2.X) and C/C++ modules (see Migrating Basilisk Modules from Version 1.X to 2.X) to be used with 2.0 and onwards. All unit test and example scenario scripts are updated and form a good source for examples on how to use the new software framework.
new Module: forceTorqueThrForceMapping to map commanded forces and torques to a set of thrusters
updated Vizard documentation on the setting flags
added power and fuel tank modules to the BSK_MultiSatDynamics class.
improved the DV calculation of the spacecraft state output message by integrating the gravitational acceleration using the current integration scheme rather than using a first order approximation.
updated install script to be able to have
opencvagain. Something changed with the
conanrepo that broke this.
updated BSK install instructions on the M1 Apple Silicon platform as Basiliks can now run natively
updated Module: vizInterface to support Vizard 1.9.1 and the ability to visualize generic sensor types and antenna communication status
updated Module: ephemerisConverter to also convert the planet orientation states, not just the translational states
added a Module: planetNav module that adds noisy to planet ephemeris, similar to simpleNav.
added Module: attRefCorrection to adjust the reference attitude by a fixed rotation
added scenarioAttitudePrescribed to illustrate how to prescribe the spacecraft orientation
added a new magnetic RW momentum dumping example in scenarioMtbMomentumManagementSimple which illustrates using the above new MTB related modules to change the momentum, as well as drive the nominal momentum to a desired value using Module: rwNullSpace.
created a new architecture based on
MultiSatBskSim. It exploits the new messaging system to create a simulation with any number of spacecraft in a highly modular way. It allows for the addition of homogeneous or heterogeneous satellites without having to hard code their properties into a single dynamics or FSW script. It will be a foundation to test the upcoming multithreading capabilities of Basilisk.
added a new FSW module Module: formationBarycenter. It computes the barycenter’s position and velocity of a swarm of satellites. This barycenter can be either computed with cartesian coordinates (usual mass-weighted average), or using orbital elements weighted average. Will be useful for spacecraft formations defined around the barycenter of the swarm and not a chief spacecraft.
enhanced Module: locationPointing to support the target input msg being either a location message or an ephemeris message
updated install notes to ensure Linux python3 developer libraries are installed, and to ensure that
wheelpackage is installed along with
created Module: smallBodyNavEKF to simulate autonomous navigation in proximity of a small body
added C++ Module with C-Wrapped Output Message to the section on learning how to create BSK modules
updated Module: locationPointing to support 3D rate damping as an option
fixed issue in Module: waypointReference to interpolate between waypoint
nand shadow set of waypoint
n+1when these are described by opposite MRP sets. Updated documentation and corrected typos in scenarioAttitudeConstraintViolation.
Added representative scenario scenarioDragRendezvous demonstrating attitude-driven differential drag formation flight
Added new scenario scenarioDragSensitivity showing how to do a differential drag spacecraft control sensitivity analysis
updated Module: celestialTwoBodyPoint to account for a case where the celestial objects are in opposite directions
safeAsin()which ensure that arguments are clipped to be within and including -1 and 1
updated Module: dataFileToViz to allow the
Reset()method to be called multiple times. If a data file was already opened, then it is closed before the next data file is opened.
updated Module: groundLocation to also output SEZ coordinates, as well as range, azimuth, elevation, south, east and zenith coordinate rates. These coordinates are always computed regardless if a spacecraft is visible to the target. Check the
hasAccessmessage variable to see if the spacecraft is visible.
updated the OpNav examples script to set a black sky background in the Vizard camera images
added a new Python method
isSubscribedTo()to query if the input and output messages between two modules are connected
updated Module: gravityEffector documentation to properly pull in the RST documentation and link to the PDF describing the gravity models
setAllButCurrentEventActivitymethod in SimulationBaseClass to work with multiple satellites. We can now add an index at the end of each event name that guarantees only events with the same index are affected. The
useIndexflag must be set to
added new magnetic torque bar effector in Module: MtbEffector
added new FSW module to control the RW momentum using MTBs in Module: mtbMomentumManagement
new tutorial example script scenarioMtbMomentumManagement
updated Module: rwNullSpace to have an optional input message of desired RW speeds. These desired values default to zero so the module retains the earlier behavior if this optional input message is not connected.
added two lines in Module: waypointReference to normalize the attitude quaternion that is read from file.
updated Module: spacecraft
Reset()method to write all spacecraft and effector state output messages with their initial values. This way these output messages are correct as already as calling the
fixed an issue that could prevent
.subscribeTofrom a C++ to C wrapped message object to not function properly.
new scenarioGroundLocationImaging example script that demonstrates the aforementioned module integrated into a full on-board data system.
new Module: etSphericalControl module that controls the relative motion of the Electrostatic Tug
new scenarioDebrisReorbitET example script that demonstrates using the Electrostatic Tug and the Multi-Sphere Method
updated Module: groundLocation to always compute the elevation, range and azimuth information, even if the satellite does not have access. The output message variable
hasAccessprovides access information.
added scripting support for Vizard 1.8.4
updated scenarioGroundLocationImaging to demonstrate the use of the new
new Module: locationPointing module to do 2-axis attitude control which aligns a body-fixed vector to a desired inertial location
new scenarioAttLocPoint example script how to point a spacecraft body axis towards Boulder
updated Module: inertial3DSpin to make the attitude input message optional, updated documentation to be RST only and more descriptive of the associated math, and changed the module variable
enables the message
recorder()module to function if the message structure contains structures itself.
make the build system compatible with Python 3.8 and higher on Windows
fixed custom RW support method in
fixed new C++20 related compiler warnings
new waypoint reference module in Module: waypointReference. It can be used to read an attitude maneuver from a set of waypoints on a text file, likely generated outside Basilisk.
updated Module: gravityEffector to allow the planet message module (
planetEphemeris) to be called either before or after the
spacecraftmodule update is called
Fix a range of long-standing HTML Documentation build warnings and issues
Renamed the messages
OpNavLimbMsgPayloadto avoid sphinx naming conflicts
unified the identical
added a new RW encoder simulation module Module: encoder
Fixed a bug in the onboardDataHandling module that allowed for data that did not exist to be downlinked
changed default behavior of
python3 conanfile.pyto automatically compile the Basilisk project. This was a common stumbling point for new users. The build flag
--buildProjectcan be used to enable automatic compiling or not. For developers making new code this should likely be set to
Falsewhen configuring the project.
Fixed a bug in SimulationBaseClass that prevented creating an event with multiple conditions
ShowExecutionOrder()method to SimulationBaseClass to print to the terminal the order that the process, tasks and modules are executed.
ShowExecutionFigure()method to SimulationBaseClass to create a figure illustration the execution order.
added a new Seeing the Order of Process, Task and Module Execution web page on how to visualize the BSK process, task and module execution
bskSimexample scenario showing how to alternate between flight modes in scenario_AttModes
provide scripting support for Vizard 1.8.2 release
Added the ability to clear the data of a message recorder using
Fixed a rare issue where RW data didn’t stick
Fixed an issue subscribing to a C++ wrapped message object from python
Cleaned up documentation on using datashaders and bokeh to interactively plot large simulation data sets. The script scenarioAnalyzeMonteCarlo is updated to discuss the particular challenges in running this datashader example of plotting data.
enable Monte Carlo
pytesttest scripts to run on macOS if Python 3.9 or higher is used
fixed an issue that prevented subscribing to a C++ msg from python
src/utilities/makeDraftModule.pyscript that is able to create a draft module template given
list of module input or output messages containing
message variable name
message payload definition
message type (ie.
The script then generates either a C or C++ module folder that contains the elemental
*.icode which compiles into a functioning prototype module. Also included are the module
*.rstfile which provides the basic description and message table (including hyperlinks to message payload type and message description), as well as a functioning python unit test that loads the module, connects zero’d input messages and sets up output message recorders. The coder can then take this draft module code and modify to achieve the desired functionality. The page moduleTemplates discusses how to use it and provides to 2 sample auto-generated modules that get created inside
new thermal motor module in Module: motorThermal. It it be used to simulate the temperature of a RW motor.
New message system with strong type checking. You now get a much simpler method to create message objects, how to connect them within python, create stand-alone messages in python, etc. If you engage with a message of the wrong type you get immediate compiler warnings.
New C++ based message recording system that is much faster than the older python based message logging
New messaging recording now stores the message data separately from the time a message was recorded and the time the message was written
Removed the arbitrary distinction between
INTmessages. All messages are now available to all modules
Both C and C++ based message interfaces are now auto-generated when running
New ability to create zero’d message structures in the modules
Seamless message subscribing in Python across all modules types (C, C++ or Python)
New generic RW device type in simIncludeRW and updated the support library to work with BSK2
Updated simIncludeThruster to work with BSK2
Updated fswSetupRW to work with BSK2
Updated fswSetupThrusters to work with BSK2
Update Basilisk module documentation that shows all input and output message variables, their type and explanation
Cleaned up the Basilisk src folder layout by moving all Basilisk architecture support files to src/architecture. This impacts some include statements
Made the C/C++
#includestatements all relative to src to make it easier to find the associated files in the source code
Updated message names to now all comply with the Basilisk message naming convention. See Migrating Basilisk Scripts from Version 1.X to 2.X for a table of how some message names have changed
Updated vizSupport to work with BSK2. It is now much easier to include RW, thruster and CSS devices. Further, the simulation gravity bodies don’t have to be explicitly provided to the
vizSupport.enableUnityVisualization()method. Rather, these are pulled from the spacecraft object directly.
Module: reactionWheelStateEffector is updated where the list of RW configuration parameters are now linked from python, not copied. As a result it is now possible to stop the simulation and change RW parameters on the fly, emulating a failure with a physical change in the RW mechanics.
Created several instructional pages in the Quick-Start documentation folder. The examples folder has moved to the Quick-Start guide as well. The new quick start guide now discusses
how to write Basilisk python simulation scripts
how to write C++, C and Python modules
Added installation instructions to run Basilisk on a computer with the Apple M1 processor
added Module: spacecraftLocation module to allow checking for satellite to satellite line-of-sight access
maximumRangean optional variable in Module: groundLocation
spacecraftDynamicsto Module: spacecraftSystem, and renamed the associated
spacecraftPlus()to be now simply Module: spacecraft
renamed rwMotorVoltageInterface to Module: motorVoltageInterface. This motor model can be used for both RW and hinged panel devices.
added support to creating custom gravity bodies to simIncludeGravBody. Including support to have custom gravity bodies shown in Vizard as well. The example script scenarioCustomGravBody provides an illustration of this functionality.
Added support and expanded installation instructions making use of virtual environments
Added support for
Locationscripting in Vizard 1.7.1
Added a new documentation page discussing how to launch Vizard from the command line and what optional arguments are available
The protobuffer interface files are now automatically created from
src/utilities/vizProtobuffer/vizMessage.protowithout having to manually run the
protoccommand each time the protobuffer message definitions changed.
centerRadiusCNN is now supported on all the platforms
Support Terminal Progress bar while running a Basilisk simulation
Improved the build system to re-swig the module if the dependencies have changed. This avoids having to do a clean build or manually deleting the swing python files from within
All unit test cases are compatible with windows platform
Added scripting support for Vizard 1.7.0
orbitalMotionpython and C libraries to include the new methods
Updated Module: dualHingedRigidBodyStateEffector to support an output message of the panel angular states, an output message of the panel inertial position and attitude states, as well as upgrading the module to support
Updated Module: vizInterface to support scripting of new Vizard 1.6.1 features
Fixed an issue where some Sim-FSW interface messages could not be written to from the Python layer
Fixed an issue that prevented the
opNavbuild mode to compile the OpenCV related libraries on macOS with Xcode 12 installed
updated Module: hingedRigidBodyStateEffector to
write the panel angle and angle rate output message
write the panel inertial and position states as an output message
updated document to make use of RST format and specify module input and output messages
avsEigenSupport.hto add new methods
spacecraftPlusto allow the attitude motion to be prescribed through an optional input message of type
fixed sign issue in Module: simpleSolarPanel
support Vizard 1.6.0 scripting
Provide support of Vizard 1.5.1 scripting
Updated conan to 1.29.2 to address issues building with opNav and support xcode 12
Disable freetype for windows because of opencv build issues.
update the macOS dependency to use either
conan>=1.28. The later resolves the linking issues that
conanhad on macOS. Other platforms can use
vizInterfaceto support the latest features of Vizard 1.5, including the ability to show relative trajectories
updated scenarioFormationBasic example script to show more general orbits and the use of the scientific camera sensor scripting
On Windows the new build system now builds Module: vizInterface
CMakeLists.txtfiles that are no longer needed
Improved the build process for Linux such that
opNavrelated modules are available again in Basilisk python scripts. Thus Linux users can use 1.8.x onwards and still use these enhanced features. The similar issue on the Windows platorm is not resolved yet.
Updated setup instructions to remind the user to delete
.conanfolder if upgrading from a BSK version prior to 1.8.0
Added support for Vizard 1.4.1 that allows setting default and thruster group plume colors. The built-in thruster pluming length can be now be custo scaled as well.
Added a video gallery page to the Vizard documentation section
Updated Module: dataFileToViz to include the ability to read thruster force values. The spacecraft can have multiple thruster sets, and this works for multiple spacecraft as well. See test_dataFileToViz for an example on how to set this up.
Updated Module: dataFileToViz to include support for reaction wheel data.
Updated documentation and
CMakeLists.txtto required 3.14 or higher
openCVis included to avoid false Xcode warnings about the library not being installed
Added Module: centerRadiusCNN for doing CNN-based image processing as well as a pre-trained model (read by the module) that allows to extract center and apparent diameter from Mars images. Note that for now this module is only built on macOS systems. As we are able to test on other platforms we will include it there too.
Added scenario_CNNAttOD to illustrate the use of the CNN-based image processing
Added support for Vizard v1.4.0 scripting
Added a new folder
externalTools/fswAutothat contains externalTools to migrate BSK simulations and modules to C-code
Added a new Module: albedo which can simulate the average or data driven albedo of a single planet. This works also if multiple celestial bodies are setup.
Made the RST HTML document creation work on Windows as well (see Creating the HTML Basilisk Documentation using Sphinx/Doxygen)
Fixed the conan issues where the IDE only saw the Debug path of the Eigen library, not the Release path. This gets rid of false warnings in Xcode that
<Eigen/Dense>could not be found.
updated the installer script to automatically set the
conanrepo information. This removes one more step from the installation process.
updated Module: imuSensor to initialize all class variables in the constructor
fixed a data frame issue in Module: groundLocation
first iteration of the CMake refactor completed. The refactor updates the project CMakeList to
conform with more modern CMake practices,
allow developers to include custom dependencies on the module level with Custom.cmake files,
refactors existing SWIG interface files to generate significantly smaller _wrap.c(xx) files,
generates single libraries for GeneralModuleFiles rather than re-including, re-wraping, and recompiling those files at the module level. The latter two changes provide significant improvements in build time.
The need for folder module
__init__.pyfiles has been removed. If local python support files should be included in the swig’d module, they can be included in the module
*.ifile using something like
The support files in
_GeneralModuleFilesare now compiled into a library with the parent folder name. Thus, the
src/simulation/dynamics/_GeneralModuleFilessupport files yield a swig’d library
Cleaned up small RST documentation issues
Updated the install process to check automatically for required python packages. They are not available, then the user is prompted to install for user, for the system or cancel.
Updated the install process to allow a user selectable checking of all optional python packages through
fixed memory issue in the Module: camera
Updated the HTML documentation process to provide tools to clean out the auto-generated documentation, as well as to open the HTML output from the command line
Added the ability to shift the HSV or BGR colors of Module: camera
Updated Module: vizInterface to allow the user to set the Vizard direct communication protocol, host name and port number.
fixed an issues in simIncludeGravBody where the method
unloadSpiceKernelshad the order of the spice package name and the spice path reversed 😟
New Module: dataFileToViz that reads in spacecraft simulation states from a text file and converts them into BSK messages. For example, this allows Module: vizInterface store the simulation data into a Vizard compatible manner.
Updated Module: spiceInterface to allow for optional overriding the IAU planet frame with custom values
Updated Module: vizInterface to allow setting
showDataRateDisplayflags for Vizard files supported in Vizard v1.3.0
hot-fix of an issue compiling Basilisk on Windows. A
#define _USE_MATH_DEFINESwas missing that Windows expected, but Unix systems didn’t need
updated scenarioFormationMeanOEFeedback and scenarioFormationReconfig to increase the orbit altitude to not hit the Earth. Also, added code that can be enabled to record the simulation parameters for Vizard.
updated Module: vizInterface to support the latest Vizard v1.2.0 features. You can script that the spacecraft and/or celestial objects are shown as sprites if they become very small. This makes it easier to see where satellites are in a constellation or formation, as well as where Earth is if orbiting about Mars
automated how the release number is pulled from a single txt file now
new spacecraft formation flying control Module: meanOEFeedback that implements a mean orbit element feedback control law
updated documentation of Module: cModuleTemplate to show how to make much simpler lists of module messages using the
new spaceraft relative motion control Module: spacecraftReconfig that implements an orbit element based impulsive feedback control strategy. The control is implemented with a thruster model and an attitude guidance message is used to point the spacecraft in the correct direction.
new example scenario scenarioFormationReconfig illustrating the use of the new impulsive relative motion control module
Added the ability to detect if a satellite is visible to a ground location in the new Module: groundLocation
Added support to script Vizard to specify spacecraft, planet and actuator labels
Added Module: spaceToGroundTransmitter which simulates transmitting data from space to an antenna at a ground location.
Updated the definition of the variable noiseMatrix in
gaussMarkov.h, and PMatrix in
Fixed a transformation issue in
cArray2EigenMatrix3d()has to deal with both column and row dominant matrix formulations. This only got used in scenarioCSS and the issue was offset by an issue in
setUnitDirectionVectorWithPerturbation()that compensated. Now, all is as it should be.
Removed unneeded instances of using
unitTestSupport.np2EigenVectorXd()when setting the spacecraft states
Many new Basilisk scenarios illustration interfacing with Vizard to simulate opNav cases:
scenario_DoubleOpNavOD uses the two OpNav methods at once
scenario_faultDetOpNav implements two OpNav methods and employs a fault detection
scenario_OpNavAttOD uses the OpNav FSW stack to perform both pointing towards the target planet
scenario_OpNavAttODLimb uses a Canny transform to extract limb points
scenario_OpNavHeading point the spacecraft visually towards a target
scenario_OpNavOD only performs the orbit determination component
scenario_OpNavODLimb only performs the orbit determination component using the Limb based method
scenario_OpNavPoint only performs the pointing component
scenario_OpNavPointLimb only performs the pointing component using the Limb based method
scenario_LimbAttOD performs a longer simulation using the limb based method
scenario_OpNavAttOD performs a longer simulation using the Hough transform method
Add scripting support for the customGUIScale parameter
All instrument cameras are now specified through fieldOfView, not sensor size and focal length
Added scripting support to turn on camera boresight line or HUD frustum
Made instrument cameras not render images to the home folder by default by setting renderRate to zero by default
Fixed the long-standing issue of not being able to run
pyteston Windows from
src, but it only ran from within sub-folders of
src. Still recommended to run on Windows multi-threaded
pytest -n XXXusing
temporary fix for opencv not finding conan gflags for opencv sfm lib on windows. See the discussion at https://github.com/conan-community/community/issues/210
Updated Module: cModuleTemplate to include a message I/O figure and move it’s message definition to
Updated the documentation of mrpPD to the RST format
Updated the documentation of mrpSteering to the RST format
At long last, 🍾, created Module: GravityGradientEffector which can simulate the gravity gradient torque acting on a spacecraft due to the gravitational influence from one or more planets.
Create a new example script scenarioAttitudeGG that illustrates the use of the gravity gradient effector
GravBodyDataclass to now register the planet position, velocity, orientation and attitude rate states. This allows other effectors, such as the gravity gradient effector, to have access to the current planet states at any time step.
added Module: ReactionWheelPower which can compute the electrical power consumed by a reaction wheel device
added new example script scenarioAttitudeFeedbackRWPower that illustrates doing a RW-based attitude maneuver and tracking the RW power and net battery capacity left.
BCT_RWP015RW model template to the
Fixed an issue running test_reactionWheelStateEffector_integrated using Python 2
cmakeissue where the module renaming from
Updated documentation for Module: eclipse module with new RST format
Updated Module: cModuleTemplate documentation to show how to add equation numbers, cite equations, do bold math variables and cite a figure caption.
Updated Module: reactionWheelStateEffector and Module: vscmgStateEffector such that max speed and max torque are consistently initialized to -1. A negative value was supposed to turn of speed and torque saturation, but this wasn’t consistenly applied.
Updated Module: reactionWheelStateEffector such that the RW state output message was not hard-coded and un-changeable. Otherwise a BSK process could never have multiple spacecraft being simulated. Now, the rw effector
ModelTagis added to the beginning of the output message. This auto-generate method of message output names is avoided if the user sets the vector of output names from Python during the simulation setup. Note: Any prior BSK script that was logging the old auto-generated RW state messages will need to update the msg name now to work again. See Basilisk Known Issues for more information.
Major enhancement to Module: vizInterface where now multiple spacecraft can be added. You can create a list of spacecraft where Module: vizInterface relies on common naming rules to find the right messages, or specify the messages for each spacecraft directly. This is demonstrated in scenarioFormationBasic. For now multiple craft with RW actuators are supported. Multi craft with thrusters will need to be added later.
New spacecraft formation flying scenario scenarioFormationBasic where 3 satellites are flying 10m apart in a lead-follower configuration. Each has a different number of RWs. This scenario is a nice script to demonstrate the new multi-spacecraft support in About Vizard.
added link to Basilisk facebook page to Sphinx-based documentation
made the html documentation compatible with dark mode on macOS, iOS and iPad OS browsers. If the user sets the system interface to dark mode, then the dark version of the web site is shown automatically.
added a fix to cmake to get around a
conanissue we are seeing on a Linux system
added Vizard scripting abilities to control the new spacecraft camera view panel behaviors
added Vizard scripting abilities to specify custom CAD OBJ models to replace the default satellite shape
updated Module: sunlineSuKF with some general improvements
cmakefile to make BSK be portable across Linux systems
changed the bskLogging level names to make them unique. This avoids potential variable name conflicts, especially on Windows.
updates to the Monte Carlo controller and plotting algorithms to make use of better use of Pandas and Datashader
Added a message to the heading estimator in order to perform OpNav pointing
added a general message to the Sphinx HTML documentation landing page
updated the Basilisk Module Checkout List with updated information and expectations
added a new help page on Forking from the Repository and Making a Pull Request
Added a fault detection module for optical navigation
Added camera module to own the message and to add corruptions to images
Added a new support document Making a New C/C++ Basilisk Module on getting started writing BSK modules
Added a new support document Using Sphinx to Document Basilisk Modules and Folders
Updated the Welcome to Basilisk: an Astrodynamics Simulation Framework page to include Basilisk highlights
Made sure the Monte Carlo unit tests didn’t leave any temporary data files behind
Added new helper functions to the RW and Thruster factory classes to return the equivalent FSW configuration message. Updated scenarioAttitudeFeedbackRW simulation script to illustrate how to use such a helper function.
Added a new Basilisk logging system called bskLogging. This allows modules to print information with a variable verbosity level
Include a new example scenario scenarioBskLog to illustrate how to use variable verbosity BSK notices
added the ability to include the unit test python files, along with their documentation, within the sphinx html documentation
updated Vizard live streaming documentation
updated unit test templates to have better formatting of the html validation report obtained with
exclude some un-needed files from the html documenation
general sphinx documentation related fixed and enhancements
small fixes to the new HTML documentation
correct the path includes in Monte Carlo Integrated tests
MRP_Steeringmodule documentation to include plots of all test cases
Update template illustrating how the validation accuracy can be recording in the
Created a new method in
pullMultiMessageLogDataThis is much faster in pulling the data log from multiple messages at once.
It is no longer necessary to call sim.TotalSim.terminateSimulation() at the beginning of Basilisk scripts. This call has been moved to the SimBaseClass constructor and removed from scripts in the repository.
A new module in the environments directory, SolarFlux, provides the solar flux value at a spacecraft location including (optionally) eclipse effects
New module in the navigation directory, PlanetHeading, provides the heading to a planet in the spacecraft body frame. There is a corresponding new message type BodyHeadingSimMsg.
New Sphinx/Breathe based BSK documentation system! All documentation is still stored in the
basilisk/docsfolder. The new system provides much better directory structure to access the BSK modules, and has a cleaner way to list the tutorial examples.
fixed an issued with the magnetometer module tests not passing on all platforms. The tolerances are now adjusted to pass everywhere.
various improvements to the
Making the Python 3 compile flag be turned on by default. To compile with Python 2 the
-DUSE_PYTHON3can still be set to
Revised the FSW template module to use the updated in-line module documentation style which adds the description to the module
*.hdoxygen description, and adds the validation discussion as a doc-string to the
mrpRotationis non-singular for any general referene rotation.
Created a Three-Axis-Magnetometer (TAM) sensor simulation model
Created a TAM FSW communication model
Changed the BSK
ReadMessage()method to automatically zero the message memory space before reading in the data
Added a base classes for battery energy storage and power consumption/provider nodes
Added a simple power node module
Added a simpler battery module
Added a simple solar panel power module
The circle finding module using openCV has been cleaned up and the noise is now dynamically measured given the image
A new dispersion was added for Monte Carlo analysis which allows for per-axis control on an initial MRP value
Cleaned up opNav messages to be consistent with other messages, and simplified the limbFinding code. Only functionality change is Gaussian Blur.
Add new OpNav module using a planet limb. Algorithm developed by J. Christian
Added support for OpenCV v 4.1.1 and Eigen library 3.3.7
fixed issue with Windows having trouble compiling due to use of
added instructions on how to use the new Xcode 11 on macOS. This requires installing 2 more tools. Updated the install and macOS FAW pages.
added the ability to
pytestto use the
--reportflag to generate a comprehensive html test and validation document. All future modules should use this method to discuss the module validation. Legacy modules will be converted over time.
Corrected an issue with some some BSK modules in a low memory computer environment
Version 1.0.0 🍾🍾🍾🍾🍾
Added the ability to plot select BSK simulation data live as teh simulation is running. See the new tutorials examples and the new FAQ response page (under Support tab) on how to do this.
Lots of code clean up to remove compiler warnings about implicit signedness conversions, print types, etc.
scenarioMagneticFieldWMM.pyscenario to store images into the correct doxygen folder.
[Bugfix] NRLMSISE-00 now defaults to kg/m^3 output, to be consistent with other atmospheric density models.
Added the ability to live stream the Basilisk simulation data to Vizard! This functions now in addition to saving BSK data to file and playing it back later on.
Created a new attitude guidance module for OpNav: opNavPoint. Similar to sunSafePoint, it matches a target heading with the OpNav heading for a simple and robust solution.
added new tutorial on calling Python Spice functions within a Monte Carlo BSK simulation
Added Keplerian Orbit utility class which is swig’d. This first implementation takes in elliptical orbit elements and can produce a range of related outputs like position, velocity, orbital period, etc. This makes it easier to create Keplerian orbits within python.
Added a LimbFinding module for OpNav: limbFinding. This module performs a Canny transform to find the end of the planet and saves away the non-zero pixels for pose-estimation.
made BSK compatible with both swig version 3 and 4
Updated the MD help file on how to compile from the command line environment using a custom configuration of Python.
Created new optical navigation filter that estimates bias in the measurements. This filter takes in pixel and line data directly.
Added the ability to specify Vizard settings from Basilisk
vizInterfacemodule settings. This way Basilisk simulations can set the desired Vizard settings from within the simulation script.
Added a new MD help file to discuss the helper methods that setup Vizard features
Added a python helper function to setup cameraConfigMsg message and create a custom camera view.
Added the ability to script what starfield Vizard should use.
Made the Vizard helper check that correct keywords are being used.
The cmake file now turns ON by default the
USE_ZMQbuild flag options. This enables out of the box support for saving BSK data to Vizard binary files.
Added a new kind of dispersion for Monte Carlos which disperses the orbit with classic orbital elements instead of cartesian postion and velocity.
Added a new module that provides the Earth atmospheric neutral density using the MSIS model.
Updated the Doxygen HTML documentation layout
ADDED PYTHON 3 SUPPORT! This is a major step for Basilisk. Python 2 remains suppored, but is now treated as a depreciated capability. It is possible to compile BSK for P3 into a
dist3folder, and for P2 into a
distfolder at the same time.
Updated the BSK installation notes to reflect a default installation using Python 3
Updated all unit test BSK scripts to work in both Python 2 and 3
Updated all tutorial scripts to work in both Python 3 and 2. Default instructions are now for Python 3
Added a new support file with tips on migrating a Python 2 BSK script to function in both Python 3 and 2. This is called Migrating BSK Scripts to Python 3.
Added a new Earth magnetic field model based on the World Magnetic Model (WMM). The module has PDF documetnation, and extensive unit test within the source code folder, as well as a tutorial script demonstrating how to run this.
spice_interfacemodule to be able to read in an epoch message
Updated scenarios to use the epoch message
Created a new support macro to convert a general date and time string into an epoch message
VizInterfacemodule to now provide the reaction wheel and thruster states to Vizard
VizInterfaceto only subscribe to BSK messages that are already created
simpleNavto only subscribe to the sun message it is already created
Update all the tutorial scenario and bskSim simulations to use the updated
Fixed and cleaned up bugs in heading and opnav UKFs, pixelLineConverter, houghCircles, and vizInterface
Added validity falg to OpNav messages in order to exclude potential measurements
Fixed camera orientation given the Unity camera frame definition
Updated BSK installation instructions to warn about not using swig v4
Added a new plotting utility library to support interactive plotting using datashaders with Python3.
Fixed a garbage collecting leak in the monte carlo controller to minimize impact on computer memory.
Added the enableViz method to the bskSim scnearios.
Added dvGuidance PDF module description
Added new orbital simulation tutorial on a transfer orbit from Earth to Jupiter using a patched-conic Delta_v
Added the first image processing FSW module using OpenCV’s HoughCirlces.
Added the a module to convert pixel/line and apparent diameter data from circle-finding algorithm to a OpNav message with relative position and covariance.
New faceted model for atmospheric drag evaluation
Updated RW and Thruster Simulation factory classes to use ordered dictionary lists. This ensures that the devices are used in the order they are added.
Fixed issue where the Viz would show a custom camera window on startup if playing back a data file from bskSim scenarios.
Added relative Orbit Determination filter (relativeODuKF) in fswAlgorithms/opticalNavigation. This filter reads measurements treated by the image processing block to estimate spacecraft position and velocity
Changed the C++ message ID to consitently be of type int64_t, not uint64_t
Rearchitected how data is retained in BSK monte carlo runs using Pandas. The python pandas package is now required to run MC runs.
Updated the CMake to handle both Microsoft Visual Studio 2017 and 2019
Added a new attitude control scenario that uses a cluster of thrusters to produce the required ADCS control torque.
hot fix that adds back a missing method in sim_model.c/h that causes the
enableVizsupport method to not work.
updated Viz_Interface module with opNavMode flag. This triggers logic to link Basilisk and Vizard with a TCP connection. This is ground work for closed loop visual navigation capabilities.
updated enableUnityViz python function in utilities/vizSupport. It now takes in key word arguments to simplify the user interface. It also reliably saves Vizard files for play back in the same directory as the scenario that calls it.
Created a user guide MD file that is included in the BSK Doxygen HTML documentation.
Removed the BOOST library from Basilisk as it is no longer needed. This makes the BSK repository much leaner. Note that this removes the capability to communicate with the old Qt-based Visualization that is now defunct and replaced with the new Vizard Visualization.
Updated switch unscented kalman filter for sunline estimation with code cleanup and documentation updates.
pytestenvironment to have markers registered
added a PPTX support file that explains the core Basilisk architecture. HTML documentation is updated to link to this.
Creates new simulation module called
planetEphemeriswhich creates a planet Spice ephemeris message given a set of classical orbit elements.
thrMomentumDumpingmodule to read in the
thrMomentumManagementmodule output message to determine if a new momentum dumping sequence is required.
updated the hillPoint and velocityPoint scenarios on how to connect a planet ephemeris message.
velocityPointto meet BSK coding guidelines
updated BSK_PRINT macro to automatically now add a new line symbol at the end of the message
Added a new
vizInterfacemodule. This version is able to record a BSK simulation which can then be played back in the BSK Vizard visualization program. Vizard must be downloaded separately. To enable this capabilty, see the scenario tutorial files.
scenariosBasicOrbit.pydiscusses how to enable this. The python support macro
vizSupport.enableUnityVisualization()is commented out by default. Further, to compile
vizInterfacethe CMake flags
USE_ZEROMQmust be turned on. A new MD FAQ support file discusses the Cmake options.
inertialUKFmodule documentation and unit tests.
Updated unit test and documentation of
added a small include change to fix BSK compiling on Windows
updated unit test and documentation of
updated cmake files to set the policy for CMP0086 required by Cmake 3.14.x and higher
thrForceMappingmodule after code review with new expansive unit tests and updated PDF documentation
orbitalMotion.c/hsupport library to have more robust
elem2rv()functions. They now also handle retrograde orbits. The manner in covering parabolic cases has changed slightly.
This module implements and tests a Switch Unscented Kalman Filter in order to estimate the sunline direction.
Added documentation to the
dvAccumulationmodule and included proper time info in the output message.
Providing new support functions to enable the upcoming Vizard Basilisk Visualization.
updated the ‘oeStateEphem()’ module to fit radius at periapses instead of SMA, and have the option to fit true versus mean anomaly angles.
module which provides a switch Sunline UKF estimation filter. New documentation and unit tests. </li> <li> updated 'MRP_Steering' module documentation and unit tests </li> <li> updated orbital motion library functionsrv2elem()
rateServoFullNonlinearmodule documentation and unit tests.
attTrackingErrorhas updated documentation and unit tests.
navAggregate module has new documentation and unit tests.
small FSW algorithm enhancements to ensure we never divide by zero
new unit test for RW-config data
included a new environment abstract class that creates a common interface to space environment modules like atmospheric density, or magnetic fields in the future. This currently implements the exponential model, but will include other models in the future. NOTE: this change breaks earlier simulation that used atmospheric drag. The old
exponentialAtmospheremodel usage must be updated. See the integrated and unit tests for details, as well as the module documentation.
added new documentation on using the new atmosphere module to simulate the atmospheric density and temperature information for a series of spacecraft locations about a planet.
updated documentation and unit tests of
added a new planetary magnetic field module. Currently it provides centered dipole models for Mercury, Earth, Jupiter, Saturn, Uranus and Neptune. This will be expanded to provide convenient access to other magnetic field models in the future.
eulerRotation()to remove optional output message and did general code clean-up
mrpRotation(), new PDF documentation, did code cleanup, updated unit tests, removed optional module output that is not needed
MRP_Feedback(), new PDF documentation, did code cleanup, updated unit tests to cover all code branches.
Added a new tutorial on using the magnetic field model.
mrpMotorTorque()with code cleanup, updated doxygen comments, PDF documentation and comprehensive unit test.
Added documentation to
Added documentation to
Updated documentation of
Updated documentation of
Added documentation of
added a new tutorial on how to use the planetary magnetic field model.
cssComm has updated documentation and unit tests.
updated Documentation on
updated how the FSW and Simulation modules are displayed with the DOxygen HTML documenation, as well as how the messages are shown. Now the use can click on the “Modules” tab in the web page to find a cleaner listing of all BSK modules, messages, utilities and architecture documentation.
cmakefile to allow the build type to be passed in from the command line
updated Doxygen documentation on
updated documentation and unit tests of
conanpackage management system. This requires conan to be installed and configured. See the updated Basilisk installation instructions. It is simple to add this to a current install. Further, the CMake GUI application can’t be used directly with this implementation if the app is double-clicked. Either the GUI is launched form a terminal (see macOS installation instructions), or
cmakeis run from the command line (again see your platform specific installation instructions). Using
conannow enables BSK to be compiled with specific support packages, and will allow us to integrate other packages like OpenCV, Protobuffers, etc. into the near future in a flexible manner.
updated install instructions to allow for pytest version 4.0.0 or newer
updated code to remove some depreciated python function call warnings
Added a new sun heading module computed exclusively from ephemeris data and spacecraft attitude (sunlineEphem). Documentation and a unit test are included.
Added a new scenario that shows how to simulate multiple spacecraft in one simulation instance.
Added a spacecraftPointing module that allows a deputy spacecraft to point at a chief spacecraft. Besides that, added a scenario that demonstrates the use of this new module.
added the ability to the thrForceMapping FSW module to handle thruster saturation better by scaling the resulting force solution set.
Added lots of new unit tests to BSK modules
rwNullSpace() module now sets ups module states in reset() instead of crossInit(), and includes new documentation and unit tests
Added a new message output with the CSS fit residuals. This is optional. If the output message is not set, then this information is not computed.
sunSafePoint()to allow for a nominal spin rate to be commanded about the sun heading vector. The unit tests and module documentation is updated accordingly.
Added a new scenario
scenarioAttitudeFeedbackNoEarth.pywhich illustrates how to do an attitude only simulation without any gravity bodies present.
Updated the macOS Basilisk installation instructions to make them easier to follow, and illustrate how to use the macOS provided Python along with all the Python packages installed in the user Library directory. This provides for a cleaner and easier to maintain Basilisk installation.
Created new switched CSS sun heading estimation algorithms called
Sunline_SEKF. These switch between two body frames to avoid singularities, but with direct body rate estimation. Previous filters
OKeefe_EKFeither subtract unobservability or difference sunheading estimate for a rate approximation.
Updated the Windows specific install instructions to include explicit steps for setting up and installing Basilisk on machine with a fresh copy of Windows 10.
Added policy statements to the CMake files. This now silences the warnings that were showing up in CMake 3.12 and 3.13
Modified CMake to silence the excessive warnings in XCode that
registerclass is no depreciated in C++
Fixed an issue with the eclipse unit test.
updated the installation instructions to warn about an incompatibility between the latest version of
pytest(version 3.7.1). Users should use a version of
pytestthat is 3.6.1 or older for now until this issue is resolved.
.gitignorefile to exclude the
.pytest_cachefolder that pytest generates with the newer versions of this program
Tutorials added for BSK_Sim architecture. Added the ability to customize the frequency for FSW and/or dynamics modules.
Updated the dynamics thruster factor classes. This streamlines how thrusters can be added to the dynamics. Also, a new blank thruster object is included in this factory class to allow the user to specify all the desired values.
bskSim now adds 8 thrusters to the spacecraft. These are not used yet, but will be in future bskSim scenarios.
Modified how bskSim now includes CSS sensors in the spacecraft dynamics setup
Modified the FSW
sunSafePoint()guidance module to read in the body angular velocity information from standard
NavAttIntMsg. This will break any earlier simulation that uses
FIX: update the
sunSafePoint()input connection to use the current message format.
Fixed an issue with energy not conserving if the fully coupled VSCMG imbalance model is used. This imbalanced gimbal and wheel version now conserves momentum and energy!
Added initial draft of VSCMG module documentation
Added documentation to all the bskSim scenarios inside
src/test/bskSimScenarios. The documentation now outlines how the bskSim class can get setup and used to create complex spacecraft behaviors with little code.
Updated cssWlsEst() module to also compute a partial angular velocity vector.
New FSW Guidance module
mrpRotation()to perform a constant body rate rotation. The initial attitude is specified through a MRP set.
Enhanced Linux installation instructions
Updated the simIncludeThruster to use the same factor class as the RW factory class. This will break old scripts that use the old method of setting up Thrusters with this helper function.
FIX: Update the script to use the new factory class. Examples are seen in
Updated bskSim to use the RW factory class to setup the simulation RW devices, as well as to use fsw helper functions to setup the RW FSW config messages
At supportData/EphermerisData, updated the leap second kernel version to from 0011 to 0012.
Added a force and torque calculation method in the stateEffector abstract class, and provided the necessary method calls in
spacecraft. This allows for stateEffectors to calculate the force and torque that they are imparting on the rigid body hub. The hingedRigidBodyStateEffector and the linearSpringMassDamper classes provide their implementation of these calculations.
Fixed an issue with
extForceTorqueeffector where the flag about having a good input message was not being initialized properly. This caused a rare failure in the unit test.
Reaction wheel state effector has an updated friction model that allows the user to implement coulomb, viscous, and static friction.
Reaction wheel state effector now has max torque saturation logic in which the wheels can only implement a maximum wheel torque and max wheel speed saturation logic in which if the wheel speed goes over the maximum wheel speed, then the wheel torque is set to zero.
A new method called writeOutputStateMessages was added to the stateEffector abstract class which allows for stateEffectors to write their states as messages in the system and the states will always be written out to the system after integration. This fixed an issue with reaction wheels where the commanded torque information needs to be tasked before the spacecraft but the reaction wheel state messages need to be written out after integration.
A new dynamics class called
spacecraftDynamicshas been created. This allow multiple complex spacecraft systems to be either rigidly connected or free-flying. This allow for example a mother craft to house a daughter craft which has its own RWs, etc, and then release the daughter craft at a specified time.
Cleaned up the gravity effector class variable names, and streamlined the evaluation logic. The gravity effector documentation has been updated to include information on the the multi-body gravity acceleration is evaluated.
Updated the FSW modules
oeStateEphemto zero out the output message first in the
Fixed an issue with the RW factory class and the Stribeck friction model not being turned off by default.
added a new bskSim based tutorial scenario that illustrates a sun-pointing control while the spacecraft goes through a planets shadow.
Version 0.2.3 (June 12, 2018)
Improved how the
fuelSloshSpringMassDampereffector class works. It is now renamed to
LinearSpringMassDamper. It can be used to simulate both fuel sloshing, but also structural modes. If the
LinearSpringMassDamperis connected to a fuel tank, then it’s mass depends on the amount of fuel left. The associated unit test illustrated how to setup this last capability. The module also contains documentation on the associated math.
SphericalPendulumeffector class has been added. For rotations a spherical pendulum is a better approximation rotational fuel slosh. This effector can model rotational fuel slosh if connected to a tank (see unit test again), or it can model a torsional structural mode if not connected to a tank. Associated math documentation is included with the class.
The booleans useTranslation and useRotation have been removed from the
HubEffector()class. The defaults in hubEffector for mass properties:
mHub = 1,
IHubPntBc_B = diag(1), and
r_BcB_B = zeros(3), enable us to evaluate the same code no matter if the desire is only to have translational states, only rotational states, or both. This allows for less logic in hubEffector and removes possibility of fringe cases that result in unexpected results from a developer standpoint. The fix for if your python script is not working related to this change:
FIX: Remove any instances of useTranslation or useRotation defined in the hubEffector class.
Changed name of the method
dynamicEffectorabstract class and any inheriting classes. This avoids the confusion of thinking that only body frame relative forces can be defined, but in reality this class gives the ability to define both external forces defined in the body frame and the inertial frame.
Fixed an issue in
RadiationPressurewhere the cannonball model was not computed in the proper frame. An integrated test has been added, and the unit test is updated. Note that the
RadiationPressuremodel specification has changes slightly. The default model is still the cannonball model. To specify another model, the python methods
setUseFacetedCPUModel()are used. Note that these take no argument anymore.
FIX: remove the argument from
setUseCannonballModel(true)and use the methods
setUseFacetedCPUModel()without any arguments instead.
Version 0.2.2 (May 14, 2018)
Fixed a build issues on the Windows platform is Visual Studio 2017 or later is used.
Unified the Coarse Sun Sensor (CSS) sun heading filtering modules to use the same I/O messages. All used messages are now in the fswMessage folder.
Made the CSS sun heading filter messages consistently use the CBias value. This allows particular sensors to have an individual (known) scaling correction factor. For example, if the return of one sensor is 10% stronger then that of the other sensors, then CBias is set to 1.10. Default value is 1.0 assuming all CSS units have the same gain.
src\tests\bskSimScenariosfolder now functions properly with the
The tutorial scripts in
src\tests\scenariosare now simplified to pull out the unit testing functionality. The unit testing is now down with the
test_XXX.pyscripts inside the
bskSimtutorial files are now tested through pytest as well. The file
testScripts\bskTestScript.pycalls all the
bskSimtutorial fails and ensures they run without error.
Added messages for current fuel tank mass, fuel tank mDot, and thruster force and torque
Changed the linearAlgebra.c/h support library to avoid using any dynamic memory allocation.
Added some new function to linearAlgebra.c/h while making the library use the new BSK_PRINT() function.
Added ability to simulate noise to the RW devices.
Created a more complete spacecraft python simulation class called BSKsim, and recreated some BSK tutorial scripts to use BSKsim instead of the more manual spacecraft setup in the earlier scripts.
Developed general functions to add saturation, discretization and Gauss Markov processes to signals.
Created a new BSK_PRINT() function. Here the coder can tag a message as an ERROR, WARNING, DEBUG or INFORMATION status. The printout can be set to selectively show these print statements.
Version 0.2.0 (First public beta)
First open beta release of Basilisk
Moved to a new file architecture. This means older BSK python scripts need to be updated as the method to import BSK has changed.
The source an now be forked from Bitbucket
Precompiled binaries are provided through a python pip install wheel file.
The Doxygen documentation now pulls in the BSK module description PDF file and makes it available via the class definition html page.
The tutorial python scripts are now moved to
pytestcommon should now be run within the
Updated fuel slosh model documentation
Updated fuel tank documentation
Adding noise and corruptions using a new utility to the BSK modules (in progress)
New N-panel hinged rigid body module
New 2-panel hinged rigid body module
Added CSS sun-heading estimation tutorial script
Added O’Keefe CSS sun-heading estimation module
New Monte-Carlo capability that uses multiple cores and hyperthreading to accelerate the MC evaluations. Data is retained and stored for each MC run for robustness. See
test_scenarioMonteCarloAttRW.pyfor an example.
Coarse Sun Sensor (CSS) modules can now scale the sensor output with the distance from the sun.
CSS now have updated documentation that includes validation results.
CSS, IMU have updated means to apply sensor corruptions.
IMU, simple_nav and star tracker modules have been updated to use now internally Eigen vectors rather than C-Arrays. NOTE: if you have simulation scripts that use these modules you may have to update the script to set sensor states as Eigen vectors from python.
All the dynamics, thruster and sensor simulation modules have expanded documentation and valdiation unit and integrated tests. The validation results are automatically included in the module TeX documentation.
new unit tests to validate the multi-body gravity simulation code in
new hinged rigid body tutorial script in
new tutorial to do velicity frame pointing on a hyperbolic orbit in
fixed various unit test issues that came up on the non-macOS builds
added reaction wheel effector documentation
Lots of new module documentation which includes a discussion of what is being modeled, the validation tests, as well as a user guide to the module. The new documentation includes:
ephemeris conversion module
Coarse Sun Sensor module
Updated BSK module template documentation
Updated documentation for IMU Sensor module
Gravity Effector module
SimpleNav Sensor module
New tutorial scripts on
using CSS modules
using fuel tank module and the fuel slosh particle
How to use
MRP_Steering()along with the rate tracking sub-servo module
The CSS modules now use the planetary shadow message information to simulated being in a planet’s shadow
SRP DynEffector modules now simulates the impact of being in a planets shadow
Included a method to validate all the AVS C-Function libraries like
orbitalMotionwhen the Basilisk
pytestcommand is called. There is also some documentation on using these libraries in
Updated the RW and gravitational body (i.e. adding Earth, sun, etc. to the simulation) to use new factory classes. If you did use the older
simIncludeGravity.pylibraries, you’ll need to update your python code to work with the new factory classes.
A planetary eclipse model has been added. This allows for the shadow of one or multiple planets to be taken into account, including the penumbra region. This module writes an output message indicating if the spacecraft is in full sun light, partial shadow, or full shadow of the sun.
The body-fixed spacecraft structure frame has now been removed from the simulation and flight algorithm codes. All spacecraft vectors and tensors are now set directly in the body frame B. If the spacecraft parameters are given in terms of an alternate structure frame, these vectors and tensor must be transformed into the body frame first before being set in BSK.
The integrated tutorial test for using a Python based BSK module now has some documentation.
Created a method to compute the orbital potential and angular momentum energy. This allows for the kinetic energy and angular momentum checks to flat-line even if the satellite is in orbit. The spherical harmonics of the planet are taken into account as well.
Included a new Extended Kalman Filter module that determines the body-relative sun heading using the CSS signals.
There is a new capability to now write BSK modules in Python, and integrated them directly with the C and C++ BSK modules. Documentation is still in progress, but a sample is found in SimScenarios/test_scenarioAttitudePythonPD.py.
A new Variable Speed Control Moment Gyroscope (VSCMG) state effector module has been created. This module provides a torque-level VSCMG simulation which also includes the gyro frame or wheel being imbalanced. If the latter modes are engaged, the simulation does slow down noticeably, but you get the full physics.
In the simulation the initial spacecraft position and velocity states are now specified now using the spacecraft center of mass location C, not the body fixed point B. This greatly simplifies the simulation setup. Upon initialization, the sim determines what the true center of mass of the spacecraft is using all time varying mass components, and sets the proper B point position and velocity vectors.
Specifying the initial spacecraft position and velocity states can now be done anywhere before the BSK initialization. The user sets init versions of the position and velocity vectors. The setState() method on the state engine thus doesn’t have to be used.
There is a new initializeSimulationAndDiscover method to init the BSK simulation that automatically checks if messages are shared across multiple simulation threads. See the modified SimScenarios/test_scenarioAttitudeFeedback2T.py file for how this simplifies the dual-threaded setup.
The MRP_Steering and PRV_Steering FSW modules have been broken up into a separate kinematic steering command (commanded desired angular velocity vector) and an associated angular velocity servo module name rateServoFullNonlinear. This will break any existing code that used either of these two attitude steering modules. The Python simulation code must be updated to to account for these new modules as done in the MRP_Steering integrated test test_MRP_steeringInt.py.
All unit and integrated tests now pass on Linux. The root issue was a variable length string variable in an output message. These strings have now been removed as they are no longer needed.
The position and velocity of the center of mass of the spacecraft was added to the messaging system, so now the spacecraft’s translational states can be logged by the center of mass of the spacecraft (r_CN_N and v_CN_N) or the origin of the body frame which is fixed to the hub (r_BN_N and v_BN_N). Additionally, the mass properties of the spacecraft was organized into an updateSCMassProps method that incapsulates the calculations of mass property calculations.
Updated UKF FSW module to be able to run on gryo only information when the star tracker is not available.
On Linux, simplified the processing running BSK modules that require boost. This makes the Viz related communication modules working again.
Added boost libs built on Ubuntu against gcc 5.4.0 20160609.
Added RPATH settings to allow for build directory to be placed outside source directory
Major addition with new depleatable mass dynamic modeling, including some fuel tank dynamic models.
minor fix for Monte Carlo dispersions
Simulation modules include:
- Flexible integration structure with fixed time step RK1, RK2 and RK4 included
- Rigid spacecraft simulated through
spacecraftPlus()module. The spacecraft object makes it simple to add external disturbances through
dynEffectorsand state depended actuation through
- Dynamics Effectors (actuation methods which do not have their own states to integrate)
- External force or torque module
- Solar radiation pressure module
- Thruster module
- State Effectors (actuation methods which have states to integrate)
- Fuel Tank model with fuel slosh particles
- Hinged panel model to simulate flexing structures such as solar panels
- Reaction wheel module with 3 modes (perfectly balanced, simple jitter with the disturbance modeled as an external force and torque, fully coupled imbalanced RW model)
- RW voltage interface module that mapes an input voltage to a RW motor torque
- integrate Spice ephemeris information
- simple navigation module that produces the position and attitude measurement states
- IMU sensor
- Star Tracker module
- Coarse Sun Sensor (CSS) module
- Added the ability to simulate the gravity from multiple celestial objects, as well as include spherical harmonic expansion of a particular celestial body.
The AVS Lab Flight Algorithm folder contains:
FSW template module
CSS based sun heading estimation module
UKF filter to determine inertial attitude
UKF filter to determine CSS based body-relative sun heading
Attitude Guidance modules:
Pointing towards two celestial objects
Hill Frame Pointing
Euler rotation sequence to add dynamics capabilities to the attitude reference generation
Spinning about an inertially fixed axis
A raster manager module that can change the guidance module states
Velocity frame pointing
attitude tracking error evaluation module
Deadband module for attitude tracking error
DV guidance module
mapping of control torque onto RW motor torques
Converting RW motor torques to voltages
RW null motion module to equalize the wheel speeds continuously
Thruster (THR) firing logic using a Schmitt trigger
THR firing logic using a remainder calculation
mapping of a command torque onto a set of THR devices
module to evaluate the net momentum to dump with thrusters