The Universal Space Operations Center, USOC, is an open-source tool that allows a simple and easy creation of a working groundstation to aid (student) space projects.
Due to the fact that the functionality of every experiment should be checked before lift-off, a communication software for up- und downlink is required. USOC follows a generic approach and offers the possibility to write this software automatically using a configuration file. The program structure is divided into three main components:
- Communication software
- Graphical user interface (GUI)
- Controller for interaction between communication software and graphical user interface
Based on the input of the user in the configuration file, the GUI and partially also the controllers can be written automatically. In this matter, USOC generates appropriate functionalities within the controllers for individual GUI contents, which can then be adapted manually. Changes in the configuration file are detected, localized and the corresponding GUI structures and controller functionalities are regenerated. If these are manually written functionalities, they are recognized and not overwritten. USOC also brings pre-coded functions, such as communication via serial ports and/or the Iridium satellite network, as well as a three-dimensional visualization of GNSS data. For further details of these functions, I would like to refer to the GSoC2017 project of Valentin Starlinger, whose blog post can be reached here.
In this way, essential parts of a ground segment software can be created quickly and easily. Because of the wide diversity concerning the experiments in the space sector, people from all over the world can use USOC and add functionalities for their individual project to develop and extend the Universal Space Operations Center.
„[GSOC2017] Introduction to the generic creation of a ground station using USOC“ weiterlesen
Mathematics is the field of science which is very vast, and the backbone for all other fields of science. It supports the development of new technologies, and in the development of new technologies. Mathematics plays a very important role in any kind of research and development. I was responsible for developing VisMa, a new project for AerospaceResearch.net under Google Summer of Code – 2017. VisMa, created to create a platform which could solve algebraic equations and perform several other complex functions on it like root finding, integration and differentiation.
The project aims to help people solve complex problems and learn. It can help students in learning concepts. It can be used in research-oriented, double-checking the solution to problems.
After the proposal was accepted. The one month community bonding period. I was mostly interacting with Manfred Ehresmann and Andreas Hornig from time to time.
Since this is a new project, a community bonding period has been used. Some GUI mock ups were created by me, so that’s it. The resources for the planning phase and GUI mock ups are available here . This is the first time I use OpenGL, and PyQT 4.0.
It was that VisMa’s code wants to be hosted on AerospaceResearch.net ’s GitHub organization.
Coding period started from 1st June, PyQT 4.0 was used to build the GUI. Some key features of VisMa’s GUI were dynamic buttons. This is the first step in the process. VisMa also has scope for multiple styles of input, for now it’s just normal and LaTeX style. VisMa wants to be able to store a history of older expressions. PyQT had a slight learning curve, but event based programming was pretty straight forward.
Each module was created it such a way that they are independent from all the other modules. This allows us to make changes in one module without effecting any other module. Also allows us to just plug in the modules, and use it with the software with minimal integration steps required.
The final GUI looks something like this:
„[GSOC2017] VisMa – VisualMath with visual equation solving (siddharth)“ weiterlesen
Iridium is a satellite communication system, previously mainly used for satellite phone calls and remote control and tracking of scientific instruments or trucks. Recently, however, more and more lightweight modules were introduced to the market which allow for new applications in vehicles such as high-altitude balloons and miniaturized spacecraft.
The goal for my GSOC development was to improve the existing ground station coded for the MIRKA2-RX KSat experiment in order to get a more flexible and versatile platform that can be easily modified and fitted to the needs of any experiment.
Java is used as main programming language.
„[GSOC2017] Building a universal ground station“ weiterlesen
CubeSats is a class of nanosatellites that uses a standard size and form factor. The standard CubeSat size is one unit or 1U measuring 10x10x10 cms and is extendable to larger sizes; 1.5, 2, 3, 6, and even 12U. Originally developed in 1999 by California Polytechnic State University of San Luis Obispo (Cal Poly) and Stanford University to provide a platform for education and space exploration. The development of CubeSats has expanded its industry, academy, and industry with ever-increasing capabilities. CubeSats now provides a cost-effective platform for science investigations, new technology demonstrations and advanced mission concepts using constellations, swarms disaggregated systems.
While CubeSats came into the picture for it’s low cost of manufacturing with many small to medium sized individuals. So through this project.
This project is made using python-3.x or python 2.7. Python libraries used for this project are
Except for PyQt4 all other libraries can be installed using python package manager. Installation of PyQt4 depends on the distribution. Detailed guide for installation of requirements is available here .
Overview of Project
„[GSOC2017] SiqNAL: CubeSat tracking using IQ stream data“ weiterlesen
In 2017 Google summer of code I was involved in the project by AerospaceResearch.net called „Orbit position data analysis and interpolation“. Mainly, the project focused on methods and techniques that are used to preliminary determine a satellite orbit. More specifically, we initially had positional data sets in the format of (time, x, y, z) and we applied to them some smoothing – filtering techniques (Savintzky – Golay, Triple moving average) and then some methods for preliminary orbit determination (Lambert’s solution, Spline Interpolation). This project was created from scratch, meaning no prior work has been done. It was also applied not only to me, but also to another GSOC student Nilesh Chaturvedi, with whom we had great communication and cooperation leading to some good and interesting working results. The mentor of the project was Andreas Hornig and his insights and guidance provided us lots of help. Before I continue describing some more technical aspects of the project I would like to point out the github repository, which includes all the coding we did as part of the program and the documentation link for the project.
The programming language used for the project was Python 3.4 / 3.5 and libraries that are a core part of the project are Numpy, Matplotlib, Scipy, Pykep and Pytest. The very first coding I did as part of the program was, to get familiar with the data sets we are dealing with and try to perform some basic statistical filtering and create some graphs with matplotlib. Then, I dived deep into smoothing techniques and tried a lot of methods like median filters, FIR filters and Kalman but after many tests, I decided to use the Savintzky – Golay filter which was giving the best results for this kind of data I had. After applying the filter to my data set I quickly moved into creating some code for finding the keplerian elements (keplerian elements = orbit of the satellite) for all these data points I have. I researched a bit about methods for preliminary orbit determination and decided to go for Lambert’s solution and more specifically I decided to use Pykep library which has the method already implemented. So for every 2 points of the 8000 points data (leading to 7999 solutions) set I had, I solved the orbit determination problem and found lots of orbits. Now from all those 7999 different orbits described by 6 keplerian elements, I wanted to find the best approximation and I used Kalman filters to do that exactly. The results at first were not that good but combining my filter with Nilesh’s Triple moving average I managed to get some good approximations. After that, I created code for one more method for preliminary orbit determination called Gibb’s method. That algorithm though was really slow and it was not included in the final version of the program. One future plan I have for the program is to make this algorithm more „light“ so I can include it. Finally, lots of results are printed and graphs about the initial data, filtered data and final orbit are made to ensure the good presentation of the final computations. Into the whole process, lots of sub – functions and calculations needed to take place and they are located in the util directory. Into that directory a user can find algorithms that can transform cartesian to spherical coordinates, two algorithms to transform state vectors to keplerian elements and vice versa, one algorithm with a numerical integration method so that we make the final graph and one for finding the window for the Savintzky – Golay filter.
After finishing the core structure of the program the part of testing arrived, which was divided into two aspects. First was the unit testing with pytest and then massive testing with lots of satellite position data to find what combinations of algorithms function best or what windows and parameters I need to apply to the filters. For the first part, I created 15 general tests that achieved a pretty good coverage.
„[GSOC2017] Orbit-Determinator: Orbit position data analysis and interpolation (Alexandros Kazantzidis)“ weiterlesen
Orbit Determinator is a project that aims to provide satellite’s tracking information to various researchers, university students and space enthusiasts who plan to launch their satellites (mainly CubeSats) into space.
The central idea to accomplish this is the position of the satellite at different time instances and then perform filtering and preliminary orbit determination techniques to get keplerian elements of the orbit. A CSV file is taken as input which has values in the format: (time, x-coordinate, y-coordinate, z-coordinate). This input sample has lots of jitter to perturbation and has to be. This project was carried out with Alexandros Kazantzidis under the guidance of Andreas Hornig.
Before the coding period started, I had already tried some smoothing / filtering techniques like as convolution and exponential smoothing with varying parameters and had an idea how to go about making changes.
„[GSOC2017] Orbit-Determinator: Interpolation as a method for Orbit Determination and more (Nilesh)“ weiterlesen