1
dataset_repo_id = 'nominal-io/px4-ulog-quadrotor'
2
dataset_filename = 'PX4-quadrotor-example-log.ulg'

1
from huggingface_hub import hf_hub_download
2
3
dataset_path = hf_hub_download(
4
    repo_id=f"{dataset_repo_id}",
5
    filename=f"{dataset_filename}",
6
    repo_type='dataset'
7
)
8
9
print(f"File saved to: {dataset_path}")

1
import subprocess
2
ulog_path = dataset_path
3
subprocess.run(["ulog2csv", ulog_path], capture_output=True, text=True)

1
from pathlib import Path
2
folder_path = Path(ulog_path).parent
3
files = [file for file in folder_path.iterdir() if file.is_file()]
4
5
for file in files:
6
    print(file.name.strip('PX4-quadrotor-example-log'))

1
import polars as pl
2
from pathlib import Path
3
4
full_path = folder_path / 'PX4-quadrotor-example-log_vehicle_gps_position_0.csv'
5
6
df_gps = pl.read_csv(full_path)
7
8
lat_normalized = pl.Series("lat_normalized", df_gps['lat']/10e6)
9
lon_normalized = pl.Series("lon_normalized", df_gps['lon']/10e6)
10
11
df_gps = df_gps.with_columns([
12
    lat_normalized,
13
    lon_normalized
14
])
15
16
df_gps.head().select(df_gps.columns[:6])

1
import plotly.express as px
2
import plotly.io as pio
3
pio.templates.default = 'plotly_dark'
4
5
fig = px.line(df_gps, x='lon_normalized', y='lat_normalized', width=500, height=500)
6
7
fig.write_image('drone_gps_flight.svg')
8
fig.show()

1
from nominal.core import NominalClient
2
3
client = NominalClient.from_profile("default")
4
5
dataset = client.create_dataset(name = 'PX4 GPS Sensor data')
6
7
dataset.add_tabular_data(
8
    path = full_path,
9
    timestamp_column = 'time_utc_usec',
10
    timestamp_type = 'epoch_microseconds',
11
)
12
13
print('Uploaded dataset:', dataset.rid)

1
import polars as pl
2
from pathlib import Path
3
import traceback
4
5
log_names = []
6
time_range_mins = []
7
time_range_maxs = []
8
log_path = []
9
10
for file in files:
11
    full_path = folder_path / file.name
12
    try:
13
        df_csv = pl.read_csv(full_path)
14
        if 'timestamp' in df_csv.columns:
15
            log_path.append(full_path)
16
            log_names.append(file.name.strip('PX4-quadrotor-example-log'))
17
            time_range_mins.append(df_csv['timestamp'].min())
18
            time_range_maxs.append(df_csv['timestamp'].max())
19
    except:
20
        pass
21
22
df_log_time_ranges = pl.DataFrame({
23
    "log_files": log_names,
24
    "min_micro_s": time_range_mins,
25
    "max_micro_s": time_range_maxs,
26
    "log_path": log_path
27
})

1
logs_to_filter = ["_mission_result_0.csv", "_sensor_correction_0.csv", "_sensor_selection_0.csv", "_mission_0.csv"]
2
df_filtered_logs = df_log_time_ranges.filter(pl.col("log_files").is_in(logs_to_filter) == False)

1
fig = px.scatter(df_filtered_logs.drop('log_path'),
2
           x = 'log_files',
3
           y = ['min_micro_s', 'max_micro_s'],
4
           height = 600,
5
           log_y = True,
6
           title = 'Flight log start and end times')
7
8
fig.update_layout(showlegend=False)
9
fig.update_layout(yaxis_title='Log time span (microseconds)')
10
fig.write_image('flight_log_start_and_end_times.png')
11
fig.show()

1
from datetime import datetime, UTC
2
3
def convert_micro_s_to_hours_minutes_seconds(micro_s):
4
    total_seconds = micro_s // 1000 // 1000
5
    hours = total_seconds // 3600
6
    minutes = (total_seconds % 3600) // 60
7
    seconds = total_seconds % 60
8
    return hours, minutes, seconds
9
10
timestamp_seconds = df_gps['time_utc_usec'].min() / 1_000_000
11
dt_flight_start = datetime.fromtimestamp(timestamp_seconds, UTC)
12
dt_flight_duration_micro_s = df_filtered_logs['max_micro_s'].max() - df_filtered_logs['min_micro_s'].min()
13
hours, minutes, seconds = convert_micro_s_to_hours_minutes_seconds(dt_flight_duration_micro_s)
14
15
print(f"Flight start time in UTC: {dt_flight_start}")
16
print(f"Flight duration: {hours}h {minutes}m {seconds}s")

1
from nominal.core import NominalClient
2
from datetime import timedelta
3
4
client = NominalClient.from_profile("default")
5
6
quadrotor_run = client.create_run(
7
    name = 'PX4 single quadrotor flight',
8
    start = dt_flight_start,
9
    end = dt_flight_start + timedelta(microseconds=dt_flight_duration_ms),
10
    description = 'https://logs.px4.io/plot_app?log=89b87d6f-d286-4703-b36b-573191a907f1',
11
)

1
import traceback
2
3
log_files = {}
4
5
# Add logs to the dataset
6
for row in df_filtered_logs.iter_rows():
7
    file_name = row[0]
8
    full_path = row[3]
9
    df_csv = pl.read_csv(full_path)
10
    if 'timestamp' in df_csv.columns:
11
        try:
12
            ref_name = '-'.join(file_name.split('_')[1:-1])
13
            csv_name = f'{ref_name}.csv'
14
15
            if ref_name in log_files:{
16
                dataset = log_files[ref_name]
17
            else:
18
                print('\nCreating dataset:', csv_name)
19
                dataset = client.create_dataset(name=csv_name)
20
                log_files[ref_name] = dataset
21
22
            print(f'Adding `{file_name}` to dataset `{csv_name}`')
23
            dataset.add_tabular_data(
24
                path=full_path,
25
                timestamp_column = 'timestamp',
26
                timestamp_type = 'epoch_microseconds'
27
            )
28
        except:
29
            print('Error uploading: ', file_name)
30
            print(traceback.format_exc())
31
32
print()
33
for ref_name, dataset in log_files.items():
34
    print(f'Adding dataset `{dataset.name}` to run with ref_name `{ref_name}`')
35
    quadrotor_run.add_dataset(
36
        ref_name=ref_name,
37
        dataset=dataset
38
    )

1
import subprocess
2
result = subprocess.run(["ulog_info", "-v", ulog_path], capture_output=True, text=True)
3
print(result.stdout)