Method handle_data_notification

src/board_controller/muse/muse_athena.cpp:643–730

}

void MuseAthena::handle_data_notification (const uint8_t *data, size_t size)
{
    std::lock_guard<std::mutex> callback_guard (callback_lock);

    size_t offset = 0;
    while (offset < size)
    {
        if (size - offset < PACKET_HEADER_SIZE)
        {
            safe_logger (spdlog::level::warn, "Short Athena message tail: {} bytes", size - offset);
            return;
        }

        uint8_t packet_len = data[offset];
        if ((packet_len < PACKET_HEADER_SIZE) || (offset + packet_len > size))
        {
            safe_logger (spdlog::level::warn, "Invalid Athena packet length: {}", packet_len);
            return;
        }

        const uint8_t *packet = data + offset;
        uint16_t packet_index =
            cast_16bit_to_uint16_little_endian ((const unsigned char *)(packet + 1));
        double packet_host_timestamp = get_timestamp ();
        uint8_t primary_tag = packet[9];
        uint8_t primary_block_index = packet[10];
        uint32_t primary_package_num = ((uint32_t)packet_index << 8) | primary_block_index;
        const uint8_t *packet_data = packet + PACKET_HEADER_SIZE;
        size_t packet_data_size = packet_len - PACKET_HEADER_SIZE;
        size_t packet_data_offset = 0;

        SensorConfig primary_config;
        if (get_sensor_config (primary_tag, primary_config))
        {
            size_t primary_data_len =
                primary_config.variable_length ? packet_data_size : primary_config.data_len;
            if ((primary_data_len > 0) && (primary_data_len <= packet_data_size))
            {
                parse_sensor_payload (primary_tag, primary_package_num, packet_host_timestamp,
                    packet_data, primary_data_len);
                packet_data_offset = primary_data_len;
            }
            else
            {
                safe_logger (spdlog::level::warn,
                    "Invalid Athena primary payload for tag 0x{:02x}: {} bytes",
                    (unsigned int)primary_tag, packet_data_size);
                packet_data_offset = packet_data_size;
            }
        }
        else
        {
            safe_logger (spdlog::level::trace, "Unknown Athena primary tag: 0x{:02x}",
                (unsigned int)primary_tag);
            packet_data_offset = packet_data_size;
        }

        while (packet_data_offset + SUBPACKET_HEADER_SIZE <= packet_data_size)