[GSoC2018|USOC GUI|Pedro] Weeks 3-4 – Handling Protocol Data

This is my second post since the start of GSoC18. I would recommend you check my first post for a bit of context before reading this.

Current state of the project

I spent the past two weeks designing a new Window for assigning variables defined in a protocol file anytime during runtime of the application. This feature is one of the main goals/tasks of my project during these 3 months as a GSoC student, so I don’t want to rush a definitive solution.

For a little insight, a protocol file is a XML file that tells the Ground Station how incoming data should be handled. It contains multiple sensors, each one with different variables and datatypes. Before, the selected protocol was hardcoded which means that the user would have to compile and re-run the application for the changes to take effect. This was fixed in my first implementation of the Layout Creator Window in the first two weeks. Now, there’s the need of assigning data from the protocol to the created charts and states. My first solution for this problem was an ‚Assign Data‘ Button inside each chart/state in the LayoutCreator window.

Assign Data Button
Assigning Data to a Chart

After some time, i figured this would not be the optimal solution for many reasons:

  • The user may not want to assign variable information to UI components right away.
  • If there is a big number of charts and states, assigning variables to each one becomes time-expensive and tedious.
  • There’s no way of knowing which variables and sensors are assigned to each chart. The user would have to open each component’s window and check.
  • No support for dragging and dropping variables (another project requirement)

All of these above go against what was proposed right at the beginning: a quick and simple implementation of a ground station that lets the user focus on what’s important, rather than the User Interface.

So, I came across another design and solution for this. Instead of assigning variables to a chart/state one at a time, all desired charts and segments are shown inside a TreeView.

Assigning Data to Charts/States

By selecting a variable from the left TreeView (source) and a state/chart from the right TreeView(destination), the user can easily assign data to UI components. For now, a button click is needed to shift variables from one tree to another, but I plan on implementing a drag-and-drop‘ feature in the future.

Protocol data persistence

Last dev blog I talked about how GUI preferences are being stored in a JSON file. To avoid having to handle protocol data each time the user loads an existing configuration file, I had to store some more information in the JSON file (protocol name, variables and sensors). For now, only the corresponding names are stored.

What’s next

There are still some bugs with the new iteration of the AssignDataWindow. It seems simple shifting variables from one tree to another, but since each item is treated as a String, there’s quite a lot of logic behind it to make sure the right components and variables are being correctly assigned. Besides, I still haven’t started working on actually assigning protocol data to charts and states (i need to make the layout creation process as solid as possible before that).

First month and evaluations

After 4 weeks of work, I finish my first coding period. I believe I achieved what I planned in my proposal for this time. I’ve been having a great time at this organization and I believe every other student feels the same. Our mentors are great and really want us to succeed more than anything. See you in two weeks!

 

– Pedro Portela

Four weeks at GSoC

About the Author: Hello guys, I am Aakash Deep. I am a B.Tech. student from Indraprastha Institute of Information Technology, Delhi (IIIT-D) in Computer Science and Engineering (CSE). I am a speed-cuber and obviously, my hobby is solving Rubik's Cube.

This post is in the continuation of my last post, as the last post contains the information about the first two weeks as being a GSoC student and the work done in that time frame. Those who missed it can access that post here.

Week 3 and 4

As the database was created earlier and now it is updating every day as the new TLEs are getting store into it. Now, the work left is implementing propagation model.

For the propagation algorithm, the SGP4 algorithm is used. The algorithm takes the TLE as input and computes position and velocity vectors. Now, we will come to the workflow of the code,  that how the code is behaving. A sample test file is added to my github (can be found here). The file contains the multiple TLEs of a single satellite which is taken from the database. The code takes this as input and passes it to the propagation model. Then propagation model computes the position and velocity vectors of each TLE. After that, the averaging occurs and in the end, we get a single position and velocity vector. These vectors are then used to find the orbital elements of the satellite.

Evaluation 1

Phase 1 evaluation of the GSoC is nearby. The dates of the deadline are from June 11 to June 15. Following checkpoints are met before the deadline:

  • Creating database
    Creating the database and a table for mapping satellite’s name to its corresponding md5 hexadecimal hash and initializing tables in the database for each satellite.
  • Scraping data from web
    Scrape data from the celestrak site and populated it into the database into their respective tables.
  • Maintaining database
    Updating database whenever new TLE comes on the website.
  • Implement Propagation Model
    Converting TLE into position and velocity vector and then computing orbital elements. Now, there can be two ways to do it.  We have a file containing multiple TLE of the same satellite at different time points.
    The first way is, feeding this file as input. Compute position and velocity vector of every TLE and average these vectors to get a single vector. Use this averaged vector to calculate orbital elements.
    The second way is, feeding the file as input. Compute position and velocity vector of each TLE and from these TLE calculate position and velocity vector for each pair of vector and then average the orbital elements. After this, we will get the averaged orbital elements.
    Right now, I don’t know which way is better but we as a team trying to figure it out.
  • Compute orbital elements
    Calculates orbital elements from the given pair of position and velocity vector.

Work on Progress

  • Documentation
  • Testing

[GSoC2018|OrbitDeterminator|Jorge] Week #3-4 – Least squares fit to cartesian positions as a function of time

Introduction

An orbital fit by least-squares is a technique for computing the set of six Keplerian elements which best describe an orbit with respect to a *whole* set of observations.
As the set of Keplerian elements we choose semimajor axis a, eccentricity e, time of perigee passage τ (i.e., how much time has elapsed since the last perigee), as well as the standard Euler angles which describe the orientation of the orbital plane with respecto to the inertial frame: argument of pericenter ω, inclination I and longitude of ascending node Ω. We denote by X the set of these six Keplerian elements; that is, X = (a, e, τ, ω, I, Ω).
A least-squares fit is simply to look the minimum of a scalar (i.e., real-valued) „cost“ function Q(X). The Q function is simply a measure of how well our theoretical predictions, for a given set X of orbital elements, depart from observations. In an ideal world, we could find a set of orbital elements such that it perfectly matched the observations and thus Q(X)=0. Nevertheless, real-world measures carry uncertainties, and we can only hope to find orbital elements X which make Q attain its minimum possible value with respect to all the observations we have made.
The values of the cost function Q(X) for a least-squared problem are constructed the following way: take *all* the values you observed (call them v_i), and substract from each of those the values you were expecting to measure for a given set of orbital elements X (say, V_i(X) ). Call each of these differences the residuals, xi_i(X) = v_i-V_i(X) . Then, square the residuals, and sum all the squared residuals. The value you obtain following this recipe, is the value of Q(X).
In practice, the least-squares method finds a local minimum of the cost function by performing an iterative procedure, which needs a good initial „guess“ solution X0; otherwise the procedure may converge to non-feasible results. Hence, it is necessary that the „good“ initial guess be provided by a preliminary orbit determination method.

„[GSoC2018|OrbitDeterminator|Jorge] Week #3-4 – Least squares fit to cartesian positions as a function of time“ weiterlesen

[GSoC2018|OrbitDeterminator|Aakash] Implementing Two-Line Element (TLE) Input / Output and using it for evaluation

About the author: Hello everyone, I am Aakash Deep, B.Tech student in Computer Science and Engineering (CSE) from Indraprastha Institute of Information Technology, Delhi (IIIT-D). Currently completed my 3rd year in it. I am a space enthusiast and always keep searching about the space.

Introduction

Orbit Determinator,  I think the project is self-explanatory. Yes, you are right the project is tracking the orbit of the satellites using their TLEs at different time points.

TLE short for Two-Line Element. It is a data format encoding a list of orbital elements of the Earth-orbiting object for a given point in time. It consists of two line with each having character length 70. Orbital elements play a major role in plotting the orbit of the satellite. Line2 of the TLE contains all the orbital elements. „[GSoC2018|OrbitDeterminator|Aakash] Implementing Two-Line Element (TLE) Input / Output and using it for evaluation“ weiterlesen

[GSoC2018|OrbitDeterminator|Jorge] Week #1-2 – Look up to the sky and marvel!

Hi, everyone! My name is Jorge Pérez, I’m a Physics PhD student at UNAM, Mexico, and this year I have been honored to form part of Aerospaceresearch.net as a GSoC student. Since I am a Python newbie, in these lines, I will try to follow the great Kepler, who in the Preface of his New Astronomy wrote:

What matters to me, is not merely to impart to the reader what I have to say, but above all to convey to him the reasons, subterfuges, and lucky hazards which led me to my discoveries. When Christopher Columbus, Magellan and the Portuguese relate how they went astray on their journeys, we not only forgive them, but would regret to miss their narration because without it the whole grand entertainment would be lost.

So, indeed, even when these last few days have been about warming up, I have been learning a lot. As a first task for my GSoC project, I have been coding some Python functions which will allow orbitdeterminator to load data from text files which contain position observations of either satellites or natural bodies, such as Near-Earth Asteroids (NEAs). Observational data for these type of objects is usually written to text files following fixed-width column formats. That is, in this kind of text files, for example, column 1 to 5 might refer to a numeric ID of the observed object; etc…

As a first thought to implement this, since these formats are defined via columns, my idea was that it might be safer to read these files using Python’s native file reading functions. And I was indeed able to read formatted files and save them into a Python list, but then I would have had to convert that to e.g. a numpy array, or something similar, in order to compute interesting stuff from the data.

So, as a second option, and after learning more about numpy, I thought that the `numpy.loadtxt` function might be the best approach, interpreting the whitespaces as delimiters and read each element as a string. This worked for a particular case I was working with, but I wasn’t sure if this approach would work for other formats.

And then, I worked on a third attempt at this. I realized that there was another numpy file-reading function, `numpy.gentfromtxt`. I liked this function better, since it tolerates files with missing values, as well as admitting files formatted with fixed-width columns. So, at the end, this was the approach that I took, and went on to code file-reading functions for some relevant formats which we will be using during the summer.

So now that we have the ability to load actual position data for satellites and asteroids, the next step, besides refining what I already coded, will be to implement orbit determination methods which take into account this kind of observational data from optical instruments, i.e., telescopes. And once this is done, the next step will be to code an orbit determination subroutine for radar observations, which are more subtle to reduce, but we will talk about this in a future blog post.

Incidentally, these last few days in Mexico City have been unusually warm; but tonight this weather, with clear skies and soft winds, allowed one of the most beautiful sights of the rising Moon in Mexico City since I can remember. Let’s not forget to always look up to the sky and marvel!

[GSoC2018|USOC GUI|Pedro] Week #1-2 – First 2 weeks as a GSOC Student

Introduction

Hello everyone. I’m Pedro Portela, a Software Engineering undergraduate student at ISEP, Portugal.  This year I applied for the first time to the Google Summer of Code Program and even though only 2 weeks have passed, I must say that I have been having a great time. In this blog post, I’m going to talk a little about how the past days have been and how I handled my work and schedule. My end goal for these dev diaries is for future gsoc students to read and get an understanding of how working for this program and AerospaceResearch looks like.

„[GSoC2018|USOC GUI|Pedro] Week #1-2 – First 2 weeks as a GSOC Student“ weiterlesen

[GSoC2018|DirectDemod|Vinay] Week #1 – Accurate sync detection from NOAA-APT signals

Hello everyone!

A little introduction since this is my first post: I am Vinay, an Electronics and Communication engineering student from IIIT Bangalore, India. I am working for AerospaceResearch.net under the Google Summer of Code (2018) programme. This organization was among very few organizations that caught my eye, owing to their very interesting projects in my fields of interest. I really believe in the core ideas of this organization, which is a great motivation for me. So far, it has been a great experience working on my project under the mentorship of Mr. Andreas Hornig.

This blog post will look at how synchronisation signals are being detected in the NOAA APT transmissions accurately.

„[GSoC2018|DirectDemod|Vinay] Week #1 – Accurate sync detection from NOAA-APT signals“ weiterlesen

[GSoC2018|OrbitDeterminator|Arya] Week #1-2 – Hello World!

Hello World!

I have been selected to work for AerospaceResearch.net under the Google Summer of Code program. Since I am a new contributer here, I think I should give a short introduction first. I am Arya Das, an undergraduate student of computer science at Indian Institute of Technology, Patna. I am highly passionate about space. I am also interested in robots, flight simulators, playing piano and swimming.

In this blog post I am going to describe my experience so far at AerospaceResearch.net and the project I am working on.

„[GSoC2018|OrbitDeterminator|Arya] Week #1-2 – Hello World!“ weiterlesen

[GSoC2018|VisMa|Shantanu] Week #01-02: Making VisMa classy

I came across AerospaceResearch.net when browsing through GSoC organizations. It offered projects both in my field of interests and academic domain. I had to make a hard choice between DirectDemod and VisMa and I finally chose VisMa as my project for GSoC.

This is my first GSoC dev log (more to come). Here I will be blogging about what I learned, what I have done and what I will do. So following is the work I have done in VisMa.

Done so far…

I used the community bonding period to fix minor errors and get more familiar with the source. I restructured the code base so that new modules could be accommodated. Code duplication was reduced using proper imports between modules. New modules like calculus, transform, solversgui etc were initialized. A token IDing module was written to handle equations during calculus operations.

„[GSoC2018|VisMa|Shantanu] Week #01-02: Making VisMa classy“ weiterlesen

Call for Google Summer of Code 2018! Student stipends of up to 6600 USD for open-source space coding (please Forward)

Again for the 4th time, AerospaceResearch.net[0] is proud to be selected as an official mentoring organization for the Summer of Code 2018 (GSOC) program run by Google[1].
And we are now looking for students to spend their summers coding on great open-source space software, getting paid up to 6600 USD by Google, releasing scientific papers about their projects and supporting the open-source space community.

Until 27. March 2018, students can apply for an hands on experience with applied space programs. As an umbrella organisation, AerospaceResearch.net and KSat-Stuttgart e.V. are offering you various coding ideas[2] to work on:

  • The Distributed Ground Station Network – global tracking and communication with small-satellites[2][4]
  • KSat-Stuttgart – the small satellite society at the Institute of Space Systems / University of Stuttgart[2]
  • or your very own proposal![2]

„Call for Google Summer of Code 2018! Student stipends of up to 6600 USD for open-source space coding (please Forward)“ weiterlesen