cs_MeshModelPackets.h

Go to the documentation of this file.

 
#pragma once
 
#include <mesh/cs_MeshDefines.h>
#include <protocol/cs_AssetFilterPackets.h>
#include <protocol/cs_CmdSource.h>
#include <protocol/cs_RssiAndChannel.h>
#include <protocol/cs_Typedefs.h>
 
enum cs_mesh_model_id_t {
    CS_MESH_MODEL_ID_MULTICAST       = 0,
    CS_MESH_MODEL_ID_MULTICAST_ACKED = 1,
    CS_MESH_MODEL_ID_UNICAST         = 2,
    CS_MESH_MODEL_ID_NEIGHBOURS      = 3,
};
 
enum cs_mesh_model_opcode_t {
    CS_MESH_MODEL_OPCODE_MSG                    = 0xC0,
    CS_MESH_MODEL_OPCODE_UNICAST_RELIABLE_MSG   = 0xC1,
    CS_MESH_MODEL_OPCODE_UNICAST_REPLY          = 0xC2,
    CS_MESH_MODEL_OPCODE_MULTICAST_RELIABLE_MSG = 0xC3,
    CS_MESH_MODEL_OPCODE_MULTICAST_REPLY        = 0xC4,
    CS_MESH_MODEL_OPCODE_MULTICAST_NEIGHBOURS   = 0xC5,
};
 
static constexpr uint8_t MAX_MESH_MSG_SIZE               = 3 * 12 - 4 - 3;
static constexpr uint8_t MAX_MESH_MSG_NON_SEGMENTED_SIZE = 15 - 4 - 3;
 
static constexpr uint8_t MESH_HEADER_SIZE                = 1;
 
static constexpr uint8_t MAX_MESH_MSG_PAYLOAD_SIZE       = MAX_MESH_MSG_NON_SEGMENTED_SIZE - MESH_HEADER_SIZE;
 
enum cs_mesh_model_msg_type_t {
    CS_MESH_MODEL_TYPE_TEST                     = 0,  // Payload: cs_mesh_model_msg_test_t
    CS_MESH_MODEL_TYPE_ACK                      = 1,  // Payload: none
    CS_MESH_MODEL_TYPE_CMD_TIME                 = 3,  // Payload: cs_mesh_model_msg_time_t
    CS_MESH_MODEL_TYPE_CMD_NOOP                 = 4,  // Payload: none
    CS_MESH_MODEL_TYPE_CMD_MULTI_SWITCH         = 5,  // Payload: cs_mesh_model_msg_multi_switch_item_t
    //  CS_MESH_MODEL_TYPE_CMD_KEEP_ALIVE_STATE      = 6,  // Payload: keep_alive_state_item_t
    //  CS_MESH_MODEL_TYPE_CMD_KEEP_ALIVE            = 7,  // Payload: none
    CS_MESH_MODEL_TYPE_STATE_0                  = 8,   // Payload: cs_mesh_model_msg_state_0_t
    CS_MESH_MODEL_TYPE_STATE_1                  = 9,   // Payload: cs_mesh_model_msg_state_1_t
    CS_MESH_MODEL_TYPE_PROFILE_LOCATION         = 10,  // Payload: cs_mesh_model_msg_profile_location_t
    CS_MESH_MODEL_TYPE_SET_BEHAVIOUR_SETTINGS   = 11,  // Payload: behaviour_settings_t
    CS_MESH_MODEL_TYPE_TRACKED_DEVICE_REGISTER  = 12,  // Payload: cs_mesh_model_msg_device_register_t
    CS_MESH_MODEL_TYPE_TRACKED_DEVICE_TOKEN     = 13,  // Payload: cs_mesh_model_msg_device_token_t
    CS_MESH_MODEL_TYPE_SYNC_REQUEST             = 14,  // Payload: cs_mesh_model_msg_sync_request_t
    //  CS_MESH_MODEL_TYPE_SYNC_RESPONSE             = 15, // Payload: cs_mesh_model_msg_sync_response_t
    CS_MESH_MODEL_TYPE_TRACKED_DEVICE_LIST_SIZE = 16,  // Payload: cs_mesh_model_msg_device_list_size_t
    CS_MESH_MODEL_TYPE_STATE_SET                = 17,  // Payload: cs_mesh_model_msg_state_header_ext_t + payload
    CS_MESH_MODEL_TYPE_RESULT                   = 18,  // Payload: cs_mesh_model_msg_result_header_t + payload
    CS_MESH_MODEL_TYPE_SET_IBEACON_CONFIG_ID    = 19,  // Payload: set_ibeacon_config_id_packet_t
    CS_MESH_MODEL_TYPE_TRACKED_DEVICE_HEARTBEAT = 20,  // Payload: cs_mesh_model_msg_device_heartbeat_t
    CS_MESH_MODEL_TYPE_RSSI_PING =
            21,  // Payload: rssi_ping_message_t                             Only used in MeshTopologyResearch
    CS_MESH_MODEL_TYPE_TIME_SYNC = 22,  // Payload: cs_mesh_model_msg_time_sync_t
    // 23 removed
    CS_MESH_MODEL_TYPE_RSSI_DATA =
            24,  // Payload: rssi_data_message_t                             Only used in MeshTopologyResearch
    CS_MESH_MODEL_TYPE_STONE_MAC            = 25,  // Payload: cs_mesh_model_msg_stone_mac_t
    CS_MESH_MODEL_TYPE_ASSET_FILTER_VERSION = 26,  // Payload: cs_mesh_model_msg_asset_filter_version_t
    CS_MESH_MODEL_TYPE_ASSET_INFO_MAC       = 27,  // Payload: cs_mesh_model_msg_asset_report_mac_t
    CS_MESH_MODEL_TYPE_NEIGHBOUR_RSSI       = 28,  // Payload: cs_mesh_model_msg_neighbour_rssi_t
    CS_MESH_MODEL_TYPE_CTRL_CMD             = 29,  // Payload: cs_mesh_model_msg_ctrl_cmd_header_ext_t + payload
    CS_MESH_MODEL_TYPE_ASSET_INFO_ID        = 30,  // Payload: cs_mesh_model_msg_asset_report_id_t
 
    CS_MESH_MODEL_TYPE_MICROAPP             = 200,  // Payload: anything.
    CS_MESH_MODEL_TYPE_UNKNOWN              = 255
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_test_t {
    uint32_t counter;
#if MESH_MODEL_TEST_MSG == 2
    //  uint8_t dummy[3]; // non segmented
    //  uint8_t dummy[12]; // 2 segments
    uint8_t dummy[24];  // 3 segments
#else
    uint8_t dummy[3];  // non segmented
#endif
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_time_t {
    uint32_t timestamp;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_profile_location_t {
    uint8_t profile;
    uint8_t location;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_state_0_t {
    uint8_t switchState;
    uint8_t flags;
    int8_t powerFactor;
    int16_t powerUsageReal;
    uint16_t partialTimestamp;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_state_1_t {
    int8_t temperature;
    int32_t energyUsed;
    uint16_t partialTimestamp;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_multi_switch_item_t {
    stone_id_t id;
    uint8_t switchCmd;
    uint16_t delay = 0;  // Deprecated, set to 0 or backwards compatibility.
    cmd_source_with_counter_t source;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_device_register_t {
    device_id_t deviceId;
    uint8_t locationId;
    uint8_t profileId;
    int8_t rssiOffset;
    uint8_t flags;
    uint8_t accessLevel;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_device_token_t {
    device_id_t deviceId;
    uint8_t deviceToken[TRACKED_DEVICE_TOKEN_SIZE];
    uint16_t ttlMinutes;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_device_heartbeat_t {
    device_id_t deviceId;
    uint8_t locationId;
    uint8_t ttlMinutes;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_device_list_size_t {
    uint8_t listSize;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_sync_request_t {
    stone_id_t id;
    union __attribute__((__packed__)) {
        struct __attribute__((packed)) {
            bool time : 1;
            bool trackedDevices : 1;
            bool behaviourSettings : 1;
        } bits;
        uint32_t bitmask;
    };
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_state_header_t {
    uint8_t type;                 // Shortened version of CS_TYPE
    uint8_t id : 6;               // Shortened version of state id.
    uint8_t persistenceMode : 2;  // Shortened version of peristenceMode.
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_state_header_ext_t {
    cs_mesh_model_msg_state_header_t header;
    uint8_t accessLevel : 3;  // Shortened version of access level.
    uint8_t sourceId : 5;     // Shortened version of source.
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_ctrl_cmd_header_t {
    uint16_t cmdType;  // CommandHandlerTypes
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_ctrl_cmd_header_ext_t {
    cs_mesh_model_msg_ctrl_cmd_header_t header;
    uint8_t accessLevel : 3;  // Shortened version of access level.
    uint8_t sourceId : 5;     // Shortened version of source.
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_result_header_t {
    uint8_t msgType;  // Mesh msg type of which this is the result.
    uint8_t retCode;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_time_sync_t {
    uint32_t posix_s;        // Seconds since epoch.
    uint16_t posix_ms : 10;  // Milliseconds passed since posix_s.
    uint8_t version : 6;     // Synchronization version,
    bool overrideRoot : 1;   // Whether this time overrides the root time.
    uint8_t reserved : 7;    // @arend maybe use these bits to increase version size.
};
 
struct __attribute__((__packed__)) mac_address_t {
    uint8_t data[MAC_ADDRESS_LEN];
 
    void copyFrom(const void* macAddress) { memcpy(data, macAddress, MAC_ADDRESS_LEN); }
 
    bool operator==(const mac_address_t& other) { return memcmp(this, &other, MAC_ADDRESS_LEN) == 0; }
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_asset_report_mac_t {
    mac_address_t mac;
    rssi_and_channel_t rssiData;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_asset_report_id_t {
    asset_id_t id;
    uint8_t filterBitmask;
    int8_t rssi;  // TODO: why not the full rssi here, and put the channel in the reserved bytes?
    union {
        struct {
            uint16_t channel : 2;
            uint16_t reserved : 14;  // Must be 0 for now.
        };
        uint16_t asInt = 0;
    };
};
 
struct __attribute__((__packed__)) rssi_ping_message_t {};
 
struct __attribute__((__packed__)) rssi_data_t {
    uint16_t variance : 3;
 
    uint16_t rssi : 7;
 
    uint16_t sampleCount : 6;
};
 
struct __attribute__((__packed__)) rssi_data_message_t {
    stone_id_t sender_id;
    rssi_data_t channel37;
    rssi_data_t channel38;
    rssi_data_t channel39;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_neighbour_rssi_t {
    uint8_t type = 0;  // Type of report, always 0 for now.
    stone_id_t neighbourId;
    int8_t rssiChannel37;
    int8_t rssiChannel38;
    int8_t rssiChannel39;
    uint8_t lastSeenSecondsAgo;
    uint8_t counter;  // Message counter, to identify package loss at the receiving node.
 
    // Possible future type:
    //   uint8_t type : 4;
    //   uint8_t rssiChannel37 : 6;
    //   uint8_t rssiChannel38 : 6;
    //   uint8_t rssiChannel39 : 6;
    //   uint8_t avgRssiChannel37 : 6;
    //   uint8_t avgRssiChannel38 : 6;
    //   uint8_t avgRssiChannel39 : 6;
    //   stone_id_t neighbourId;
    //   uint8_t lastSeenSecondsAgo;
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_stone_mac_t {
    uint8_t type;  // 0 = request, 1 = reply.
    uint8_t connectionProtocol = CS_CONNECTION_PROTOCOL_VERSION;
    uint8_t reserved[5];  // Allows for larger payloads for future types. Set to 0 for now.
};
 
struct __attribute__((__packed__)) cs_mesh_model_msg_asset_filter_version_t {
    asset_filter_cmd_protocol_t protocol;
    uint16_t masterVersion;
    uint32_t masterCrc;
};