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
import nominal as nm
2
3
dataset = nm.upload_csv(
4
    full_path,
5
    name='PX4 GPS Sensor data',
6
    timestamp_column='time_utc_usec',
7
    timestamp_type='epoch_microseconds',
8
)
9
10
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}")
16
print(f"Flight duration: {hours} h, {minutes} m, {seconds} s")

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

1
import traceback
2
import nominal as nm
3
4
rids = dict()
5
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
            csv_dataset = nm.upload_csv(
13
                file = full_path,
14
                name = file_name,
15
                timestamp_column = 'timestamp',
16
                timestamp_type = 'relative_microseconds'
17
            )
18
            print('Adding Dataset to Run: ', file_name)
19
            quadrotor_run.add_dataset(
20
                dataset = csv_dataset,
21
                ref_name = file_name
22
            )
23
        except:
24
            print('Error uploading: ', file_name)
25
            print(traceback.format_exc())

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