cs_PacketsInternal.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: May 17, 2019
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
#pragma once
 
#include <protocol/cs_ErrorCodes.h>
#include <protocol/cs_Packets.h>
 
struct cs_data_t {
    buffer_ptr_t data    = nullptr; 
    cs_buffer_size_t len = 0;       
    cs_data_t() : data(nullptr), len(0) {}
    cs_data_t(buffer_ptr_t buf, cs_buffer_size_t size) : data(buf), len(size) {}
};
 
struct cs_const_data_t {
    const uint8_t* data  = nullptr; 
    cs_buffer_size_t len = 0;       
    cs_const_data_t() : data(nullptr), len(0) {}
    cs_const_data_t(const uint8_t* buf, cs_buffer_size_t size) : data(buf), len(size) {}
};
 
struct cs_result_t {
    cs_ret_code_t returnCode = ERR_EVENT_UNHANDLED;
 
    cs_data_t buf;
 
    cs_buffer_size_t dataSize = 0;
 
    cs_result_t() : buf() {}
    cs_result_t(cs_data_t buf) : buf(buf) {}
    cs_result_t(cs_ret_code_t returnCode) : returnCode(returnCode), buf() {}
};
 
struct cs_async_result_t {
    CommandHandlerTypes commandType;
    cs_ret_code_t resultCode;
    cs_data_t resultData;
 
    cs_async_result_t(CommandHandlerTypes type, cs_ret_code_t resultCode)
            : commandType(type), resultCode(resultCode), resultData() {}
    cs_async_result_t(CommandHandlerTypes type, cs_ret_code_t resultCode, cs_data_t data)
            : commandType(type), resultCode(resultCode), resultData(data) {}
};
 
enum CS_ADDRESS_TYPE {
    CS_ADDRESS_TYPE_PUBLIC                        = 0,     // Public (registered) static address.
    CS_ADDRESS_TYPE_RANDOM_STATIC                 = 1,     // Random static address (can only change at boot).
    CS_ADDRESS_TYPE_RANDOM_PRIVATE_RESOLVABLE     = 2,     // Random resolvable address (can change at any moment).
    CS_ADDRESS_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE = 3,     // Random address (can change at any moment).
    CS_ADDRESS_TYPE_ANONYMOUS                     = 0x7F,  // No address is advertised.
};
 
struct __attribute__((packed)) device_address_t {
    uint8_t address[MAC_ADDRESS_LEN];
    uint8_t addressType = CS_ADDRESS_TYPE_RANDOM_STATIC;
};
 
struct __attribute__((packed)) scanned_device_t {
    int8_t rssi;
    uint8_t address[MAC_ADDRESS_LEN];
    bool resolvedPrivateAddress;
    uint8_t addressType;  // See CS_ADDRESS_TYPE
    uint8_t channel;
    uint8_t setId;
    uint8_t advType;
    uint8_t dataSize;
    uint8_t* data;  // Advertisement or scan response data.
    // More possibilities: addressType, connectable, isScanResponse, directed, scannable, extended advertisements, etc.
};
 
struct __attribute__((packed)) internal_multi_switch_item_cmd_t {
    uint8_t switchCmd;
};
 
struct __attribute__((packed)) internal_multi_switch_item_t {
    stone_id_t id;
    internal_multi_switch_item_cmd_t cmd;
};
 
inline bool cs_multi_switch_item_is_valid(internal_multi_switch_item_t* item, size16_t size) {
    return (size == sizeof(internal_multi_switch_item_t) && item->id != 0);
}
 
struct __attribute__((packed)) control_command_packet_t {
    uint8_t protocolVersion = CS_CONNECTION_PROTOCOL_VERSION;
    CommandHandlerTypes type;
    buffer_ptr_t data;
    size16_t size;
    EncryptionAccessLevel accessLevel;
};
 
struct __attribute__((__packed__)) mesh_control_command_packet_t {
    mesh_control_command_packet_header_t header;
    stone_id_t* targetIds;
    control_command_packet_t controlCommand;
};
 
enum cs_mesh_msg_reliability : uint8_t {
    CS_MESH_RELIABILITY_INVALID = 0,
    CS_MESH_RELIABILITY_LOWEST  = 1,
    CS_MESH_RELIABILITY_LOW     = 3,
    CS_MESH_RELIABILITY_MEDIUM  = 5,
    CS_MESH_RELIABILITY_HIGH    = 10,
};
 
enum cs_mesh_msg_urgency {
    CS_MESH_URGENCY_LOW,
    CS_MESH_URGENCY_HIGH,
};
 
struct cs_mesh_msg_t {
    cs_mesh_model_msg_type_t type;
    mesh_control_command_packet_flags_t flags;
    uint8_t reliability         = 0;
    cs_mesh_msg_urgency urgency = CS_MESH_URGENCY_LOW;
    uint8_t idCount             = 0;
    stone_id_t* targetIds       = nullptr;
    size16_t size               = 0;
    uint8_t* payload            = nullptr;
};
 
struct state_external_stone_t {
    service_data_encrypted_t data;
};
 
struct ble_connected_t {
    uint16_t connectionHandle;
    uint8_t advertisementHandle;
    cs_data_t advertisementBuffer;
    cs_data_t scanResponseBuffer;
    device_address_t address;
};
 
struct __attribute__((__packed__)) adv_background_t {
    uint8_t protocol;
    uint8_t sphereId;
    uint8_t* data;
    uint8_t dataSize;
    uint8_t* macAddress;
    int8_t rssi;
};
 
struct __attribute__((__packed__)) adv_background_parsed_t {
    uint8_t* macAddress;
    int8_t adjustedRssi;
    uint8_t locationId;
    uint8_t profileId;
    uint8_t flags;
};
 
struct __attribute__((__packed__)) adv_background_parsed_v1_t {
    uint8_t* macAddress;
    int8_t rssi;
    uint8_t deviceToken[TRACKED_DEVICE_TOKEN_SIZE];
};
 
enum class PresenceMutation : uint8_t {
    NothingChanged,
    Online,   // when no previous PresenceStateDescription was available but now it is
    Offline,  // when a previous PresenceStateDescription was available but now it isn't
    LastUserExitSphere,
    FirstUserEnterSphere,
    OccupiedRoomsMaskChanged,
};
 
struct profile_location_t {
    uint8_t profileId;
    uint8_t locationId;
    bool fromMesh  = false;
    bool simulated = false;
};
 
struct __attribute__((packed)) internal_register_tracked_device_packet_t {
    register_tracked_device_packet_t data;
    uint8_t accessLevel = NOT_SET;
};
 
typedef internal_register_tracked_device_packet_t internal_update_tracked_device_packet_t;
 
struct __attribute__((packed)) internal_tracked_device_heartbeat_packet_t {
    tracked_device_heartbeat_packet_t data;
    uint8_t accessLevel = NOT_SET;
};
 
#define CS_ADC_REF_PIN_NOT_AVAILABLE 255
#define CS_ADC_PIN_VDD 100
 
struct __attribute__((packed)) adc_channel_config_t {
    adc_pin_id_t pin;
    uint32_t rangeMilliVolt;
    adc_pin_id_t referencePin;
};
 
struct __attribute__((packed)) adc_config_t {
    adc_channel_id_t channelCount;
    adc_channel_config_t channels[CS_ADC_NUM_CHANNELS];
    uint32_t samplingIntervalUs;
};
 
struct __attribute__((packed)) adc_channel_config_result_t {
    adc_pin_id_t pin;
    adc_pin_id_t referencePin;
    uint16_t samplingIntervalUs;
    int16_t minValueMilliVolt;
    int16_t maxValueMilliVolt;
    adc_sample_value_t minSampleValue;
    adc_sample_value_t maxSampleValue;
};
 
struct adc_buffer_t {
    bool valid                = false;
 
    adc_buffer_seq_nr_t seqNr = 0;
 
    adc_channel_config_result_t config[CS_ADC_NUM_CHANNELS];
 
    adc_sample_value_t* samples = nullptr;
};
 
struct microapp_advertise_request_t {
    uint8_t type;  // 0 for encrypted service data.
    uint8_t version;
    uint16_t appUuid;
    cs_data_t data;
};
 
struct microapp_upload_internal_t {
    microapp_upload_t header;
    cs_data_t data;
};
 
struct microapp_message_internal_t {
    microapp_ctrl_header_t header;
    cs_data_t payload;
};
 
struct mesh_topo_mac_result_t {
    uint8_t stoneId;
    uint8_t macAddress[MAC_ADDRESS_LEN];
};
 
struct __attribute__((packed)) cs_twi_init_t {
    uint8_t scl;
    uint8_t sda;
    uint8_t freq;
};
 
struct __attribute__((packed)) cs_twi_write_t {
    uint8_t address;
    uint8_t length;
    uint8_t* buf;
    bool stop;
};
 
struct __attribute__((packed)) cs_twi_read_t {
    uint8_t address;
    uint8_t length;
    uint8_t* buf;
    bool stop;
};
 
struct __attribute__((packed)) cs_gpio_init_t {
    uint8_t pinIndex;
    uint8_t direction;
    uint8_t pull;
    uint8_t polarity;
    uintptr_t callback;
};
 
struct __attribute__((packed)) cs_gpio_write_t {
    uint8_t pinIndex;
    uint8_t length;
    uint8_t* buf;
};
 
struct __attribute__((packed)) cs_gpio_read_t {
    uint8_t pinIndex;
    uint8_t length;
    uint8_t* buf;
};
 
struct __attribute__((packed)) cs_gpio_update_t {
    uint8_t pinIndex;
    uint8_t length;
    uint8_t* buf;
};