ccl.proto

// Copyright 2012-2023:
//   GobySoft, LLC (2013-)
//   Massachusetts Institute of Technology (2007-2014)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//   Chris Murphy <cmurphy@aphysci.com>
//
//
// This file is part of the Dynamic Compact Control Language Library
// ("DCCL").
//
// DCCL is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// DCCL is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
syntax = "proto2";
 
import "dccl/ccl/protobuf/ccl_extensions.proto";
import "dccl/option_extensions.proto";
 
package dccl.legacyccl.protobuf;
 
// typedef struct
// {
//   unsigned char mode;
//   char spare[31];
// }
// MODEM_MSG_DATA_EMPTY;
 
message CCLMDATEmpty
{
    // prefix CCL IDs with 0x0CC1 to get out of normal 0x0000 prefix
    option (dccl.msg).id = 0x0CC10006;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required bytes spare = 1 [(dccl.field).max_length = 31];
}
 
// typedef struct
// {
//   unsigned char mode;
//   // MDAT_REDIRECT
//   unsigned char message_number;
//   LATLON_COMPRESSED lat;
//   // Center of search area
//   LATLON_COMPRESSED lon;
//   // Center of search area
//   char speed_depth_flags;
//   unsigned short depth_goal_encoded_transit;
//   char speed_encoded_transit;
//   unsigned char device_cmd_transit;
//   // Sidescan, DIDSON range.
//   unsigned short depth_goal_encoded_survey;
//   char speed_encoded_survey;
//   unsigned char device_cmd_survey;
//   // Sidescan, DIDSON range.
//   unsigned char num_rows;
//   // 0 if not rows.
//   unsigned short row_length;
//   // in meters
//   unsigned char spacing_0;
//   // in meters
//   unsigned char spacing_1;
//   // in meters
//   char heading_encoded;
//   LATLON_COMPRESSED lat_start;
//   // ack only, where redirect started
//   LATLON_COMPRESSED lon_start;
//   char spare[3];
// }
// MODEM_MSG_DATA_REDIRECT;
message CCLMDATRedirect
{
    option (dccl.msg).id = 0x0CC10007;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required uint32 message_number = 1
        [(dccl.field).min = 0, (dccl.field).max = 0xff];
 
    required double latitude = 2 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).description = "Center of search area: latitude in degrees"
    ];
 
    required double longitude = 3 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).description = "Center of search area: longitude in degrees"
    ];
 
    // replaces speed_depth_flags field
    enum VerticalMode
    {
        DEPTH = 0;
        ALTITUDE = 1;
        RESERVED_2 = 2;
        RESERVED_3 = 3;
        RESERVED_4 = 4;
        RESERVED_5 = 5;
        RESERVED_6 = 6;
        RESERVED_7 = 7;
    }
    enum ThrustMode
    {
        RPM = 0;
        METERS_PER_SECOND = 1;
    }
 
    required VerticalMode transit_vertical_mode = 4;
    required ThrustMode transit_thrust_mode = 5;
    required VerticalMode survey_vertical_mode = 6;
    required ThrustMode survey_thrust_mode = 7;
 
    required float depth_goal_transit = 8
        [(dccl.field).codec = "_ccl_depth", (dccl.field).(ccl).bit_size = 16];
 
    required float speed_transit = 9 [
        (dccl.field).codec = "_ccl_speed",
        (dccl.field).(ccl).thrust_mode_tag = 5
    ];
 
    required uint32 device_cmd_transit = 10
        [(dccl.field).min = 0, (dccl.field).max = 0xff];
 
    required float depth_goal_survey = 11
        [(dccl.field).codec = "_ccl_depth", (dccl.field).(ccl).bit_size = 16];
 
    required float speed_survey = 12 [
        (dccl.field).codec = "_ccl_speed",
        (dccl.field).(ccl).thrust_mode_tag = 7
    ];
 
    required uint32 device_cmd_survey = 13
        [(dccl.field).min = 0, (dccl.field).max = 0xff];
 
    required uint32 num_rows = 14
        [(dccl.field).min = 0, (dccl.field).max = 0xff];
 
    required uint32 row_length = 15
        [(dccl.field).min = 0, (dccl.field).max = 0xffff];
 
    required uint32 spacing_0 = 16
        [(dccl.field).min = 0, (dccl.field).max = 0xff];
 
    required uint32 spacing_1 = 17
        [(dccl.field).min = 0, (dccl.field).max = 0xff];
 
    required float heading = 18 [
        (dccl.field).codec = "_ccl_heading",
        (dccl.field).description = "Heading in degrees"
    ];
 
    required double lat_start = 19
        [(dccl.field).codec = "_ccl_latloncompressed"];
    required double lon_start = 20
        [(dccl.field).codec = "_ccl_latloncompressed"];
 
    required bytes spare = 21 [(dccl.field).max_length = 3];
}
 
// typedef struct
// {
//   unsigned char mode;
//   unsigned char spare;
//   unsigned short depth[3];
//   unsigned short altitude[3];
//   LATLON_COMPRESSED latitude[3];
//   LATLON_COMPRESSED longitude[3];
// }
// MODEM_MSG_DATA_BATHY;
message CCLMDATBathy
{
    option (dccl.msg).id = 0x0CC10009;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required bytes spare = 1 [(dccl.field).max_length = 1];
 
    repeated float depth = 2 [
        (dccl.field).codec = "_ccl_depth",
        (dccl.field).(ccl).bit_size = 16,
        (dccl.field).max_repeat = 3
    ];
 
    repeated float altitude = 3 [
        (dccl.field).codec = "_ccl_hires_altitude",
        (dccl.field).max_repeat = 3
    ];
 
    repeated double latitude = 4 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).max_repeat = 3
    ];
 
    repeated double longitude = 5 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).max_repeat = 3
    ];
}
 
// typedef struct
// {
// unsigned char mode;
// // MDAT_CTD
// unsigned char spare;
// unsigned char salinity[2];
// unsigned char temperature[2];
// unsigned short depth[2];
// unsigned char sound_speed[2];
// LATLON_COMPRESSED latitude[2];
// LATLON_COMPRESSED longitude[2];
// char spare2[8];
// }
// MODEM_MSG_DATA_CTD;
 
// untested, CCL spec does not give test case
message CCLMDATCTD
{
    option (dccl.msg).id = 0x0CC1000A;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required bytes spare = 1 [(dccl.field).max_length = 1];
 
    repeated float salinity = 2
        [(dccl.field).codec = "_ccl_salinity", (dccl.field).max_repeat = 2];
 
    repeated float temperature = 3
        [(dccl.field).codec = "_ccl_temperature", (dccl.field).max_repeat = 2];
 
    repeated float depth = 4 [
        (dccl.field).codec = "_ccl_depth",
        (dccl.field).(ccl).bit_size = 16,
        (dccl.field).max_repeat = 2
    ];
 
    repeated float sound_speed = 5
        [(dccl.field).codec = "_ccl_sound_speed", (dccl.field).max_repeat = 2];
 
    repeated double latitude = 6 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).max_repeat = 2
    ];
 
    repeated double longitude = 7 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).max_repeat = 2
    ];
 
    required bytes spare2 = 8 [(dccl.field).max_length = 8];
}
 
// typedef struct
// {
// unsigned char mode;
// unsigned char spare;
// unsigned short command;
// char parameter[28];
// }
// MODEM_MSG_DATA_COMMAND;
message CCLMDATCommand
{
    option (dccl.msg).id = 0x0CC1000B;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required bytes spare = 1 [(dccl.field).max_length = 1];
 
    enum Command
    {
        RESERVED_0 = 0;
        ABORT_TO_END_POSITION_OF_MISSION = 1;
        ABORT_IMMEDIATELY = 2;
        START_MISSION = 3;
        RELEASE_DESCENT_WEIGHT = 4;
        RELEASE_ASCENT_WEIGHT = 5;
        RELEASE_PICKUP_FLOAT = 6;
        ENABLE_MODEM_RANGER_PING = 7;
        DISABLE_MODEM_RANGER_PING = 8;
        OBSOLETE_9 = 9;
        OBSOLETE_10 = 10;
        OBSOLETE_11 = 11;
        OBSOLETE_12 = 12;
        OBSOLETE_13 = 13;
        ACCEPT_NEXT_FIX = 14;
        DUMP_REDIRECT_COMMANDS = 15;
        GET_GPS_FIX = 16;
        ABORT_TO_MISSION_START_LOCATION = 17;
        ABORT_TO_DESTINATION = 18;
        DUMP_REDIRECT_COMMANDS_EXCEPT_CURRENT = 19;
        ABORT_DROP_ASCENT_WEIGHT_AND_POWER_TO_SURFACE = 20;
        RESERVED_21 = 21;
        RESERVED_22 = 22;
        RESERVED_23 = 23;
        RESERVED_24 = 24;
        RESERVED_25 = 25;
        RESERVED_26 = 26;
        RESERVED_27 = 27;
        RESERVED_28 = 28;
        RESERVED_29 = 29;
        RESERVED_30 = 30;
        RESERVED_31 = 31;
    }
    required Command command = 2;
 
    // placeholder for the unenumerated commands
    required uint32 reserved_command = 3
        [(dccl.field).min = 0, (dccl.field).max = 0x7ff];
 
    required bytes parameter = 4 [(dccl.field).max_length = 28];
}
 
// typedef struct
// {
//     unsigned char     mode;
//     // MDAT_STATE
//     LATLON_COMPRESSED latitude;
//     // 3 bytes
//     LATLON_COMPRESSED longitude;
//       unsigned char     fix_age
//       TIME_DATE         time_date;
//     // 3 bytes;
//     unsigned char     heading;
//     // 1.5 degree resolution
//     unsigned short    mission_mode_depth;
//     //
//     unsigned long     faults;
//     unsigned char     faults_2;
//     unsigned char     mission_leg;
//     char              est_velocity;
//     char              objective_index;
//     unsigned char     watts_encoded;
//     LATLON_COMPRESSED lat_goal;
//     // 3 bytes
//     LATLON_COMPRESSED lon_goal;
//     // 3 bytes
//     unsigned char     battery_percent;
//     unsigned short    gfi_pitch_oil_encoded;
//     // 5 bits gfi,6 bits pitch,
//     // 5 bits oil
// }
// MODEM_MSG_DATA_STATE;
 
message CCLMDATState
{
    option (dccl.msg).id = 0x0CC1000E;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required double latitude = 1 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).description = "Latitude in degrees"
    ];
 
    required double longitude = 2 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).description = "Longitude in degrees"
    ];
 
    required uint32 fix_age = 3 [
        (dccl.field).codec = "_ccl_fix_age",
        (dccl.field).description = "Fix age in seconds"
    ];
 
    required uint64 time_date = 4 [
        (dccl.field).codec = "_ccl_time_date",
        (dccl.field).description =
            "Microseconds since UNIX 1970/01/01 00:00:00 UTC"
    ];
    required float heading = 5 [
        (dccl.field).codec = "_ccl_heading",
        (dccl.field).description = "Heading in degrees"
    ];
    required float depth = 6 [
        (dccl.field).codec = "_ccl_depth",
        (dccl.field).description = "Depth in meters",
        (dccl.field).(ccl).bit_size = 13
    ];  // 13 since MissionMode is stuck in the top three bits
 
    enum MissionMode
    {
        MISSION_COMPLETED = 0;
        MANUAL_MODE = 1;
        TEST = 2;
        FAULT = 3;
        UNKNOWN_MODE_4 = 4;
        REDIRECT_MISSION_IN_PROGRESS = 5;
        NORMAL = 6;
        UNKNOWN_MODE_7 = 7;
    };
 
    required MissionMode mission_mode = 7;
 
    required bytes faults = 8 [(dccl.field).max_length = 4];
    required bytes faults_2 = 9 [(dccl.field).max_length = 1];
    required uint32 mission_leg = 10
        [(dccl.field).max = 0xff, (dccl.field).min = 0];
    required float est_velocity = 11 [
        (dccl.field).codec = "_ccl_velocity",
        (dccl.field).description = "Velocity from ADCP or prop turns in m/s"
    ];
    required bytes objective_index = 12 [(dccl.field).max_length = 1];
    required float watts = 13 [(dccl.field).codec = "_ccl_watts"];
    required double lat_goal = 14 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).description = "Latitude goal in degrees"
    ];
    required double lon_goal = 15 [
        (dccl.field).codec = "_ccl_latloncompressed",
        (dccl.field).description = "Longitude goal in degrees"
    ];
    required uint32 battery_percent = 16
        [(dccl.field).max = 0xff, (dccl.field).min = 0];
 
    message GFIPitchOil
    {
        required float gfi = 1
            [(dccl.field).description = "Percentage ground fault (0-100)"];
        required float pitch = 2
            [(dccl.field).description = "Pitch of the vehicle in degrees"];
        required float oil = 3 [
            (dccl.field).description =
                "Percentage of the available capacity remaining in the oil compensation system, or 0 if no such system"
        ];
    }
    required GFIPitchOil gfi_pitch_oil = 17
        [(dccl.field).codec = "_ccl_gfi_pitch_oil"];
}
 
// typedef struct
// {
// unsigned char mode;
// char message[31];
// }
// MODEM_MSG_ERROR_MSG;
message CCLMDATError
{
    // prefix CCL IDs with 0x0CC1 to get out of normal 0x0000 prefix
    option (dccl.msg).id = 0x0CC1000F;
    option (dccl.msg).max_bytes = 32;
    option (dccl.msg).codec_version = 2;
 
    required bytes message = 1 [(dccl.field).max_length = 31];
}