Telemetry Sub-Project

This page is a dedicated sub project of the HIL where alterations to the testing platform will be implemented.

The end goal of this project is to develop a suitable UI where testers can track behaviour of the satellite realtime → instead of sniffing and reading from the logsink via command line, we can develop and interface where a server that is hosted on the RPI will display actuator and sensor values along with a logger where testers can see which tests have passed/failed along with realtime scheduled tasks that take place on the satellite.

Currently, when HIL is implemented, if we wanted to emulate sensor data along with manual CubeSAT verification, keeping track of many processes will be challenging, and to optimize this, a separate interface will be created for ease of access.

Skills: Fullstack (React Native, Node, Next), JS, Python, SQL, API, Flask/Django, AWS?, Linux?

Goals

Develop internal communication with HIL system processes and the WebServer/db	We’ll need to implement communication within the code so that information can be casted to the server/db.
Host a WebServer on the RPI	Probably using apache with RPI, we can host a web application using Node.js. Node.js also supports many communication interfaces so that we can extract sensor telemetry.
Develop both Frontend and Backend of a Web Application Implementation	We can use React Native to design the front end using a template (sake of time) and backend should add basic functionality to the web application.
Export LogSink RealTime into a database with timestamps	Reading from the logsink using the HIL RPI, we can read from the logsink to the database, which will then be read using backend logic and casted to the web app.

Progression Guide:

Setup Raspberry Pi:
- Connect your sensors or telemetry devices to the GPIO pins on the Raspberry Pi.
- Install necessary libraries or drivers to interact with these sensors.
Set up a Web Server on Raspberry Pi:
- Install a web server like Apache or Nginx on your Raspberry Pi.
- Set up a web application framework like Flask or Django to handle HTTP requests and responses.
Read Data from GPIO Pins:
- Write a Python script to read data from the GPIO pins.
- You can use libraries like RPi.GPIO to interact with GPIO pins in Python.
- Read the telemetry data and process it as needed.
Expose Data via Web API:
- Expose an API endpoint in your Flask or Django application to serve the telemetry data.
- The endpoint can return the telemetry data in JSON format.
Create a Frontend Web Application:
- Write HTML, CSS, and JavaScript to create the frontend of your web application.
- Use frameworks like React, Vue.js, or Angular for building interactive UI components.
Visualize Telemetry Data:
- Use JavaScript libraries like Chart.js, D3.js, or Plotly to visualize the telemetry data on the frontend.
- Fetch data from the API endpoint created in step 4 and update the visualization dynamically.
Save Telemetry Data to Database:
- Install and configure a database server like MySQL, PostgreSQL, or SQLite on your Raspberry Pi.
- Write Python code to insert telemetry data into the database.
- Schedule a task using tools like cron to run this code every minute to save telemetry data to the database.
Secure Your Web Application:
- Implement proper authentication and authorization mechanisms to secure access to your web application and API endpoints.
- Consider using HTTPS to encrypt communication between the web server and clients.
Testing and Deployment:
- Test your web application thoroughly to ensure it works as expected.
- Deploy your web application on the Raspberry Pi.
- Make sure your Raspberry Pi is accessible over the network if you want to access the web application from other devices.

Notes: This is a recommended flowchart.