init

buf.gen.yaml

@@ -0,0 +1,13 @@
+version: v2
+clean: true
+inputs:
+  - git_repo: https://git.quantadev.cc/Quanta/qc2-proto.git
+    branch: main
+    ref: d7ea0cf7cb103cd93b0b9623268e18d26bf01e99
+
+managed:
+  enabled: true
+
+plugins:
+  - remote: buf.build/community/nanopb:v0.4.9
+    out: vendor/protobuf

build.zig

@@ -58,31 +58,29 @@ pub fn build(b: *std.Build) void {
     // If neither case applies to you, feel free to delete the declaration you
     // don't need and to put everything under a single module.
     const exe = b.addExecutable(.{
-        .name = "zig_template",
+        .name = "reader",
         .root_module = b.createModule(.{
-            // b.createModule defines a new module just like b.addModule but,
-            // unlike b.addModule, it does not expose the module to consumers of
-            // this package, which is why in this case we don't have to give it a name.
             .root_source_file = b.path("src/main.zig"),
-            // Target and optimization levels must be explicitly wired in when
-            // defining an executable or library (in the root module), and you
-            // can also hardcode a specific target for an executable or library
-            // definition if desireable (e.g. firmware for embedded devices).
             .target = target,
             .optimize = optimize,
-            // List of modules available for import in source files part of the
-            // root module.
-            .imports = &.{
-                // Here "zig_template" is the name you will use in your source code to
-                // import this module (e.g. `@import("zig_template")`). The name is
-                // repeated because you are allowed to rename your imports, which
-                // can be extremely useful in case of collisions (which can happen
-                // importing modules from different packages).
-                .{ .name = "zig_template", .module = mod },
-            },
         }),
     });
 
+    // Select the right pre-compiled libltkc static archive for the target arch.
+    const arch_suffix: []const u8 = switch (target.result.cpu.arch) {
+        .x86_64 => "x86_64",
+        .x86 => "x86",
+        .arm, .armeb, .thumb, .thumbeb => "armv7l",
+        else => @panic("unsupported target architecture for libltkc vendor libs"),
+    };
+    exe.root_module.addIncludePath(b.path("vendor/libltkc"));
+    exe.addObjectFile(b.path(b.fmt("vendor/libltkc/libltkc_{s}.a", .{arch_suffix})));
+    exe.addObjectFile(b.path(b.fmt("vendor/libltkc/libltkcimpinj_{s}.a", .{arch_suffix})));
+    exe.addObjectFile(b.path(b.fmt("vendor/libltkc/libxml2_{s}.a", .{arch_suffix})));
+    exe.linkSystemLibrary("ssl");
+    exe.linkSystemLibrary("crypto");
+    exe.linkLibC();
+
     // This declares intent for the executable to be installed into the
     // install prefix when running `zig build` (i.e. when executing the default
     // step). By default the install prefix is `zig-out/` but can be overridden

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1772736753,
+        "lastModified": 1773110118,
-        "narHash": "sha256-au/m3+EuBLoSzWUCb64a/MZq6QUtOV8oC0D9tY2scPQ=",
+        "narHash": "sha256-mPAG8phMbCReKSiKAijjjd3v7uVcJOQ75gSjGJjt/Rk=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "917fec990948658ef1ccd07cef2a1ef060786846",
+        "rev": "e607cb5360ff1234862ac9f8839522becb853bb9",
         "type": "github"
       },
       "original": {
@@ -48,11 +48,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1772876132,
+        "lastModified": 1773294693,
-        "narHash": "sha256-yfHMAmihWLAXU9K3IZcY9u+x7e7/5IqVuZDgVT6UPl8=",
+        "narHash": "sha256-lJFjEOr//a7/5U62Los6ey3FVv4jOjDKJGSB/HxWcdE=",
         "owner": "spotdemo4",
         "repo": "nur",
-        "rev": "832cb64ef80f65c9734d82feec1441f9d10e3b14",
+        "rev": "8dab613a8c0e780fab2c1b20ba0927310e6341fa",
         "type": "github"
       },
       "original": {

flake.nix

@@ -48,7 +48,10 @@
               lldb
 
               # deps
-              duckdb
+              openssl
+
+              # gen
+              buf
 
               # linters
               octoscan

src/llrp.zig

@@ -0,0 +1,770 @@
+//! LLRP (Low Level Reader Protocol) reader abstraction.
+//!
+//! Wraps the Impinj LTKC (LLRP Tool Kit C) library behind a Zig-friendly
+//! `Reader` struct.  All network I/O is blocking; timeouts are specified in
+//! milliseconds and embedded in each call.
+
+const std = @import("std");
+
+// Re-export `c` so callers can reference LLRP types and printf without a
+// second @cImport.
+pub const c = @cImport({
+    @cInclude("stdio.h");
+    @cInclude("ltkc.h");
+    @cInclude("impinj_ltkc.h");
+});
+
+pub const Error = error{
+    LlrpFailed,
+    /// Returned by `tryReceiveReport` when no message arrived within the
+    /// timeout window.  This is not a fatal condition; callers can simply
+    /// continue the loop.
+    Timeout,
+};
+
+// ---------------------------------------------------------------------------
+// Observation callback
+// ---------------------------------------------------------------------------
+
+/// One tag observation extracted from an RO_ACCESS_REPORT.
+pub const TagObservation = struct {
+    /// Zero-padded EPC bytes.  Valid bytes are `epc[0..epc_len]`.
+    epc: [32]u8,
+    epc_len: u8,
+    antenna: u16,
+    rssi_dbm: i8,
+    /// UTC microseconds from the reader's first-seen timestamp.
+    /// Falls back to the local wall clock if the reader omits the field.
+    timestamp_us: u64,
+};
+
+/// Callback invoked once per tag in each RO_ACCESS_REPORT.
+pub const ObserveCallback = struct {
+    context: *anyopaque,
+    func: *const fn (context: *anyopaque, obs: TagObservation) void,
+
+    pub fn call(self: ObserveCallback, obs: TagObservation) void {
+        self.func(self.context, obs);
+    }
+};
+
+// ---------------------------------------------------------------------------
+// GPI event callback
+// ---------------------------------------------------------------------------
+
+/// One GPI (General Purpose Input) state-change event from the reader.
+pub const GpiEvent = struct {
+    /// GPI port number (1-based, as reported by the reader).
+    port: u16,
+    /// `true`  = high / asserted;
+    /// `false` = low  / released.
+    state: bool,
+    /// UTC microseconds (reader clock + NTP offset).
+    timestamp_us: u64,
+};
+
+/// Callback invoked on each LLRP GPI state-change event.
+/// Pass `null` to `tryReceiveReport` for a built-in log-only handler.
+pub const GpiCallback = struct {
+    context: *anyopaque,
+    func: *const fn (context: *anyopaque, event: GpiEvent) void,
+
+    pub fn call(self: GpiCallback, event: GpiEvent) void {
+        self.func(self.context, event);
+    }
+};
+
+// ---------------------------------------------------------------------------
+// Reader info
+// ---------------------------------------------------------------------------
+
+/// Static information retrieved from the reader at startup.
+pub const ReaderInfo = struct {
+    /// IANA Private Enterprise Number (e.g. 25882 = Impinj).
+    manufacturer_pen: u32,
+    /// Vendor-specific model code.
+    model: u32,
+    /// Null-terminated firmware version string.
+    firmware: [64:0]u8,
+    /// 128-bit UUID derived from the reader's hardware identifier.
+    /// Layout: bytes 0–7 = 0x00 (padding); bytes 8–15 = EUI-64.
+    /// MAC addresses (6 bytes) are expanded to EUI-64 via the standard
+    /// IEEE FF:FE insertion (bytes 2–3 become 0xFF 0xFE).
+    /// Format as: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.
+    reader_id: [16]u8,
+};
+
+// ---------------------------------------------------------------------------
+// Reader
+// ---------------------------------------------------------------------------
+
+/// An active connection to an LLRP reader.
+///
+/// Typical lifecycle:
+///   1. `var reader = try Reader.init(hostname, verbose);`
+///   2. `defer reader.deinit();`
+///   3. `try reader.checkConnectionStatus();`
+///   4. `try reader.scrubConfiguration();`
+///   5. configure + run inventory loop
+///   6. `try reader.scrubConfiguration();`  (best-effort)
+///   …deinit() called by defer
+pub const Reader = struct {
+    pConn: [*c]c.LLRP_tSConnection,
+    pTypeRegistry: [*c]c.LLRP_tSTypeRegistry,
+    verbose: c_int,
+    /// Offset (µs) added to all reader-reported timestamps to correct for
+    /// drift between the reader's clock and NTP UTC.
+    /// Set by the caller after `init`; defaults to 0 (no correction).
+    clock_offset_us: i64 = 0,
+
+    // -----------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------
+
+    /// Allocate a type registry, construct the connection object, and open a
+    /// TCP socket to `hostname` (standard LLRP port 5084).
+    /// Call `checkConnectionStatus` immediately after to verify the reader
+    /// accepted the connection.
+    pub fn init(hostname: [*:0]const u8, verbose: c_int) Error!Reader {
+        const pTypeRegistry = c.LLRP_getTheTypeRegistry();
+        if (pTypeRegistry == null) {
+            _ = c.printf("ERROR: getTheTypeRegistry failed\n");
+            return Error.LlrpFailed;
+        }
+        c.LLRP_enrollImpinjTypesIntoRegistry(pTypeRegistry);
+
+        const pConn = c.LLRP_Conn_construct(pTypeRegistry, 32 * 1024);
+        if (pConn == null) {
+            _ = c.printf("ERROR: Conn_construct failed\n");
+            c.LLRP_TypeRegistry_destruct(pTypeRegistry);
+            return Error.LlrpFailed;
+        }
+
+        if (verbose != 0) _ = c.printf("INFO: Connecting to %s....\n", hostname);
+
+        const rc = c.LLRP_Conn_openConnectionToReader(pConn, hostname);
+        if (rc != 0) {
+            _ = c.printf("ERROR: connect: %s (%d)\n", pConn[0].pConnectErrorStr, rc);
+            c.LLRP_Conn_destruct(pConn);
+            c.LLRP_TypeRegistry_destruct(pTypeRegistry);
+            return Error.LlrpFailed;
+        }
+
+        if (verbose != 0) _ = c.printf("INFO: Connected, checking status....\n");
+
+        return .{
+            .pConn = pConn,
+            .pTypeRegistry = pTypeRegistry,
+            .verbose = verbose,
+        };
+    }
+
+    /// Close the TCP connection and release all library resources.
+    pub fn deinit(self: *Reader) void {
+        _ = c.LLRP_Conn_closeConnectionToReader(self.pConn);
+        c.LLRP_Conn_destruct(self.pConn);
+        c.LLRP_TypeRegistry_destruct(self.pTypeRegistry);
+    }
+
+    // -----------------------------------------------------------------------
+    // Setup / teardown
+    // -----------------------------------------------------------------------
+
+    /// Await and validate the initial READER_EVENT_NOTIFICATION the reader
+    /// sends immediately upon accepting the connection.
+    pub fn checkConnectionStatus(self: *Reader) Error!void {
+        const pMessage = self.recvMessage(10000) orelse return Error.LlrpFailed;
+        defer freeMessage(pMessage);
+
+        if (&c.LLRP_tdREADER_EVENT_NOTIFICATION != pMessage.elementHdr.pType) {
+            _ = c.printf("ERROR: checkConnectionStatus: unexpected message type\n");
+            return Error.LlrpFailed;
+        }
+
+        const pNtf: *c.LLRP_tSREADER_EVENT_NOTIFICATION = @ptrCast(pMessage);
+        const pNtfData = pNtf.pReaderEventNotificationData;
+        if (pNtfData == null) {
+            _ = c.printf("ERROR: checkConnectionStatus: missing notification data\n");
+            return Error.LlrpFailed;
+        }
+
+        const pEvent = pNtfData[0].pConnectionAttemptEvent;
+        if (pEvent == null) {
+            _ = c.printf("ERROR: checkConnectionStatus: missing ConnectionAttemptEvent\n");
+            return Error.LlrpFailed;
+        }
+
+        if (c.LLRP_ConnectionAttemptStatusType_Success != pEvent[0].eStatus) {
+            _ = c.printf("ERROR: checkConnectionStatus: connection attempt failed\n");
+            return Error.LlrpFailed;
+        }
+
+        if (self.verbose != 0) _ = c.printf("INFO: Connection status OK\n");
+    }
+
+    /// Query the reader's static identity: manufacturer PEN, model code,
+    /// firmware version, and unique reader ID (typically a MAC address).
+    /// Call after `checkConnectionStatus` and before `scrubConfiguration`.
+    pub fn queryReaderInfo(self: *Reader) Error!ReaderInfo {
+        var info = std.mem.zeroes(ReaderInfo);
+
+        // --- GET_READER_CAPABILITIES (General_Device_Capabilities) ---
+        var CapCmd = std.mem.zeroes(c.LLRP_tSGET_READER_CAPABILITIES);
+        CapCmd.hdr.elementHdr.pType = &c.LLRP_tdGET_READER_CAPABILITIES;
+        CapCmd.hdr.MessageID = 104;
+        CapCmd.eRequestedData =
+            c.LLRP_GetReaderCapabilitiesRequestedData_General_Device_Capabilities;
+
+        const pCapRspMsg = self.transact(&CapCmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pCapRspMsg);
+
+        const pCapRsp: *c.LLRP_tSGET_READER_CAPABILITIES_RESPONSE = @ptrCast(pCapRspMsg);
+        try checkLLRPStatus(pCapRsp.pLLRPStatus, "queryReaderInfo(capabilities)");
+
+        if (pCapRsp.pGeneralDeviceCapabilities == null) {
+            _ = c.printf("ERROR: queryReaderInfo: missing GeneralDeviceCapabilities\n");
+            return Error.LlrpFailed;
+        }
+        const pCap = pCapRsp.pGeneralDeviceCapabilities;
+        info.manufacturer_pen = pCap[0].DeviceManufacturerName;
+        info.model = pCap[0].ModelName;
+
+        const fw = pCap[0].ReaderFirmwareVersion;
+        const fw_len: u8 = @intCast(@min(fw.nValue, 63));
+        if (fw.pValue != null)
+            @memcpy(info.firmware[0..fw_len], @as([*]const u8, @ptrCast(fw.pValue))[0..fw_len]);
+        info.firmware[fw_len] = 0;
+
+        // --- GET_READER_CONFIG (Identification) ---
+        var CfgCmd = std.mem.zeroes(c.LLRP_tSGET_READER_CONFIG);
+        CfgCmd.hdr.elementHdr.pType = &c.LLRP_tdGET_READER_CONFIG;
+        CfgCmd.hdr.MessageID = 105;
+        CfgCmd.AntennaID = 0;
+        CfgCmd.eRequestedData = c.LLRP_GetReaderConfigRequestedData_Identification;
+
+        const pCfgRspMsg = self.transact(&CfgCmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pCfgRspMsg);
+
+        const pCfgRsp: *c.LLRP_tSGET_READER_CONFIG_RESPONSE = @ptrCast(pCfgRspMsg);
+        try checkLLRPStatus(pCfgRsp.pLLRPStatus, "queryReaderInfo(config)");
+
+        if (pCfgRsp.pIdentification != null) {
+            const pId = pCfgRsp.pIdentification;
+            const rid = pId[0].ReaderID;
+            const rid_len: usize = @min(rid.nValue, 8);
+            if (rid.pValue != null) {
+                const raw: [*]const u8 = @ptrCast(rid.pValue);
+                if (rid_len == 6) {
+                    // Expand MAC (EUI-48) to EUI-64 by inserting 0xFF 0xFE
+                    // between bytes 2 and 3 (IEEE standard expansion).
+                    info.reader_id[8]  = raw[0];
+                    info.reader_id[9]  = raw[1];
+                    info.reader_id[10] = raw[2];
+                    info.reader_id[11] = 0xFF;
+                    info.reader_id[12] = 0xFE;
+                    info.reader_id[13] = raw[3];
+                    info.reader_id[14] = raw[4];
+                    info.reader_id[15] = raw[5];
+                } else {
+                    // EUI-64 or other: copy directly into the node field.
+                    @memcpy(info.reader_id[8..8 + rid_len], raw[0..rid_len]);
+                }
+            }
+        }
+
+        return info;
+    }
+
+    /// Reset the reader to factory defaults and delete all ROSpecs.
+    pub fn scrubConfiguration(self: *Reader) Error!void {
+        try self.resetConfigurationToFactoryDefaults();
+        try self.deleteAllROSpecs();
+    }
+
+    // -----------------------------------------------------------------------
+    // Configuration
+    // -----------------------------------------------------------------------
+
+    /// Send IMPINJ_ENABLE_EXTENSIONS to unlock Impinj-specific parameters.
+    pub fn enableImpinjExtensions(self: *Reader) Error!void {
+        var Cmd = std.mem.zeroes(c.LLRP_tSIMPINJ_ENABLE_EXTENSIONS);
+        Cmd.hdr.elementHdr.pType = &c.LLRP_tdIMPINJ_ENABLE_EXTENSIONS;
+        Cmd.hdr.MessageID = 103;
+
+        const pRspMsg = self.transact(&Cmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsg);
+
+        const pRsp: *c.LLRP_tSIMPINJ_ENABLE_EXTENSIONS_RESPONSE = @ptrCast(pRspMsg);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "enableImpinjExtensions");
+
+        if (self.verbose != 0) _ = c.printf("INFO: Impinj extensions enabled\n");
+    }
+
+    /// Add ROSpec ID 123:
+    ///   - Command-triggered start (Null start trigger)
+    ///   - Null ROSpec/AISpec stop triggers — inventories until `stopROSpec`
+    ///   - C1G2 Session 0 on all antennas
+    ///   - One RO_ACCESS_REPORT per tag, including AntennaID and PeakRSSI
+    pub fn addROSpec(self: *Reader) Error!void {
+        var ROSpecStartTrigger = std.mem.zeroes(c.LLRP_tSROSpecStartTrigger);
+        ROSpecStartTrigger.hdr.elementHdr.pType = &c.LLRP_tdROSpecStartTrigger;
+        ROSpecStartTrigger.eROSpecStartTriggerType = c.LLRP_ROSpecStartTriggerType_Null;
+
+        var ROSpecStopTrigger = std.mem.zeroes(c.LLRP_tSROSpecStopTrigger);
+        ROSpecStopTrigger.hdr.elementHdr.pType = &c.LLRP_tdROSpecStopTrigger;
+        ROSpecStopTrigger.eROSpecStopTriggerType = c.LLRP_ROSpecStopTriggerType_Null;
+        ROSpecStopTrigger.DurationTriggerValue = 0;
+
+        var ROBoundarySpec = std.mem.zeroes(c.LLRP_tSROBoundarySpec);
+        ROBoundarySpec.hdr.elementHdr.pType = &c.LLRP_tdROBoundarySpec;
+        ROBoundarySpec.pROSpecStartTrigger = &ROSpecStartTrigger;
+        ROBoundarySpec.pROSpecStopTrigger = &ROSpecStopTrigger;
+
+        // AntennaID 0 means "all antennas".
+        var AntennaIDs = [_]c.llrp_u16_t{0};
+
+        // Null stop trigger keeps the AISpec running indefinitely; the reader
+        // continuously inventories until explicitly stopped via STOP_ROSPEC.
+        var AISpecStopTrigger = std.mem.zeroes(c.LLRP_tSAISpecStopTrigger);
+        AISpecStopTrigger.hdr.elementHdr.pType = &c.LLRP_tdAISpecStopTrigger;
+        AISpecStopTrigger.eAISpecStopTriggerType = c.LLRP_AISpecStopTriggerType_Null;
+        AISpecStopTrigger.DurationTrigger = 0;
+
+        // Session 0: tags respond on every inventory round (no state machine
+        // advancement).  TagPopulation is a hint for the reader's Q algorithm.
+        var C1G2SingulationControl = std.mem.zeroes(c.LLRP_tSC1G2SingulationControl);
+        C1G2SingulationControl.hdr.elementHdr.pType = &c.LLRP_tdC1G2SingulationControl;
+        C1G2SingulationControl.Session = 0;
+        C1G2SingulationControl.TagPopulation = 32;
+        C1G2SingulationControl.TagTransitTime = 0;
+
+        var C1G2InventoryCommand = std.mem.zeroes(c.LLRP_tSC1G2InventoryCommand);
+        C1G2InventoryCommand.hdr.elementHdr.pType = &c.LLRP_tdC1G2InventoryCommand;
+        C1G2InventoryCommand.TagInventoryStateAware = 0;
+        C1G2InventoryCommand.pC1G2SingulationControl = &C1G2SingulationControl;
+
+        // AntennaID 0 = all antennas; attach C1G2InventoryCommand here.
+        var AntennaConfiguration = std.mem.zeroes(c.LLRP_tSAntennaConfiguration);
+        AntennaConfiguration.hdr.elementHdr.pType = &c.LLRP_tdAntennaConfiguration;
+        AntennaConfiguration.AntennaID = 0;
+        AntennaConfiguration.listAirProtocolInventoryCommandSettings = @ptrCast(&C1G2InventoryCommand.hdr);
+
+        var InventoryParameterSpec = std.mem.zeroes(c.LLRP_tSInventoryParameterSpec);
+        InventoryParameterSpec.hdr.elementHdr.pType = &c.LLRP_tdInventoryParameterSpec;
+        InventoryParameterSpec.InventoryParameterSpecID = 1234;
+        InventoryParameterSpec.eProtocolID = c.LLRP_AirProtocols_EPCGlobalClass1Gen2;
+        InventoryParameterSpec.listAntennaConfiguration = &AntennaConfiguration;
+
+        var AISpec = std.mem.zeroes(c.LLRP_tSAISpec);
+        AISpec.hdr.elementHdr.pType = &c.LLRP_tdAISpec;
+        AISpec.AntennaIDs.nValue = 1;
+        AISpec.AntennaIDs.pValue = &AntennaIDs[0];
+        AISpec.pAISpecStopTrigger = &AISpecStopTrigger;
+        AISpec.listInventoryParameterSpec = &InventoryParameterSpec;
+
+        var TagReportContentSelector = std.mem.zeroes(c.LLRP_tSTagReportContentSelector);
+        TagReportContentSelector.hdr.elementHdr.pType = &c.LLRP_tdTagReportContentSelector;
+        TagReportContentSelector.EnableAntennaID = 1;
+        TagReportContentSelector.EnablePeakRSSI = 1;
+        TagReportContentSelector.EnableFirstSeenTimestamp = 1;
+
+        var ROReportSpec = std.mem.zeroes(c.LLRP_tSROReportSpec);
+        ROReportSpec.hdr.elementHdr.pType = &c.LLRP_tdROReportSpec;
+        // N=1: send a report after every single tag observation so callers
+        // see reads in real time rather than in batches.
+        ROReportSpec.eROReportTrigger = c.LLRP_ROReportTriggerType_Upon_N_Tags_Or_End_Of_ROSpec;
+        ROReportSpec.N = 1;
+        ROReportSpec.pTagReportContentSelector = &TagReportContentSelector;
+
+        var ROSpec = std.mem.zeroes(c.LLRP_tSROSpec);
+        ROSpec.hdr.elementHdr.pType = &c.LLRP_tdROSpec;
+        ROSpec.ROSpecID = 123;
+        ROSpec.Priority = 0;
+        ROSpec.eCurrentState = c.LLRP_ROSpecState_Disabled;
+        ROSpec.pROBoundarySpec = &ROBoundarySpec;
+        ROSpec.listSpecParameter = @ptrCast(&AISpec.hdr);
+        ROSpec.pROReportSpec = &ROReportSpec;
+
+        var Cmd = std.mem.zeroes(c.LLRP_tSADD_ROSPEC);
+        Cmd.hdr.elementHdr.pType = &c.LLRP_tdADD_ROSPEC;
+        Cmd.hdr.MessageID = 201;
+        Cmd.pROSpec = &ROSpec;
+
+        const pRspMsg = self.transact(&Cmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsg);
+
+        const pRsp: *c.LLRP_tSADD_ROSPEC_RESPONSE = @ptrCast(pRspMsg);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "addROSpec");
+
+        if (self.verbose != 0) _ = c.printf("INFO: ROSpec added\n");
+    }
+
+    /// Send ENABLE_ROSPEC for ROSpecID 123, transitioning it to Enabled state.
+    pub fn enableROSpec(self: *Reader) Error!void {
+        var Cmd = std.mem.zeroes(c.LLRP_tSENABLE_ROSPEC);
+        Cmd.hdr.elementHdr.pType = &c.LLRP_tdENABLE_ROSPEC;
+        Cmd.hdr.MessageID = 202;
+        Cmd.ROSpecID = 123;
+
+        const pRspMsg = self.transact(&Cmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsg);
+
+        const pRsp: *c.LLRP_tSENABLE_ROSPEC_RESPONSE = @ptrCast(pRspMsg);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "enableROSpec");
+
+        if (self.verbose != 0) _ = c.printf("INFO: ROSpec enabled\n");
+    }
+
+    // -----------------------------------------------------------------------
+    // Inventory
+    // -----------------------------------------------------------------------
+
+    /// Send START_ROSPEC for ROSpecID 123.  Because the AISpec has a Null
+    /// stop trigger the reader inventories continuously until `stopROSpec` is
+    /// called.  Each tag observation produces an independent RO_ACCESS_REPORT.
+    pub fn startROSpec(self: *Reader) Error!void {
+        var Cmd = std.mem.zeroes(c.LLRP_tSSTART_ROSPEC);
+        Cmd.hdr.elementHdr.pType = &c.LLRP_tdSTART_ROSPEC;
+        Cmd.hdr.MessageID = 203;
+        Cmd.ROSpecID = 123;
+
+        const pRspMsg = self.transact(&Cmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsg);
+
+        const pRsp: *c.LLRP_tSSTART_ROSPEC_RESPONSE = @ptrCast(pRspMsg);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "startROSpec");
+
+        if (self.verbose != 0) _ = c.printf("INFO: ROSpec started\n");
+    }
+
+    /// Send STOP_ROSPEC for ROSpecID 123 to halt the continuous inventory.
+    pub fn stopROSpec(self: *Reader) Error!void {
+        var Cmd = std.mem.zeroes(c.LLRP_tSSTOP_ROSPEC);
+        Cmd.hdr.elementHdr.pType = &c.LLRP_tdSTOP_ROSPEC;
+        Cmd.hdr.MessageID = 204;
+        Cmd.ROSpecID = 123;
+
+        const pRspMsg = self.transact(&Cmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsg);
+
+        const pRsp: *c.LLRP_tSSTOP_ROSPEC_RESPONSE = @ptrCast(pRspMsg);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "stopROSpec");
+
+        if (self.verbose != 0) _ = c.printf("INFO: ROSpec stopped\n");
+    }
+
+    /// Wait up to `nMaxMS` milliseconds for the next tag report.
+    /// For each tag in the report `cb` is invoked with a `TagObservation`.
+    /// Returns `error.Timeout` (non-fatal) if no message arrived in time.
+    /// Interleaved READER_EVENT_NOTIFICATIONs are dispatched transparently.
+    /// Pass `null` for `gpi_cb` to use the default log-only GPI handler.
+    pub fn tryReceiveReport(self: *Reader, nMaxMS: c_int, cb: ObserveCallback, gpi_cb: ?GpiCallback) Error!void {
+        while (true) {
+            const pMsgC = c.LLRP_Conn_recvMessage(self.pConn, nMaxMS);
+            if (pMsgC == null) {
+                // Distinguish a normal timeout from a real socket error so
+                // callers can keep looping when there are simply no tags.
+                if (self.isTimeoutError()) return Error.Timeout;
+                const pError = c.LLRP_Conn_getRecvError(self.pConn);
+                _ = c.printf("ERROR: recvMessage failed, %s\n",
+                    if (pError[0].pWhatStr != null) pError[0].pWhatStr else @as([*c]const u8, "no reason given"));
+                return Error.LlrpFailed;
+            }
+            // Cast [*c]T → *T now that we know it is non-null.
+            const pMessage: *c.LLRP_tSMessage = @ptrCast(pMsgC);
+            const pType = pMessage.elementHdr.pType;
+
+            if (self.verbose > 1) {
+                _ = c.printf("\n===================================\n");
+                _ = c.printf("INFO: Message received\n");
+                printXMLMessage(@ptrCast(pMessage));
+            }
+
+            if (&c.LLRP_tdRO_ACCESS_REPORT == pType) {
+                const pRpt: *c.LLRP_tSRO_ACCESS_REPORT = @ptrCast(pMessage);
+                dispatchObservations(pRpt, self.clock_offset_us, cb);
+                freeMessage(pMessage);
+                return;
+            } else if (&c.LLRP_tdREADER_EVENT_NOTIFICATION == pType) {
+                const pNtf: *c.LLRP_tSREADER_EVENT_NOTIFICATION = @ptrCast(pMessage);
+                const pNtfData = c.LLRP_READER_EVENT_NOTIFICATION_getReaderEventNotificationData(pNtf);
+                if (pNtfData != null) {
+                    handleReaderEventNotification(pNtfData.?, self.clock_offset_us, gpi_cb);
+                } else {
+                    _ = c.printf("WARNING: READER_EVENT_NOTIFICATION without data\n");
+                }
+                freeMessage(pMessage);
+            } else {
+                _ = c.printf("WARNING: Ignored unexpected message: %s\n", pType[0].pName);
+                freeMessage(pMessage);
+            }
+        }
+    }
+
+    /// Returns true when the last `recvMessage` call failed due to a timeout
+    /// rather than a genuine socket or protocol error.
+    fn isTimeoutError(self: *Reader) bool {
+        const pError = c.LLRP_Conn_getRecvError(self.pConn);
+        if (pError == null or pError[0].pWhatStr == null) return false;
+        const s = std.mem.span(pError[0].pWhatStr);
+        // The LTKC library embeds the word "timeout" (case-insensitive) in
+        // its timeout error description strings.
+        return std.ascii.indexOfIgnoreCase(s, "timeout") != null;
+    }
+
+    fn resetConfigurationToFactoryDefaults(self: *Reader) Error!void {
+        var Cmd = std.mem.zeroes(c.LLRP_tSSET_READER_CONFIG);
+        Cmd.hdr.elementHdr.pType = &c.LLRP_tdSET_READER_CONFIG;
+        Cmd.hdr.MessageID = 101;
+        Cmd.ResetToFactoryDefault = 1;
+
+        const pRspMsg = self.transact(&Cmd.hdr) orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsg);
+
+        const pRsp: *c.LLRP_tSSET_READER_CONFIG_RESPONSE = @ptrCast(pRspMsg);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "resetConfigurationToFactoryDefaults");
+
+        if (self.verbose != 0) _ = c.printf("INFO: Configuration reset to factory defaults\n");
+    }
+
+    fn deleteAllROSpecs(self: *Reader) Error!void {
+        const pCmd = c.LLRP_DELETE_ROSPEC_construct();
+        if (pCmd == null) {
+            _ = c.printf("ERROR: LLRP_DELETE_ROSPEC_construct failed\n");
+            return Error.LlrpFailed;
+        }
+        const pCmdMsg: *c.LLRP_tSMessage = &pCmd[0].hdr;
+        c.LLRP_Message_setMessageID(pCmdMsg, 102);
+        _ = c.LLRP_DELETE_ROSPEC_setROSpecID(pCmd, 0); // 0 = all ROSpecs
+
+        // Free the command after transact regardless of the result.
+        const pRspMsg = self.transact(pCmdMsg);
+        freeMessage(pCmdMsg);
+        const pRspMsgNN = pRspMsg orelse return Error.LlrpFailed;
+        defer freeMessage(pRspMsgNN);
+
+        const pRsp: *c.LLRP_tSDELETE_ROSPEC_RESPONSE = @ptrCast(pRspMsgNN);
+        try checkLLRPStatus(pRsp.pLLRPStatus, "deleteAllROSpecs");
+
+        if (self.verbose != 0) _ = c.printf("INFO: All ROSpecs deleted\n");
+    }
+
+    /// Send `pSendMsg` and await the matching response (5 s timeout).
+    /// Returns null and tattles on any error.
+    fn transact(self: *Reader, pSendMsg: *c.LLRP_tSMessage) ?*c.LLRP_tSMessage {
+        if (self.verbose > 1) {
+            _ = c.printf("\n===================================\n");
+            _ = c.printf("INFO: Transact sending\n");
+            printXMLMessage(pSendMsg);
+        }
+
+        const pRspMsg = c.LLRP_Conn_transact(self.pConn, pSendMsg, 5000);
+        if (pRspMsg == null) {
+            const pError = c.LLRP_Conn_getTransactError(self.pConn);
+            _ = c.printf("ERROR: %s transact failed, %s\n",
+                pSendMsg.elementHdr.pType[0].pName,
+                if (pError[0].pWhatStr != null) pError[0].pWhatStr else @as([*c]const u8, "no reason given"));
+            if (pError[0].pRefType != null)
+                _ = c.printf("ERROR: ... reference type %s\n", pError[0].pRefType[0].pName);
+            if (pError[0].pRefField != null)
+                _ = c.printf("ERROR: ... reference field %s\n", pError[0].pRefField[0].pName);
+            return null;
+        }
+
+        if (self.verbose > 1) {
+            _ = c.printf("\n- - - - - - - - - - - - - - - - - -\n");
+            _ = c.printf("INFO: Transact received response\n");
+            printXMLMessage(@ptrCast(pRspMsg));
+        }
+
+        if (&c.LLRP_tdERROR_MESSAGE == pRspMsg[0].elementHdr.pType) {
+            const pResponseType = pSendMsg.elementHdr.pType[0].pResponseType;
+            _ = c.printf("ERROR: Received ERROR_MESSAGE instead of %s\n", pResponseType[0].pName);
+            freeMessage(@ptrCast(pRspMsg));
+            return null;
+        }
+
+        return pRspMsg;
+    }
+
+    /// Receive one message with a timeout in milliseconds.
+    /// Returns null and tattles on any error.
+    fn recvMessage(self: *Reader, nMaxMS: c_int) ?*c.LLRP_tSMessage {
+        const pMessage = c.LLRP_Conn_recvMessage(self.pConn, nMaxMS);
+        if (pMessage == null) {
+            const pError = c.LLRP_Conn_getRecvError(self.pConn);
+            _ = c.printf("ERROR: recvMessage failed, %s\n",
+                if (pError[0].pWhatStr != null) pError[0].pWhatStr else @as([*c]const u8, "no reason given"));
+            if (pError[0].pRefType != null)
+                _ = c.printf("ERROR: ... reference type %s\n", pError[0].pRefType[0].pName);
+            if (pError[0].pRefField != null)
+                _ = c.printf("ERROR: ... reference field %s\n", pError[0].pRefField[0].pName);
+            return null;
+        }
+
+        if (self.verbose > 1) {
+            _ = c.printf("\n===================================\n");
+            _ = c.printf("INFO: Message received\n");
+            printXMLMessage(@ptrCast(pMessage));
+        }
+
+        return pMessage;
+    }
+};
+
+// ---------------------------------------------------------------------------
+// Module-private helpers
+// ---------------------------------------------------------------------------
+
+fn checkLLRPStatus(pLLRPStatus: ?*c.LLRP_tSLLRPStatus, pWhatStr: [*:0]const u8) Error!void {
+    if (pLLRPStatus == null) {
+        _ = c.printf("ERROR: %s missing LLRP status\n", pWhatStr);
+        return Error.LlrpFailed;
+    }
+    if (c.LLRP_StatusCode_M_Success != pLLRPStatus.?.eStatusCode) {
+        if (pLLRPStatus.?.ErrorDescription.nValue == 0) {
+            _ = c.printf("ERROR: %s failed, no error description given\n", pWhatStr);
+        } else {
+            _ = c.printf("ERROR: %s failed, %.*s\n",
+                pWhatStr,
+                @as(c_int, pLLRPStatus.?.ErrorDescription.nValue),
+                pLLRPStatus.?.ErrorDescription.pValue);
+        }
+        return Error.LlrpFailed;
+    }
+}
+
+fn freeMessage(pMessage: *c.LLRP_tSMessage) void {
+    c.LLRP_Element_destruct(&pMessage.elementHdr);
+}
+
+fn printXMLMessage(pMessage: *c.LLRP_tSMessage) void {
+    var aBuf: [100 * 1024]u8 = undefined;
+    _ = c.LLRP_toXMLString(&pMessage.elementHdr, &aBuf[0], aBuf.len);
+    _ = c.printf("%s", &aBuf[0]);
+}
+
+/// Build a `TagObservation` for each entry in an RO_ACCESS_REPORT and
+/// invoke `cb` for each one.
+fn dispatchObservations(pReport: *c.LLRP_tSRO_ACCESS_REPORT, clock_offset_us: i64, cb: ObserveCallback) void {
+    var pEntry = pReport.listTagReportData;
+    while (pEntry != null) : (pEntry = @ptrCast(pEntry[0].hdr.pNextSubParameter)) {
+        const pTrd = @as(*c.LLRP_tSTagReportData, @ptrCast(pEntry));
+        cb.call(buildObservation(pTrd, clock_offset_us));
+    }
+}
+
+/// Extract fields from a single TagReportData into a flat `TagObservation`.
+fn buildObservation(pTrd: *c.LLRP_tSTagReportData, clock_offset_us: i64) TagObservation {
+    var obs = std.mem.zeroes(TagObservation);
+
+    // --- EPC ---
+    if (pTrd.pEPCParameter != null) {
+        const pType = pTrd.pEPCParameter[0].elementHdr.pType;
+        if (&c.LLRP_tdEPC_96 == pType) {
+            const pE96: *c.LLRP_tSEPC_96 = @ptrCast(pTrd.pEPCParameter);
+            const n = 12;
+            @memcpy(obs.epc[0..n], @as([*]const u8, @ptrCast(&pE96.EPC.aValue[0]))[0..n]);
+            obs.epc_len = n;
+        } else if (&c.LLRP_tdEPCData == pType) {
+            const pEPCData: *c.LLRP_tSEPCData = @ptrCast(pTrd.pEPCParameter);
+            const n: u8 = @intCast(@min((pEPCData.EPC.nBit + 7) / 8, 32));
+            if (pEPCData.EPC.pValue != null)
+                @memcpy(obs.epc[0..n], @as([*]const u8, @ptrCast(pEPCData.EPC.pValue))[0..n]);
+            obs.epc_len = n;
+        }
+    }
+
+    // --- Antenna / RSSI ---
+    if (pTrd.pAntennaID != null)
+        obs.antenna = pTrd.pAntennaID[0].AntennaID;
+    if (pTrd.pPeakRSSI != null)
+        obs.rssi_dbm = pTrd.pPeakRSSI[0].PeakRSSI;
+
+    // --- Timestamp (prefer LLRP UTC, fall back to local wall clock; apply NTP offset) ---
+    const raw_us: i64 = if (pTrd.pFirstSeenTimestampUTC != null)
+        @intCast(pTrd.pFirstSeenTimestampUTC[0].Microseconds)
+    else
+        std.time.microTimestamp();
+    obs.timestamp_us = @intCast(raw_us + clock_offset_us);
+
+    return obs;
+}
+
+
+fn handleReaderEventNotification(pNtfData: *c.LLRP_tSReaderEventNotificationData, clock_offset_us: i64, gpi_cb: ?GpiCallback) void {
+    var nReported: c_int = 0;
+
+    const pGpiEvent = c.LLRP_ReaderEventNotificationData_getGPIEvent(pNtfData);
+    if (pGpiEvent != null) {
+        const pTimestamp = c.LLRP_ReaderEventNotificationData_getTimestamp(pNtfData);
+        handleGpiEvent(@ptrCast(pGpiEvent), pTimestamp, clock_offset_us, gpi_cb);
+        nReported += 1;
+    }
+
+    const pAntennaEvent = c.LLRP_ReaderEventNotificationData_getAntennaEvent(pNtfData);
+    if (pAntennaEvent != null) {
+        handleAntennaEvent(@ptrCast(pAntennaEvent));
+        nReported += 1;
+    }
+
+    const pReaderExceptionEvent = c.LLRP_ReaderEventNotificationData_getReaderExceptionEvent(pNtfData);
+    if (pReaderExceptionEvent != null) {
+        handleReaderExceptionEvent(@ptrCast(pReaderExceptionEvent));
+        nReported += 1;
+    }
+
+    if (nReported == 0) _ = c.printf("NOTICE: Unexpected (unhandled) ReaderEvent\n");
+}
+
+fn handleGpiEvent(
+    pEvt: *c.LLRP_tSGPIEvent,
+    pTimestamp: ?*c.LLRP_tSParameter,
+    clock_offset_us: i64,
+    gpi_cb: ?GpiCallback,
+) void {
+    const port = c.LLRP_GPIEvent_getGPIPortNumber(pEvt);
+    const state = c.LLRP_GPIEvent_getGPIEvent(pEvt) != 0;
+
+    // Extract UTC timestamp from the notification's Timestamp sub-parameter.
+    // The parameter is polymorphic: prefer UTCTimestamp; fall back to local
+    // wall clock if it is absent or expressed as an Uptime (relative ticks).
+    var raw_us: i64 = std.time.microTimestamp();
+    if (pTimestamp) |pT| {
+        if (&c.LLRP_tdUTCTimestamp == pT.elementHdr.pType) {
+            const pUTC: *c.LLRP_tSUTCTimestamp = @ptrCast(pT);
+            raw_us = @intCast(pUTC.Microseconds);
+        }
+    }
+    const timestamp_us: u64 = @intCast(raw_us + clock_offset_us);
+
+    if (gpi_cb) |cb| {
+        cb.call(.{ .port = port, .state = state, .timestamp_us = timestamp_us });
+    } else {
+        _ = c.printf("NOTICE: GPI port %d %s  ts=%llu\n",
+            port,
+            if (state) @as([*:0]const u8, "high") else @as([*:0]const u8, "low"),
+            @as(c_ulonglong, timestamp_us));
+    }
+}
+
+fn handleAntennaEvent(pAntennaEvent: *c.LLRP_tSAntennaEvent) void {
+    const eEventType = c.LLRP_AntennaEvent_getEventType(pAntennaEvent);
+    const AntennaID = c.LLRP_AntennaEvent_getAntennaID(pAntennaEvent);
+    const pStateStr: [*:0]const u8 = switch (eEventType) {
+        c.LLRP_AntennaEventType_Antenna_Disconnected => "disconnected",
+        c.LLRP_AntennaEventType_Antenna_Connected => "connected",
+        else => "?unknown-event?",
+    };
+    _ = c.printf("NOTICE: Antenna %d is %s\n", AntennaID, pStateStr);
+}
+
+fn handleReaderExceptionEvent(pReaderExceptionEvent: *c.LLRP_tSReaderExceptionEvent) void {
+    const Message = c.LLRP_ReaderExceptionEvent_getMessage(pReaderExceptionEvent);
+    if (Message.nValue > 0 and Message.pValue != null) {
+        _ = c.printf("NOTICE: ReaderException '%.*s'\n",
+            @as(c_int, Message.nValue), Message.pValue);
+    } else {
+        _ = c.printf("NOTICE: ReaderException but no message\n");
+    }
+}

src/main.zig

@@ -1,27 +1,306 @@
+/// LLRP inventory reader
+///
+/// Connects to an RFID reader, configures it, then streams tag reads
+/// continuously until interrupted with Ctrl+C (SIGINT).  Each tag observation
+/// triggers an immediate report.  On signal the reader is stopped, cleaned up,
+/// and the program exits.
+///
+/// Usage:  reader [-v[-v]] READERHOSTNAME
+///   -v    print one-line progress messages
+///   -vv   also dump all LLRP messages as XML
 const std = @import("std");
-const zig_template = @import("zig_template");
+const llrp = @import("llrp.zig");
+const tracker = @import("tracker.zig");
+const ntp = @import("ntp.zig");
 
-pub fn main() !void {
+// ---------------------------------------------------------------------------
-    // Prints to stderr, ignoring potential errors.
+// Signal handling
-    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
+// ---------------------------------------------------------------------------
-    try zig_template.bufferedPrint();
+
+/// Set to false by the SIGINT handler to stop the inventory loop.
+var g_running = std.atomic.Value(bool).init(true);
+
+fn sigintHandler(signo: c_int) callconv(.c) void {
+    _ = signo;
+    g_running.store(false, .release);
+    _ = llrp.c.printf("\nINFO: SIGINT received, stopping inventory...\n");
 }
 
-test "simple test" {
+// ---------------------------------------------------------------------------
-    const gpa = std.testing.allocator;
+// Entry point
-    var list: std.ArrayList(i32) = .empty;
+// ---------------------------------------------------------------------------
-    defer list.deinit(gpa); // Try commenting this out and see if zig detects the memory leak!
-    try list.append(gpa, 42);
-    try std.testing.expectEqual(@as(i32, 42), list.pop());
-}
 
-test "fuzz example" {
+pub fn main() void {
-    const Context = struct {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-        fn testOne(context: @This(), input: []const u8) anyerror!void {
+    defer _ = gpa.deinit();
-            _ = context;
+    const allocator = gpa.allocator();
-            // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
+
-            try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input));
+    const args = std.process.argsAlloc(allocator) catch {
-        }
+        std.debug.print("ERROR: failed to allocate args\n", .{});
+        std.process.exit(1);
     };
-    try std.testing.fuzz(Context{}, Context.testOne, .{});
+    defer std.process.argsFree(allocator, args);
+
+    var verbose: c_int = 0;
+    var hostname: ?[*:0]const u8 = null;
+
+    for (args[1..]) |arg| {
+        if (arg.len > 0 and (arg[0] == '-' or arg[0] == '/')) {
+            for (arg[1..]) |ch| {
+                switch (ch) {
+                    'v', 'V' => verbose += 1,
+                    else => {
+                        std.debug.print("Usage: {s} [-v[-v]] READERHOSTNAME\n", .{args[0]});
+                        std.process.exit(1);
+                    },
+                }
+            }
+        } else {
+            hostname = arg.ptr;
+        }
+    }
+
+    if (hostname == null) {
+        std.debug.print("Usage: {s} [-v[-v]] READERHOSTNAME\n", .{args[0]});
+        std.process.exit(1);
+    }
+
+    // Install SIGINT handler for graceful shutdown.
+    const sa = std.posix.Sigaction{
+        .handler = .{ .handler = sigintHandler },
+        .mask = std.mem.zeroes(std.posix.sigset_t),
+        .flags = 0,
+    };
+    std.posix.sigaction(std.posix.SIG.INT, &sa, null);
+
+    run(allocator, hostname.?, verbose) catch |err| {
+        std.debug.print("ERROR: {}\n", .{err});
+        std.process.exit(2);
+    };
+
+    std.debug.print("INFO: Done\n", .{});
+}
+
+// ---------------------------------------------------------------------------
+// Run loop
+// ---------------------------------------------------------------------------
+
+fn run(allocator: std.mem.Allocator, hostname: [*:0]const u8, verbose: c_int) !void {
+    var t = tracker.Tracker.init(allocator, onTagEnter, onTagExit, .{});
+    defer {
+        t.flush();
+        t.deinit();
+    }
+
+    // Query NTP once to get a correction offset for all reported timestamps.
+    // A failure is non-fatal: we proceed with offset=0 and log a warning.
+    const clock_offset_us = ntp.queryOffset(allocator, "pool.ntp.org") catch |err| blk: {
+        _ = llrp.c.printf(
+            "WARNING: NTP query failed (%s), timestamps may be inaccurate\n",
+            @errorName(err).ptr,
+        );
+        break :blk @as(i64, 0);
+    };
+    if (verbose != 0)
+        _ = llrp.c.printf("INFO: NTP clock offset: %lld µs\n", @as(c_longlong, clock_offset_us));
+
+    var reader = try llrp.Reader.init(hostname, verbose);
+    reader.clock_offset_us = clock_offset_us;
+    defer reader.deinit();
+
+    try reader.checkConnectionStatus();
+
+    const info = try reader.queryReaderInfo();
+    printReaderInfo(&info);
+
+    if (verbose != 0) _ = llrp.c.printf("INFO: Scrubbing initial configuration...\n");
+    try reader.scrubConfiguration();
+
+    // Best-effort config cleanup on exit (deferred, errors ignored).
+    defer {
+        if (verbose != 0) _ = llrp.c.printf("INFO: Cleaning up reader configuration...\n");
+        reader.scrubConfiguration() catch {};
+    }
+
+    try reader.enableImpinjExtensions();
+    try reader.addROSpec();
+    try reader.enableROSpec();
+
+    _ = llrp.c.printf("INFO: Starting continuous inventory — press Ctrl+C to stop\n");
+
+    // Start the ROSpec once; because the AISpec has a Null stop trigger the
+    // reader inventories continuously.  Stop it explicitly before teardown.
+    try reader.startROSpec();
+    defer reader.stopROSpec() catch {};
+
+    // Loop receiving one-tag reports until SIGINT.
+    while (g_running.load(.acquire)) {
+        reader.tryReceiveReport(500, .{
+            .context = &t,
+            .func = struct {
+                fn shim(ctx: *anyopaque, obs: llrp.TagObservation) void {
+                    const tp: *tracker.Tracker = @ptrCast(@alignCast(ctx));
+                    tp.observe(obs) catch {};
+                }
+            }.shim,
+        }, .{
+            .context = undefined,
+            .func = struct {
+                fn shim(_: *anyopaque, event: llrp.GpiEvent) void {
+                    onGpiEvent(event.port, event.state, event.timestamp_us);
+                }
+            }.shim,
+        }) catch |err| {
+            // A timeout just means no tag was seen in this window — keep going.
+            if (err == error.Timeout) {
+                t.checkExpired(now()) catch {};
+                continue;
+            }
+            // Any other error during SIGINT shutdown is expected; exit cleanly.
+            if (!g_running.load(.acquire)) break;
+            return err;
+        };
+        t.checkExpired(now()) catch {};
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn now() u64 {
+    return @intCast(std.time.microTimestamp());
+}
+
+fn printReaderInfo(info: *const llrp.ReaderInfo) void {
+    _ = llrp.c.printf("INFO: Reader  manufacturer_pen=%u  model=%u  firmware=%s\n",
+        info.manufacturer_pen, info.model, &info.firmware[0]);
+
+    const r = info.reader_id;
+    _ = llrp.c.printf(
+        "INFO: Reader  id=%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X\n",
+        r[0],  r[1],  r[2],  r[3],
+        r[4],  r[5],
+        r[6],  r[7],
+        r[8],  r[9],
+        r[10], r[11], r[12], r[13], r[14], r[15],
+    );
+}
+
+/// Format raw EPC bytes as "XXXX-XXXX-..." into a stack buffer.
+/// Returns a slice into `buf`.
+fn fmtEpc(epc: []const u8, buf: []u8) [:0]const u8 {
+    var written: usize = 0;
+    for (epc, 0..) |byte, i| {
+        if (i > 0 and i % 2 == 0) {
+            buf[written] = '-';
+            written += 1;
+        }
+        const pair = std.fmt.bufPrint(buf[written..], "{X:0>2}", .{byte}) catch break;
+        written += pair.len;
+    }
+    buf[written] = 0;
+    return buf[0..written :0];
+}
+
+// ---------------------------------------------------------------------------
+// GPI lifecycle callback
+// ---------------------------------------------------------------------------
+
+fn onGpiEvent(port: u16, state: bool, timestamp_us: u64) void {
+    _ = llrp.c.printf(
+        "GPI    port=%u  state=%s  ts=%llu\n",
+        port,
+        if (state) @as([*:0]const u8, "high") else @as([*:0]const u8, "low"),
+        @as(c_ulonglong, timestamp_us),
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Tag lifecycle callbacks
+// ---------------------------------------------------------------------------
+
+fn onTagEnter(epc: []const u8, antenna: u16, timestamp_us: u64) void {
+    var buf: [96]u8 = undefined;
+    _ = llrp.c.printf(
+        "ENTER  epc=%-32s  ant=%u  ts=%llu\n",
+        (fmtEpc(epc, &buf).ptr),
+        antenna,
+        @as(c_ulonglong, timestamp_us),
+    );
+}
+
+fn onTagExit(
+    epc: []const u8,
+    antenna: u16,
+    first_seen_us: u64,
+    samples: []const tracker.RssiSample,
+) void {
+    var buf: [96]u8 = undefined;
+    const epc_str = fmtEpc(epc, &buf);
+    const stats = rssiStats(samples);
+
+    _ = llrp.c.printf(
+        "EXIT   epc=%-32s  ant=%u  first_seen=%llu  samples=%zu" ++
+            "  mean=%.1fdBm  peak=%ddBm  variance=%.2f  skew=%.3f  entropy=%.3f\n",
+        epc_str.ptr,
+        antenna,
+        @as(c_ulonglong, first_seen_us),
+        samples.len,
+        stats.mean,
+        stats.peak,
+        stats.variance,
+        stats.skew,
+        stats.entropy,
+    );
+}
+
+const RssiStats = struct {
+    mean: f64,
+    peak: i8,
+    variance: f64,
+    skew: f64,
+    entropy: f64,
+};
+
+fn rssiStats(samples: []const tracker.RssiSample) RssiStats {
+    if (samples.len == 0) return .{ .mean = 0, .peak = 0, .variance = 0, .skew = 0, .entropy = 0 };
+
+    const n: f64 = @floatFromInt(samples.len);
+
+    // --- mean and peak ---
+    var sum: f64 = 0;
+    var peak: i8 = samples[0].rssi_dbm;
+    for (samples) |s| {
+        sum += @floatFromInt(s.rssi_dbm);
+        if (s.rssi_dbm > peak) peak = s.rssi_dbm;
+    }
+    const mean = sum / n;
+
+    // --- variance (population) and third central moment for skewness ---
+    var m2: f64 = 0; // sum of (x - mean)^2
+    var m3: f64 = 0; // sum of (x - mean)^3
+    for (samples) |s| {
+        const d: f64 = @as(f64, @floatFromInt(s.rssi_dbm)) - mean;
+        m2 += d * d;
+        m3 += d * d * d;
+    }
+    const variance = m2 / n;
+
+    // Pearson's moment coefficient of skewness; 0 if std dev is negligible.
+    const std_dev = @sqrt(variance);
+    const skew = if (std_dev > 1e-9) (m3 / n) / (std_dev * std_dev * std_dev) else 0.0;
+
+    // --- Shannon entropy over the observed value distribution ---
+    // RSSI is i8; use a 256-bucket counter array indexed by value + 128.
+    var counts = std.mem.zeroes([256]u32);
+    for (samples) |s| counts[@as(u8, @bitCast(s.rssi_dbm))] += 1;
+    var entropy: f64 = 0;
+    for (counts) |c| {
+        if (c == 0) continue;
+        const p: f64 = @as(f64, @floatFromInt(c)) / n;
+        entropy -= p * @log2(p);
+    }
+
+    return .{ .mean = mean, .peak = peak, .variance = variance, .skew = skew, .entropy = entropy };
 }

src/ntp.zig

@@ -0,0 +1,103 @@
+//! Minimal SNTP client (RFC 4330).
+//!
+//! Performs a single round-trip to an NTP server and computes the offset
+//! between the local system clock and UTC so that reported timestamps can
+//! be corrected before being sent to a server.
+//!
+//! Typical usage:
+//!   const offset = ntp.queryOffset(allocator, "pool.ntp.org") catch |err| blk: {
+//!       std.log.warn("NTP query failed ({s}), timestamps may be inaccurate", .{@errorName(err)});
+//!       break :blk 0;
+//!   };
+//!   // corrected_us = std.time.microTimestamp() + offset
+
+const std = @import("std");
+
+const ntp_port: u16 = 123;
+
+/// NTP epoch is 1 Jan 1900; Unix epoch is 1 Jan 1970.
+/// Difference = 70 years = 2 208 988 800 seconds.
+const ntp_to_unix_s: i64 = 2_208_988_800;
+
+/// Decode a 64-bit NTP timestamp starting at `buf[off]` into microseconds
+/// since the Unix epoch.
+fn ntpToUs(buf: []const u8, off: usize) i64 {
+    const secs = std.mem.readInt(u32, buf[off..][0..4], .big);
+    const frac = std.mem.readInt(u32, buf[off + 4 ..][0..4], .big);
+    const unix_s: i64 = @as(i64, secs) - ntp_to_unix_s;
+    // frac / 2^32 * 1_000_000 µs  (no overflow: frac < 2^32, result < 1_000_000)
+    const us_frac: i64 = @intCast((@as(u64, frac) * 1_000_000) >> 32);
+    return unix_s * 1_000_000 + us_frac;
+}
+
+/// Query `server` (hostname or IP) via SNTP and return the estimated clock
+/// offset in microseconds.
+///
+/// Return value semantics:
+///   offset_us = ntp_time_us - local_time_us
+///
+/// To get a corrected UTC timestamp:
+///   corrected_us = std.time.microTimestamp() + offset_us
+///
+/// Uses the standard SNTP offset formula:
+///   offset = ((T2 - T1) + (T3 - T4)) / 2
+/// where T1 = local send time, T2 = server receive, T3 = server transmit,
+/// T4 = local receive time.
+pub fn queryOffset(allocator: std.mem.Allocator, server: []const u8) !i64 {
+    // Resolve hostname.
+    const addr_list = try std.net.getAddressList(allocator, server, ntp_port);
+    defer addr_list.deinit();
+    if (addr_list.addrs.len == 0) return error.NoAddress;
+    const addr = addr_list.addrs[0];
+
+    // Open a UDP socket.
+    const sock = try std.posix.socket(
+        addr.any.family,
+        std.posix.SOCK.DGRAM,
+        std.posix.IPPROTO.UDP,
+    );
+    defer std.posix.close(sock);
+
+    // 2 second receive timeout.
+    const tv = std.posix.timeval{ .sec = 2, .usec = 0 };
+    try std.posix.setsockopt(
+        sock,
+        std.posix.SOL.SOCKET,
+        std.posix.SO.RCVTIMEO,
+        std.mem.asBytes(&tv),
+    );
+
+    // 48-byte SNTP request: only the flags byte is non-zero.
+    //   LI = 0 (no leap second warning)
+    //   VN = 4 (NTP version 4)
+    //   Mode = 3 (client)
+    //   Packed: 0b00_100_011 = 0x23
+    var req = std.mem.zeroes([48]u8);
+    req[0] = 0x23;
+
+    // T1: local clock immediately before send.
+    const t1: i64 = std.time.microTimestamp();
+
+    const sent = try std.posix.sendto(
+        sock,
+        &req,
+        0,
+        &addr.any,
+        addr.getOsSockLen(),
+    );
+    if (sent != 48) return error.SendFailed;
+
+    var resp: [48]u8 = undefined;
+    const n = try std.posix.recvfrom(sock, &resp, 0, null, null);
+    if (n < 48) return error.ShortResponse;
+
+    // T4: local clock immediately after receive.
+    const t4: i64 = std.time.microTimestamp();
+
+    // T2 = server receive timestamp  (bytes 32–39)
+    // T3 = server transmit timestamp (bytes 40–47)
+    const t2 = ntpToUs(&resp, 32);
+    const t3 = ntpToUs(&resp, 40);
+
+    return @divTrunc((t2 - t1) + (t3 - t4), 2);
+}

src/tracker.zig

@@ -0,0 +1,258 @@
+//! Tag presence tracker.
+//!
+//! Turns a stream of LLRP tag observations into enter/exit events per
+//! (EPC, antenna) pair.  A tag is considered "present" from its first
+//! observation until `exit_timeout_us` microseconds pass with no new
+//! observation on the same antenna.
+//!
+//! Call `observe()` for every arriving `llrp.TagObservation`, and call
+//! `checkExpired()` periodically (e.g. after each receive poll) to fire
+//! exit callbacks for tags that have dropped out of view.
+
+const std = @import("std");
+const llrp = @import("llrp.zig");
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/// One RSSI measurement from a continuous inventory scan.
+pub const RssiSample = struct {
+    rssi_dbm: i8,
+    timestamp_us: u64,
+};
+
+/// Called on the first observation of a (tag, antenna) pair.
+///
+/// `epc`          – raw EPC bytes (valid only for the duration of the call)
+/// `antenna`      – 1-based antenna port number reported by the reader
+/// `timestamp_us` – UTC microseconds of the first observation
+pub const OnEnterFn = *const fn (
+    epc: []const u8,
+    antenna: u16,
+    timestamp_us: u64,
+) void;
+
+/// Called when a tag has not been seen on an antenna for `exit_timeout_us`.
+///
+/// `epc`           – raw EPC bytes (valid only for the duration of the call)
+/// `antenna`       – 1-based antenna port number
+/// `first_seen_us` – UTC microseconds of the first observation this visit
+/// `samples`       – RSSI samples collected during the visit; the slice is
+///                   freed immediately after this callback returns
+pub const OnExitFn = *const fn (
+    epc: []const u8,
+    antenna: u16,
+    first_seen_us: u64,
+    samples: []const RssiSample,
+) void;
+
+/// Tuning parameters for the tracker.
+pub const Options = struct {
+    /// How long after the last observation (µs) before a tag is considered
+    /// gone and `on_exit` is fired.  Default: 10 seconds.
+    exit_timeout_us: u64 = 10_000_000,
+
+    /// Duration of each RSSI averaging window (µs).  All observations
+    /// within a window are averaged into a single sample candidate.
+    /// Default: 200 ms.
+    sample_interval_us: u64 = 200_000,
+
+    /// Minimum change from the last stored sample (dBm) required to
+    /// commit a new one.  Intervals whose average falls within this band
+    /// are silently dropped.  Default: 2 dBm.
+    min_delta_dbm: u8 = 2,
+};
+
+// ---------------------------------------------------------------------------
+// Internal types
+// ---------------------------------------------------------------------------
+
+/// HashMap key: (zero-padded EPC, antenna).
+/// Bytes beyond `epc_len` are always zeroed so that auto-hashing produces
+/// consistent results regardless of how the array was allocated.
+const TagKey = struct {
+    epc: [32]u8,
+    epc_len: u8,
+    antenna: u16,
+
+    fn from(obs: llrp.TagObservation) TagKey {
+        return .{
+            .epc = obs.epc,
+            .epc_len = obs.epc_len,
+            .antenna = obs.antenna,
+        };
+    }
+};
+
+const TagEntry = struct {
+    /// Reader UTC timestamp of the first observation this visit.
+    first_seen_us: u64,
+    /// Local wall-clock time (µs) of the most recent observation.
+    /// Using local clock keeps age calculations consistent with `checkExpired`.
+    last_seen_us: u64,
+    /// RSSI of the last committed sample; new intervals are compared against
+    /// this to decide whether the change is worth storing.
+    last_committed_rssi: i8,
+    /// Start of the in-progress averaging window (local clock).
+    pending_start_us: u64,
+    /// Accumulator for the in-progress window.
+    pending_sum: i32,
+    pending_count: u32,
+    rssi_samples: std.ArrayListUnmanaged(RssiSample),
+};
+
+// ---------------------------------------------------------------------------
+// Tracker
+// ---------------------------------------------------------------------------
+
+pub const Tracker = struct {
+    allocator: std.mem.Allocator,
+    on_enter: OnEnterFn,
+    on_exit: OnExitFn,
+    opts: Options,
+    tags: std.AutoHashMap(TagKey, TagEntry),
+
+    pub fn init(
+        allocator: std.mem.Allocator,
+        on_enter: OnEnterFn,
+        on_exit: OnExitFn,
+        opts: Options,
+    ) Tracker {
+        return .{
+            .allocator = allocator,
+            .on_enter = on_enter,
+            .on_exit = on_exit,
+            .opts = opts,
+            .tags = std.AutoHashMap(TagKey, TagEntry).init(allocator),
+        };
+    }
+
+    /// Release all tracked state.  Any tags still in flight are silently
+    /// discarded — call `flush()` first if you need exit callbacks for them.
+    pub fn deinit(self: *Tracker) void {
+        var it = self.tags.valueIterator();
+        while (it.next()) |entry| entry.rssi_samples.deinit(self.allocator);
+        self.tags.deinit();
+    }
+
+    /// Fire `on_exit` for every tag currently tracked, then clear the map.
+    /// Useful for graceful shutdown.
+    pub fn flush(self: *Tracker) void {
+        const now_us: u64 = @intCast(std.time.microTimestamp());
+        var it = self.tags.iterator();
+        while (it.next()) |kv| {
+            const key = kv.key_ptr.*;
+            const entry = kv.value_ptr;
+            // Force-commit any partial averaging window before reporting.
+            self.commitPending(entry, now_us, true) catch {};
+            self.on_exit(
+                key.epc[0..key.epc_len],
+                key.antenna,
+                entry.first_seen_us,
+                entry.rssi_samples.items,
+            );
+            entry.rssi_samples.deinit(self.allocator);
+        }
+        self.tags.clearRetainingCapacity();
+    }
+
+    /// Record one tag observation.  Fires `on_enter` the first time a
+    /// (tag, antenna) pair is seen within a visit.
+    pub fn observe(self: *Tracker, obs: llrp.TagObservation) !void {
+        const key = TagKey.from(obs);
+        const received_us: u64 = @intCast(std.time.microTimestamp());
+        const result = try self.tags.getOrPut(key);
+
+        if (!result.found_existing) {
+            // First observation this visit — store as baseline and fire on_enter.
+            result.value_ptr.* = .{
+                .first_seen_us = obs.timestamp_us,
+                .last_seen_us = received_us,
+                .last_committed_rssi = obs.rssi_dbm,
+                .pending_start_us = received_us,
+                .pending_sum = obs.rssi_dbm,
+                .pending_count = 1,
+                .rssi_samples = .{},
+            };
+            // Always store the first reading as the baseline sample.
+            try result.value_ptr.rssi_samples.append(self.allocator, .{
+                .rssi_dbm = obs.rssi_dbm,
+                .timestamp_us = obs.timestamp_us,
+            });
+            self.on_enter(key.epc[0..key.epc_len], key.antenna, obs.timestamp_us);
+        } else {
+            const entry = result.value_ptr;
+            entry.last_seen_us = received_us;
+            entry.pending_sum += obs.rssi_dbm;
+            entry.pending_count += 1;
+
+            // Commit the averaging window once its duration has elapsed.
+            if (received_us -| entry.pending_start_us >= self.opts.sample_interval_us) {
+                try self.commitPending(entry, obs.timestamp_us, false);
+                entry.pending_start_us = received_us;
+            }
+        }
+    }
+
+    /// Check for tags that have not been seen within `exit_timeout_us` and
+    /// fire `on_exit` for each.  Pass the current UTC time in microseconds
+    /// (e.g. `@as(u64, @intCast(std.time.microTimestamp()))`).
+    pub fn checkExpired(self: *Tracker, now_us: u64) !void {
+        // Collect expired keys first; we cannot remove entries while iterating.
+        var expired: std.ArrayListUnmanaged(TagKey) = .{};
+        defer expired.deinit(self.allocator);
+
+        var it = self.tags.iterator();
+        while (it.next()) |kv| {
+            const age = now_us -| kv.value_ptr.last_seen_us;
+            if (age >= self.opts.exit_timeout_us) {
+                try expired.append(self.allocator, kv.key_ptr.*);
+            }
+        }
+
+        for (expired.items) |key| {
+            if (self.tags.fetchRemove(key)) |kv| {
+                var entry = kv.value;
+                defer entry.rssi_samples.deinit(self.allocator);
+                // Force-commit any partial window before reporting.
+                try self.commitPending(&entry, now_us, true);
+                self.on_exit(
+                    key.epc[0..key.epc_len],
+                    key.antenna,
+                    entry.first_seen_us,
+                    entry.rssi_samples.items,
+                );
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+
+    /// Average the pending window and store a sample if the result differs
+    /// from `last_committed_rssi` by at least `min_delta_dbm`.
+    /// When `force` is true the sample is always stored (used on exit to
+    /// ensure the final reading is captured).
+    /// Resets `pending_sum` and `pending_count` afterwards.
+    fn commitPending(
+        self: *Tracker,
+        entry: *TagEntry,
+        timestamp_us: u64,
+        force: bool,
+    ) !void {
+        if (entry.pending_count == 0) return;
+        const avg: i8 = @intCast(@divTrunc(entry.pending_sum, @as(i32, @intCast(entry.pending_count))));
+        const delta: u8 = @intCast(@min(255, @abs(@as(i16, avg) - @as(i16, entry.last_committed_rssi))));
+        if (force or delta >= self.opts.min_delta_dbm) {
+            try entry.rssi_samples.append(self.allocator, .{
+                .rssi_dbm = avg,
+                .timestamp_us = timestamp_us,
+            });
+            entry.last_committed_rssi = avg;
+        }
+        entry.pending_sum = 0;
+        entry.pending_count = 0;
+    }
+};

vendor/protobuf/account/v1/account.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "account/v1/account.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(account_v1_Account, account_v1_Account, AUTO)
+
+
+

vendor/protobuf/account/v1/account.pb.h

@@ -0,0 +1,62 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ACCOUNT_V1_ACCOUNT_V1_ACCOUNT_PB_H_INCLUDED
+#define PB_ACCOUNT_V1_ACCOUNT_V1_ACCOUNT_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _account_v1_Account {
+    bool has_account_id;
+    util_UUID account_id;
+    pb_callback_t name;
+    pb_callback_t logo;
+    bool has_last_updated;
+    google_protobuf_Timestamp last_updated;
+} account_v1_Account;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define account_v1_Account_init_default          {false, util_UUID_init_default, {{NULL}, NULL}, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default}
+#define account_v1_Account_init_zero             {false, util_UUID_init_zero, {{NULL}, NULL}, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define account_v1_Account_account_id_tag        1
+#define account_v1_Account_name_tag              2
+#define account_v1_Account_logo_tag              3
+#define account_v1_Account_last_updated_tag      4
+
+/* Struct field encoding specification for nanopb */
+#define account_v1_Account_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  account_id,        1) \
+X(a, CALLBACK, SINGULAR, STRING,   name,              2) \
+X(a, CALLBACK, OPTIONAL, STRING,   logo,              3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_updated,      4)
+#define account_v1_Account_CALLBACK pb_default_field_callback
+#define account_v1_Account_DEFAULT NULL
+#define account_v1_Account_account_id_MSGTYPE util_UUID
+#define account_v1_Account_last_updated_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t account_v1_Account_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define account_v1_Account_fields &account_v1_Account_msg
+
+/* Maximum encoded size of messages (where known) */
+/* account_v1_Account_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/account/v1/create.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "account/v1/create.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(account_v1_CreateAccountRequest, account_v1_CreateAccountRequest, AUTO)
+
+
+PB_BIND(account_v1_CreateAccountResponse, account_v1_CreateAccountResponse, AUTO)
+
+
+

vendor/protobuf/account/v1/create.pb.h

@@ -0,0 +1,65 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ACCOUNT_V1_ACCOUNT_V1_CREATE_PB_H_INCLUDED
+#define PB_ACCOUNT_V1_ACCOUNT_V1_CREATE_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _account_v1_CreateAccountRequest {
+    pb_callback_t name;
+    pb_callback_t logo;
+} account_v1_CreateAccountRequest;
+
+typedef struct _account_v1_CreateAccountResponse {
+    char dummy_field;
+} account_v1_CreateAccountResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define account_v1_CreateAccountRequest_init_default {{{NULL}, NULL}, {{NULL}, NULL}}
+#define account_v1_CreateAccountResponse_init_default {0}
+#define account_v1_CreateAccountRequest_init_zero {{{NULL}, NULL}, {{NULL}, NULL}}
+#define account_v1_CreateAccountResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define account_v1_CreateAccountRequest_name_tag 1
+#define account_v1_CreateAccountRequest_logo_tag 2
+
+/* Struct field encoding specification for nanopb */
+#define account_v1_CreateAccountRequest_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   name,              1) \
+X(a, CALLBACK, OPTIONAL, STRING,   logo,              2)
+#define account_v1_CreateAccountRequest_CALLBACK pb_default_field_callback
+#define account_v1_CreateAccountRequest_DEFAULT NULL
+
+#define account_v1_CreateAccountResponse_FIELDLIST(X, a) \
+
+#define account_v1_CreateAccountResponse_CALLBACK NULL
+#define account_v1_CreateAccountResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t account_v1_CreateAccountRequest_msg;
+extern const pb_msgdesc_t account_v1_CreateAccountResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define account_v1_CreateAccountRequest_fields &account_v1_CreateAccountRequest_msg
+#define account_v1_CreateAccountResponse_fields &account_v1_CreateAccountResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* account_v1_CreateAccountRequest_size depends on runtime parameters */
+#define account_v1_CreateAccountResponse_size    0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/account/v1/get.pb.c

@@ -0,0 +1,21 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "account/v1/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(account_v1_GetAccountRequest, account_v1_GetAccountRequest, AUTO)
+
+
+PB_BIND(account_v1_GetAccountResponse, account_v1_GetAccountResponse, AUTO)
+
+
+PB_BIND(account_v1_GetAccountsRequest, account_v1_GetAccountsRequest, AUTO)
+
+
+PB_BIND(account_v1_GetAccountsResponse, account_v1_GetAccountsResponse, AUTO)
+
+
+

vendor/protobuf/account/v1/get.pb.h

@@ -0,0 +1,103 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ACCOUNT_V1_ACCOUNT_V1_GET_PB_H_INCLUDED
+#define PB_ACCOUNT_V1_ACCOUNT_V1_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "account/v1/account.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _account_v1_GetAccountRequest {
+    bool has_account_id;
+    util_UUID account_id;
+} account_v1_GetAccountRequest;
+
+typedef struct _account_v1_GetAccountResponse {
+    bool has_account;
+    account_v1_Account account;
+} account_v1_GetAccountResponse;
+
+typedef struct _account_v1_GetAccountsRequest {
+    char dummy_field;
+} account_v1_GetAccountsRequest;
+
+typedef struct _account_v1_GetAccountsResponse {
+    pb_callback_t accounts;
+} account_v1_GetAccountsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define account_v1_GetAccountRequest_init_default {false, util_UUID_init_default}
+#define account_v1_GetAccountResponse_init_default {false, account_v1_Account_init_default}
+#define account_v1_GetAccountsRequest_init_default {0}
+#define account_v1_GetAccountsResponse_init_default {{{NULL}, NULL}}
+#define account_v1_GetAccountRequest_init_zero   {false, util_UUID_init_zero}
+#define account_v1_GetAccountResponse_init_zero  {false, account_v1_Account_init_zero}
+#define account_v1_GetAccountsRequest_init_zero  {0}
+#define account_v1_GetAccountsResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define account_v1_GetAccountRequest_account_id_tag 1
+#define account_v1_GetAccountResponse_account_tag 1
+#define account_v1_GetAccountsResponse_accounts_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define account_v1_GetAccountRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  account_id,        1)
+#define account_v1_GetAccountRequest_CALLBACK NULL
+#define account_v1_GetAccountRequest_DEFAULT NULL
+#define account_v1_GetAccountRequest_account_id_MSGTYPE util_UUID
+
+#define account_v1_GetAccountResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  account,           1)
+#define account_v1_GetAccountResponse_CALLBACK NULL
+#define account_v1_GetAccountResponse_DEFAULT NULL
+#define account_v1_GetAccountResponse_account_MSGTYPE account_v1_Account
+
+#define account_v1_GetAccountsRequest_FIELDLIST(X, a) \
+
+#define account_v1_GetAccountsRequest_CALLBACK NULL
+#define account_v1_GetAccountsRequest_DEFAULT NULL
+
+#define account_v1_GetAccountsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  accounts,          1)
+#define account_v1_GetAccountsResponse_CALLBACK pb_default_field_callback
+#define account_v1_GetAccountsResponse_DEFAULT NULL
+#define account_v1_GetAccountsResponse_accounts_MSGTYPE account_v1_Account
+
+extern const pb_msgdesc_t account_v1_GetAccountRequest_msg;
+extern const pb_msgdesc_t account_v1_GetAccountResponse_msg;
+extern const pb_msgdesc_t account_v1_GetAccountsRequest_msg;
+extern const pb_msgdesc_t account_v1_GetAccountsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define account_v1_GetAccountRequest_fields &account_v1_GetAccountRequest_msg
+#define account_v1_GetAccountResponse_fields &account_v1_GetAccountResponse_msg
+#define account_v1_GetAccountsRequest_fields &account_v1_GetAccountsRequest_msg
+#define account_v1_GetAccountsResponse_fields &account_v1_GetAccountsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* account_v1_GetAccountsResponse_size depends on runtime parameters */
+#if defined(util_UUID_size)
+#define ACCOUNT_V1_ACCOUNT_V1_GET_PB_H_MAX_SIZE  account_v1_GetAccountRequest_size
+#define account_v1_GetAccountRequest_size        (6 + util_UUID_size)
+#endif
+#if defined(account_v1_Account_size)
+#define account_v1_GetAccountResponse_size       (6 + account_v1_Account_size)
+#endif
+#define account_v1_GetAccountsRequest_size       0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/account/v1/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "account/v1/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/account/v1/service.pb.h

@@ -0,0 +1,22 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ACCOUNT_V1_ACCOUNT_V1_SERVICE_PB_H_INCLUDED
+#define PB_ACCOUNT_V1_ACCOUNT_V1_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "account/v1/create.pb.h"
+#include "account/v1/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/antenna.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/antenna.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(antenna_v1_Antenna, antenna_v1_Antenna, 2)
+
+
+

vendor/protobuf/antenna/v1/antenna.pb.h

@@ -0,0 +1,87 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_ANTENNA_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_ANTENNA_PB_H_INCLUDED
+#include <pb.h>
+#include "antenna/v1/settings.pb.h"
+#include "buf/validate/validate.pb.h"
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _antenna_v1_Antenna {
+    bool has_reader_id;
+    util_UUID reader_id;
+    uint32_t antenna; /* max uint8 */
+    /* metadata */
+    uint32_t power;
+    bool connected;
+    bool has_last_updated;
+    google_protobuf_Timestamp last_updated;
+    /* aggregates */
+    bool has_read_count;
+    uint64_t read_count;
+    bool has_last_read_timestamp;
+    google_protobuf_Timestamp last_read_timestamp;
+    /* settings */
+    bool has_settings;
+    antenna_v1_Settings settings;
+} antenna_v1_Antenna;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define antenna_v1_Antenna_init_default          {false, util_UUID_init_default, 0, 0, 0, false, google_protobuf_Timestamp_init_default, false, 0, false, google_protobuf_Timestamp_init_default, false, antenna_v1_Settings_init_default}
+#define antenna_v1_Antenna_init_zero             {false, util_UUID_init_zero, 0, 0, 0, false, google_protobuf_Timestamp_init_zero, false, 0, false, google_protobuf_Timestamp_init_zero, false, antenna_v1_Settings_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define antenna_v1_Antenna_reader_id_tag         1
+#define antenna_v1_Antenna_antenna_tag           2
+#define antenna_v1_Antenna_power_tag             3
+#define antenna_v1_Antenna_connected_tag         4
+#define antenna_v1_Antenna_last_updated_tag      5
+#define antenna_v1_Antenna_read_count_tag        6
+#define antenna_v1_Antenna_last_read_timestamp_tag 7
+#define antenna_v1_Antenna_settings_tag          8
+
+/* Struct field encoding specification for nanopb */
+#define antenna_v1_Antenna_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, STATIC,   SINGULAR, UINT32,   antenna,           2) \
+X(a, STATIC,   SINGULAR, UINT32,   power,             3) \
+X(a, STATIC,   SINGULAR, BOOL,     connected,         4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_updated,      5) \
+X(a, STATIC,   OPTIONAL, UINT64,   read_count,        6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_read_timestamp,   7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,          8)
+#define antenna_v1_Antenna_CALLBACK NULL
+#define antenna_v1_Antenna_DEFAULT NULL
+#define antenna_v1_Antenna_reader_id_MSGTYPE util_UUID
+#define antenna_v1_Antenna_last_updated_MSGTYPE google_protobuf_Timestamp
+#define antenna_v1_Antenna_last_read_timestamp_MSGTYPE google_protobuf_Timestamp
+#define antenna_v1_Antenna_settings_MSGTYPE antenna_v1_Settings
+
+extern const pb_msgdesc_t antenna_v1_Antenna_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define antenna_v1_Antenna_fields &antenna_v1_Antenna_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size) && defined(antenna_v1_Settings_size)
+#define ANTENNA_V1_ANTENNA_V1_ANTENNA_PB_H_MAX_SIZE antenna_v1_Antenna_size
+#define antenna_v1_Antenna_size                  (85 + util_UUID_size + antenna_v1_Settings_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/create.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/create.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(antenna_v1_CreateAntennaRequest, antenna_v1_CreateAntennaRequest, AUTO)
+
+
+PB_BIND(antenna_v1_CreateAntennaResponse, antenna_v1_CreateAntennaResponse, 2)
+
+
+

vendor/protobuf/antenna/v1/create.pb.h

@@ -0,0 +1,83 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_CREATE_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_CREATE_PB_H_INCLUDED
+#include <pb.h>
+#include "antenna/v1/antenna.pb.h"
+#include "buf/validate/validate.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _antenna_v1_CreateAntennaRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+    uint32_t antenna; /* max uint8 */
+    uint32_t power;
+    bool connected;
+} antenna_v1_CreateAntennaRequest;
+
+typedef struct _antenna_v1_CreateAntennaResponse {
+    bool has_antenna;
+    antenna_v1_Antenna antenna;
+} antenna_v1_CreateAntennaResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define antenna_v1_CreateAntennaRequest_init_default {false, util_UUID_init_default, 0, 0, 0}
+#define antenna_v1_CreateAntennaResponse_init_default {false, antenna_v1_Antenna_init_default}
+#define antenna_v1_CreateAntennaRequest_init_zero {false, util_UUID_init_zero, 0, 0, 0}
+#define antenna_v1_CreateAntennaResponse_init_zero {false, antenna_v1_Antenna_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define antenna_v1_CreateAntennaRequest_reader_id_tag 1
+#define antenna_v1_CreateAntennaRequest_antenna_tag 2
+#define antenna_v1_CreateAntennaRequest_power_tag 3
+#define antenna_v1_CreateAntennaRequest_connected_tag 4
+#define antenna_v1_CreateAntennaResponse_antenna_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define antenna_v1_CreateAntennaRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, STATIC,   SINGULAR, UINT32,   antenna,           2) \
+X(a, STATIC,   SINGULAR, UINT32,   power,             3) \
+X(a, STATIC,   SINGULAR, BOOL,     connected,         4)
+#define antenna_v1_CreateAntennaRequest_CALLBACK NULL
+#define antenna_v1_CreateAntennaRequest_DEFAULT NULL
+#define antenna_v1_CreateAntennaRequest_reader_id_MSGTYPE util_UUID
+
+#define antenna_v1_CreateAntennaResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  antenna,           1)
+#define antenna_v1_CreateAntennaResponse_CALLBACK NULL
+#define antenna_v1_CreateAntennaResponse_DEFAULT NULL
+#define antenna_v1_CreateAntennaResponse_antenna_MSGTYPE antenna_v1_Antenna
+
+extern const pb_msgdesc_t antenna_v1_CreateAntennaRequest_msg;
+extern const pb_msgdesc_t antenna_v1_CreateAntennaResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define antenna_v1_CreateAntennaRequest_fields &antenna_v1_CreateAntennaRequest_msg
+#define antenna_v1_CreateAntennaResponse_fields &antenna_v1_CreateAntennaResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define ANTENNA_V1_ANTENNA_V1_CREATE_PB_H_MAX_SIZE antenna_v1_CreateAntennaRequest_size
+#define antenna_v1_CreateAntennaRequest_size     (20 + util_UUID_size)
+#endif
+#if defined(antenna_v1_Antenna_size)
+#define antenna_v1_CreateAntennaResponse_size    (6 + antenna_v1_Antenna_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/get.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(antenna_v1_GetAntennasRequest, antenna_v1_GetAntennasRequest, AUTO)
+
+
+PB_BIND(antenna_v1_GetAntennasResponse, antenna_v1_GetAntennasResponse, AUTO)
+
+
+

vendor/protobuf/antenna/v1/get.pb.h

@@ -0,0 +1,70 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_GET_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "antenna/v1/antenna.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _antenna_v1_GetAntennasRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+} antenna_v1_GetAntennasRequest;
+
+typedef struct _antenna_v1_GetAntennasResponse {
+    pb_callback_t antennas;
+} antenna_v1_GetAntennasResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define antenna_v1_GetAntennasRequest_init_default {false, util_UUID_init_default}
+#define antenna_v1_GetAntennasResponse_init_default {{{NULL}, NULL}}
+#define antenna_v1_GetAntennasRequest_init_zero  {false, util_UUID_init_zero}
+#define antenna_v1_GetAntennasResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define antenna_v1_GetAntennasRequest_reader_id_tag 1
+#define antenna_v1_GetAntennasResponse_antennas_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define antenna_v1_GetAntennasRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1)
+#define antenna_v1_GetAntennasRequest_CALLBACK NULL
+#define antenna_v1_GetAntennasRequest_DEFAULT NULL
+#define antenna_v1_GetAntennasRequest_reader_id_MSGTYPE util_UUID
+
+#define antenna_v1_GetAntennasResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  antennas,          1)
+#define antenna_v1_GetAntennasResponse_CALLBACK pb_default_field_callback
+#define antenna_v1_GetAntennasResponse_DEFAULT NULL
+#define antenna_v1_GetAntennasResponse_antennas_MSGTYPE antenna_v1_Antenna
+
+extern const pb_msgdesc_t antenna_v1_GetAntennasRequest_msg;
+extern const pb_msgdesc_t antenna_v1_GetAntennasResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define antenna_v1_GetAntennasRequest_fields &antenna_v1_GetAntennasRequest_msg
+#define antenna_v1_GetAntennasResponse_fields &antenna_v1_GetAntennasResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* antenna_v1_GetAntennasResponse_size depends on runtime parameters */
+#if defined(util_UUID_size)
+#define ANTENNA_V1_ANTENNA_V1_GET_PB_H_MAX_SIZE  antenna_v1_GetAntennasRequest_size
+#define antenna_v1_GetAntennasRequest_size       (6 + util_UUID_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/antenna/v1/service.pb.h

@@ -0,0 +1,24 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_SERVICE_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "antenna/v1/create.pb.h"
+#include "antenna/v1/get.pb.h"
+#include "antenna/v1/subscribe.pb.h"
+#include "antenna/v1/update.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/settings.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/settings.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(antenna_v1_Settings, antenna_v1_Settings, AUTO)
+
+
+

vendor/protobuf/antenna/v1/settings.pb.h

@@ -0,0 +1,82 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_SETTINGS_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_SETTINGS_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "util/between.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _antenna_v1_Settings {
+    pb_callback_t epc_prefix;
+    bool has_total;
+    util_UInt64Between total;
+    bool has_peak_rssi;
+    util_SInt32Between peak_rssi;
+    bool has_skew_rssi;
+    util_DoubleBetween skew_rssi;
+    bool has_variance_rssi;
+    util_DoubleBetween variance_rssi;
+    bool has_entropy_rssi;
+    util_DoubleBetween entropy_rssi;
+    bool has_duration;
+    util_DurationBetween duration;
+    pb_callback_t signals;
+} antenna_v1_Settings;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define antenna_v1_Settings_init_default         {{{NULL}, NULL}, false, util_UInt64Between_init_default, false, util_SInt32Between_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DurationBetween_init_default, {{NULL}, NULL}}
+#define antenna_v1_Settings_init_zero            {{{NULL}, NULL}, false, util_UInt64Between_init_zero, false, util_SInt32Between_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DurationBetween_init_zero, {{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define antenna_v1_Settings_epc_prefix_tag       1
+#define antenna_v1_Settings_total_tag            2
+#define antenna_v1_Settings_peak_rssi_tag        3
+#define antenna_v1_Settings_skew_rssi_tag        4
+#define antenna_v1_Settings_variance_rssi_tag    5
+#define antenna_v1_Settings_entropy_rssi_tag     6
+#define antenna_v1_Settings_duration_tag         7
+#define antenna_v1_Settings_signals_tag          8
+
+/* Struct field encoding specification for nanopb */
+#define antenna_v1_Settings_FIELDLIST(X, a) \
+X(a, CALLBACK, OPTIONAL, STRING,   epc_prefix,        1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  total,             2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  peak_rssi,         3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  skew_rssi,         4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  variance_rssi,     5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  entropy_rssi,      6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  duration,          7) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,           8)
+#define antenna_v1_Settings_CALLBACK pb_default_field_callback
+#define antenna_v1_Settings_DEFAULT NULL
+#define antenna_v1_Settings_total_MSGTYPE util_UInt64Between
+#define antenna_v1_Settings_peak_rssi_MSGTYPE util_SInt32Between
+#define antenna_v1_Settings_skew_rssi_MSGTYPE util_DoubleBetween
+#define antenna_v1_Settings_variance_rssi_MSGTYPE util_DoubleBetween
+#define antenna_v1_Settings_entropy_rssi_MSGTYPE util_DoubleBetween
+#define antenna_v1_Settings_duration_MSGTYPE util_DurationBetween
+
+extern const pb_msgdesc_t antenna_v1_Settings_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define antenna_v1_Settings_fields &antenna_v1_Settings_msg
+
+/* Maximum encoded size of messages (where known) */
+/* antenna_v1_Settings_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/subscribe.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/subscribe.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(antenna_v1_SubscribeAntennaRequest, antenna_v1_SubscribeAntennaRequest, AUTO)
+
+
+PB_BIND(antenna_v1_SubscribeAntennaResponse, antenna_v1_SubscribeAntennaResponse, 2)
+
+
+

vendor/protobuf/antenna/v1/subscribe.pb.h

@@ -0,0 +1,73 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_SUBSCRIBE_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_SUBSCRIBE_PB_H_INCLUDED
+#include <pb.h>
+#include "antenna/v1/antenna.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _antenna_v1_SubscribeAntennaRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+} antenna_v1_SubscribeAntennaRequest;
+
+typedef struct _antenna_v1_SubscribeAntennaResponse {
+    bool has_antenna;
+    antenna_v1_Antenna antenna;
+} antenna_v1_SubscribeAntennaResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define antenna_v1_SubscribeAntennaRequest_init_default {false, util_UUID_init_default}
+#define antenna_v1_SubscribeAntennaResponse_init_default {false, antenna_v1_Antenna_init_default}
+#define antenna_v1_SubscribeAntennaRequest_init_zero {false, util_UUID_init_zero}
+#define antenna_v1_SubscribeAntennaResponse_init_zero {false, antenna_v1_Antenna_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define antenna_v1_SubscribeAntennaRequest_reader_id_tag 1
+#define antenna_v1_SubscribeAntennaResponse_antenna_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define antenna_v1_SubscribeAntennaRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1)
+#define antenna_v1_SubscribeAntennaRequest_CALLBACK NULL
+#define antenna_v1_SubscribeAntennaRequest_DEFAULT NULL
+#define antenna_v1_SubscribeAntennaRequest_reader_id_MSGTYPE util_UUID
+
+#define antenna_v1_SubscribeAntennaResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  antenna,           1)
+#define antenna_v1_SubscribeAntennaResponse_CALLBACK NULL
+#define antenna_v1_SubscribeAntennaResponse_DEFAULT NULL
+#define antenna_v1_SubscribeAntennaResponse_antenna_MSGTYPE antenna_v1_Antenna
+
+extern const pb_msgdesc_t antenna_v1_SubscribeAntennaRequest_msg;
+extern const pb_msgdesc_t antenna_v1_SubscribeAntennaResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define antenna_v1_SubscribeAntennaRequest_fields &antenna_v1_SubscribeAntennaRequest_msg
+#define antenna_v1_SubscribeAntennaResponse_fields &antenna_v1_SubscribeAntennaResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define ANTENNA_V1_ANTENNA_V1_SUBSCRIBE_PB_H_MAX_SIZE antenna_v1_SubscribeAntennaRequest_size
+#define antenna_v1_SubscribeAntennaRequest_size  (6 + util_UUID_size)
+#endif
+#if defined(antenna_v1_Antenna_size)
+#define antenna_v1_SubscribeAntennaResponse_size (6 + antenna_v1_Antenna_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/antenna/v1/update.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "antenna/v1/update.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(antenna_v1_UpdateAntennaRequest, antenna_v1_UpdateAntennaRequest, AUTO)
+
+
+PB_BIND(antenna_v1_UpdateAntennaResponse, antenna_v1_UpdateAntennaResponse, AUTO)
+
+
+

vendor/protobuf/antenna/v1/update.pb.h

@@ -0,0 +1,87 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_ANTENNA_V1_ANTENNA_V1_UPDATE_PB_H_INCLUDED
+#define PB_ANTENNA_V1_ANTENNA_V1_UPDATE_PB_H_INCLUDED
+#include <pb.h>
+#include "antenna/v1/settings.pb.h"
+#include "buf/validate/validate.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _antenna_v1_UpdateAntennaRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+    uint32_t antenna; /* max uint8 */
+    /* metadata */
+    bool has_power;
+    uint32_t power;
+    bool has_connected;
+    bool connected;
+    /* settings */
+    bool has_settings;
+    antenna_v1_Settings settings;
+} antenna_v1_UpdateAntennaRequest;
+
+typedef struct _antenna_v1_UpdateAntennaResponse {
+    char dummy_field;
+} antenna_v1_UpdateAntennaResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define antenna_v1_UpdateAntennaRequest_init_default {false, util_UUID_init_default, 0, false, 0, false, 0, false, antenna_v1_Settings_init_default}
+#define antenna_v1_UpdateAntennaResponse_init_default {0}
+#define antenna_v1_UpdateAntennaRequest_init_zero {false, util_UUID_init_zero, 0, false, 0, false, 0, false, antenna_v1_Settings_init_zero}
+#define antenna_v1_UpdateAntennaResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define antenna_v1_UpdateAntennaRequest_reader_id_tag 1
+#define antenna_v1_UpdateAntennaRequest_antenna_tag 2
+#define antenna_v1_UpdateAntennaRequest_power_tag 3
+#define antenna_v1_UpdateAntennaRequest_connected_tag 4
+#define antenna_v1_UpdateAntennaRequest_settings_tag 5
+
+/* Struct field encoding specification for nanopb */
+#define antenna_v1_UpdateAntennaRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, STATIC,   SINGULAR, UINT32,   antenna,           2) \
+X(a, STATIC,   OPTIONAL, UINT32,   power,             3) \
+X(a, STATIC,   OPTIONAL, BOOL,     connected,         4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,          5)
+#define antenna_v1_UpdateAntennaRequest_CALLBACK NULL
+#define antenna_v1_UpdateAntennaRequest_DEFAULT NULL
+#define antenna_v1_UpdateAntennaRequest_reader_id_MSGTYPE util_UUID
+#define antenna_v1_UpdateAntennaRequest_settings_MSGTYPE antenna_v1_Settings
+
+#define antenna_v1_UpdateAntennaResponse_FIELDLIST(X, a) \
+
+#define antenna_v1_UpdateAntennaResponse_CALLBACK NULL
+#define antenna_v1_UpdateAntennaResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t antenna_v1_UpdateAntennaRequest_msg;
+extern const pb_msgdesc_t antenna_v1_UpdateAntennaResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define antenna_v1_UpdateAntennaRequest_fields &antenna_v1_UpdateAntennaRequest_msg
+#define antenna_v1_UpdateAntennaResponse_fields &antenna_v1_UpdateAntennaResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size) && defined(antenna_v1_Settings_size)
+#define ANTENNA_V1_ANTENNA_V1_UPDATE_PB_H_MAX_SIZE antenna_v1_UpdateAntennaRequest_size
+#define antenna_v1_UpdateAntennaRequest_size     (26 + util_UUID_size + antenna_v1_Settings_size)
+#endif
+#define antenna_v1_UpdateAntennaResponse_size    0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/location/v1/create.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "location/v1/create.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(location_v1_CreateLocationRequest, location_v1_CreateLocationRequest, AUTO)
+
+
+PB_BIND(location_v1_CreateLocationResponse, location_v1_CreateLocationResponse, AUTO)
+
+
+

vendor/protobuf/location/v1/create.pb.h

@@ -0,0 +1,69 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_LOCATION_V1_LOCATION_V1_CREATE_PB_H_INCLUDED
+#define PB_LOCATION_V1_LOCATION_V1_CREATE_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _location_v1_CreateLocationRequest {
+    pb_callback_t name;
+} location_v1_CreateLocationRequest;
+
+typedef struct _location_v1_CreateLocationResponse {
+    bool has_location_id;
+    util_UUID location_id;
+} location_v1_CreateLocationResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define location_v1_CreateLocationRequest_init_default {{{NULL}, NULL}}
+#define location_v1_CreateLocationResponse_init_default {false, util_UUID_init_default}
+#define location_v1_CreateLocationRequest_init_zero {{{NULL}, NULL}}
+#define location_v1_CreateLocationResponse_init_zero {false, util_UUID_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define location_v1_CreateLocationRequest_name_tag 1
+#define location_v1_CreateLocationResponse_location_id_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define location_v1_CreateLocationRequest_FIELDLIST(X, a) \
+X(a, CALLBACK, OPTIONAL, STRING,   name,              1)
+#define location_v1_CreateLocationRequest_CALLBACK pb_default_field_callback
+#define location_v1_CreateLocationRequest_DEFAULT NULL
+
+#define location_v1_CreateLocationResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location_id,       1)
+#define location_v1_CreateLocationResponse_CALLBACK NULL
+#define location_v1_CreateLocationResponse_DEFAULT NULL
+#define location_v1_CreateLocationResponse_location_id_MSGTYPE util_UUID
+
+extern const pb_msgdesc_t location_v1_CreateLocationRequest_msg;
+extern const pb_msgdesc_t location_v1_CreateLocationResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define location_v1_CreateLocationRequest_fields &location_v1_CreateLocationRequest_msg
+#define location_v1_CreateLocationResponse_fields &location_v1_CreateLocationResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* location_v1_CreateLocationRequest_size depends on runtime parameters */
+#if defined(util_UUID_size)
+#define LOCATION_V1_LOCATION_V1_CREATE_PB_H_MAX_SIZE location_v1_CreateLocationResponse_size
+#define location_v1_CreateLocationResponse_size  (6 + util_UUID_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/location/v1/delete.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "location/v1/delete.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(location_v1_DeleteLocationRequest, location_v1_DeleteLocationRequest, AUTO)
+
+
+PB_BIND(location_v1_DeleteLocationResponse, location_v1_DeleteLocationResponse, AUTO)
+
+
+

vendor/protobuf/location/v1/delete.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_LOCATION_V1_LOCATION_V1_DELETE_PB_H_INCLUDED
+#define PB_LOCATION_V1_LOCATION_V1_DELETE_PB_H_INCLUDED
+#include <pb.h>
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _location_v1_DeleteLocationRequest {
+    bool has_location_id;
+    util_UUID location_id;
+} location_v1_DeleteLocationRequest;
+
+typedef struct _location_v1_DeleteLocationResponse {
+    char dummy_field;
+} location_v1_DeleteLocationResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define location_v1_DeleteLocationRequest_init_default {false, util_UUID_init_default}
+#define location_v1_DeleteLocationResponse_init_default {0}
+#define location_v1_DeleteLocationRequest_init_zero {false, util_UUID_init_zero}
+#define location_v1_DeleteLocationResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define location_v1_DeleteLocationRequest_location_id_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define location_v1_DeleteLocationRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location_id,       1)
+#define location_v1_DeleteLocationRequest_CALLBACK NULL
+#define location_v1_DeleteLocationRequest_DEFAULT NULL
+#define location_v1_DeleteLocationRequest_location_id_MSGTYPE util_UUID
+
+#define location_v1_DeleteLocationResponse_FIELDLIST(X, a) \
+
+#define location_v1_DeleteLocationResponse_CALLBACK NULL
+#define location_v1_DeleteLocationResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t location_v1_DeleteLocationRequest_msg;
+extern const pb_msgdesc_t location_v1_DeleteLocationResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define location_v1_DeleteLocationRequest_fields &location_v1_DeleteLocationRequest_msg
+#define location_v1_DeleteLocationResponse_fields &location_v1_DeleteLocationResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define LOCATION_V1_LOCATION_V1_DELETE_PB_H_MAX_SIZE location_v1_DeleteLocationRequest_size
+#define location_v1_DeleteLocationRequest_size   (6 + util_UUID_size)
+#endif
+#define location_v1_DeleteLocationResponse_size  0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/location/v1/get.pb.c

@@ -0,0 +1,21 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "location/v1/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(location_v1_GetLocationRequest, location_v1_GetLocationRequest, AUTO)
+
+
+PB_BIND(location_v1_GetLocationResponse, location_v1_GetLocationResponse, AUTO)
+
+
+PB_BIND(location_v1_GetLocationsRequest, location_v1_GetLocationsRequest, AUTO)
+
+
+PB_BIND(location_v1_GetLocationsResponse, location_v1_GetLocationsResponse, AUTO)
+
+
+

vendor/protobuf/location/v1/get.pb.h

@@ -0,0 +1,103 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_LOCATION_V1_LOCATION_V1_GET_PB_H_INCLUDED
+#define PB_LOCATION_V1_LOCATION_V1_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "location/v1/location.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _location_v1_GetLocationRequest {
+    bool has_location_id;
+    util_UUID location_id;
+} location_v1_GetLocationRequest;
+
+typedef struct _location_v1_GetLocationResponse {
+    bool has_location;
+    location_v1_Location location;
+} location_v1_GetLocationResponse;
+
+typedef struct _location_v1_GetLocationsRequest {
+    char dummy_field;
+} location_v1_GetLocationsRequest;
+
+typedef struct _location_v1_GetLocationsResponse {
+    pb_callback_t locations;
+} location_v1_GetLocationsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define location_v1_GetLocationRequest_init_default {false, util_UUID_init_default}
+#define location_v1_GetLocationResponse_init_default {false, location_v1_Location_init_default}
+#define location_v1_GetLocationsRequest_init_default {0}
+#define location_v1_GetLocationsResponse_init_default {{{NULL}, NULL}}
+#define location_v1_GetLocationRequest_init_zero {false, util_UUID_init_zero}
+#define location_v1_GetLocationResponse_init_zero {false, location_v1_Location_init_zero}
+#define location_v1_GetLocationsRequest_init_zero {0}
+#define location_v1_GetLocationsResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define location_v1_GetLocationRequest_location_id_tag 1
+#define location_v1_GetLocationResponse_location_tag 1
+#define location_v1_GetLocationsResponse_locations_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define location_v1_GetLocationRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location_id,       1)
+#define location_v1_GetLocationRequest_CALLBACK NULL
+#define location_v1_GetLocationRequest_DEFAULT NULL
+#define location_v1_GetLocationRequest_location_id_MSGTYPE util_UUID
+
+#define location_v1_GetLocationResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location,          1)
+#define location_v1_GetLocationResponse_CALLBACK NULL
+#define location_v1_GetLocationResponse_DEFAULT NULL
+#define location_v1_GetLocationResponse_location_MSGTYPE location_v1_Location
+
+#define location_v1_GetLocationsRequest_FIELDLIST(X, a) \
+
+#define location_v1_GetLocationsRequest_CALLBACK NULL
+#define location_v1_GetLocationsRequest_DEFAULT NULL
+
+#define location_v1_GetLocationsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  locations,         1)
+#define location_v1_GetLocationsResponse_CALLBACK pb_default_field_callback
+#define location_v1_GetLocationsResponse_DEFAULT NULL
+#define location_v1_GetLocationsResponse_locations_MSGTYPE location_v1_Location
+
+extern const pb_msgdesc_t location_v1_GetLocationRequest_msg;
+extern const pb_msgdesc_t location_v1_GetLocationResponse_msg;
+extern const pb_msgdesc_t location_v1_GetLocationsRequest_msg;
+extern const pb_msgdesc_t location_v1_GetLocationsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define location_v1_GetLocationRequest_fields &location_v1_GetLocationRequest_msg
+#define location_v1_GetLocationResponse_fields &location_v1_GetLocationResponse_msg
+#define location_v1_GetLocationsRequest_fields &location_v1_GetLocationsRequest_msg
+#define location_v1_GetLocationsResponse_fields &location_v1_GetLocationsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* location_v1_GetLocationsResponse_size depends on runtime parameters */
+#if defined(util_UUID_size)
+#define LOCATION_V1_LOCATION_V1_GET_PB_H_MAX_SIZE location_v1_GetLocationRequest_size
+#define location_v1_GetLocationRequest_size      (6 + util_UUID_size)
+#endif
+#if defined(location_v1_Location_size)
+#define location_v1_GetLocationResponse_size     (6 + location_v1_Location_size)
+#endif
+#define location_v1_GetLocationsRequest_size     0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/location/v1/location.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "location/v1/location.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(location_v1_Location, location_v1_Location, AUTO)
+
+
+

vendor/protobuf/location/v1/location.pb.h

@@ -0,0 +1,59 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_LOCATION_V1_LOCATION_V1_LOCATION_PB_H_INCLUDED
+#define PB_LOCATION_V1_LOCATION_V1_LOCATION_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _location_v1_Location {
+    bool has_location_id;
+    util_UUID location_id;
+    pb_callback_t name;
+    bool has_last_updated;
+    google_protobuf_Timestamp last_updated;
+} location_v1_Location;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define location_v1_Location_init_default        {false, util_UUID_init_default, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default}
+#define location_v1_Location_init_zero           {false, util_UUID_init_zero, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define location_v1_Location_location_id_tag     1
+#define location_v1_Location_name_tag            2
+#define location_v1_Location_last_updated_tag    3
+
+/* Struct field encoding specification for nanopb */
+#define location_v1_Location_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location_id,       1) \
+X(a, CALLBACK, OPTIONAL, STRING,   name,              2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_updated,      3)
+#define location_v1_Location_CALLBACK pb_default_field_callback
+#define location_v1_Location_DEFAULT NULL
+#define location_v1_Location_location_id_MSGTYPE util_UUID
+#define location_v1_Location_last_updated_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t location_v1_Location_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define location_v1_Location_fields &location_v1_Location_msg
+
+/* Maximum encoded size of messages (where known) */
+/* location_v1_Location_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/location/v1/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "location/v1/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/location/v1/service.pb.h

@@ -0,0 +1,23 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_LOCATION_V1_LOCATION_V1_SERVICE_PB_H_INCLUDED
+#define PB_LOCATION_V1_LOCATION_V1_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "location/v1/create.pb.h"
+#include "location/v1/delete.pb.h"
+#include "location/v1/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/read/v1/get.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "read/v1/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(read_v1_GetReadsRequest, read_v1_GetReadsRequest, AUTO)
+
+
+PB_BIND(read_v1_GetReadsResponse, read_v1_GetReadsResponse, AUTO)
+
+
+

vendor/protobuf/read/v1/get.pb.h

@@ -0,0 +1,80 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READ_V1_READ_V1_GET_PB_H_INCLUDED
+#define PB_READ_V1_READ_V1_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "read/v1/read.pb.h"
+#include "util/between.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _read_v1_GetReadsRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+    pb_callback_t epc;
+    bool has_antenna;
+    uint32_t antenna;
+    bool has_timestamp;
+    util_TimestampBetween timestamp;
+} read_v1_GetReadsRequest;
+
+typedef struct _read_v1_GetReadsResponse {
+    pb_callback_t reads;
+} read_v1_GetReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define read_v1_GetReadsRequest_init_default     {false, util_UUID_init_default, {{NULL}, NULL}, false, 0, false, util_TimestampBetween_init_default}
+#define read_v1_GetReadsResponse_init_default    {{{NULL}, NULL}}
+#define read_v1_GetReadsRequest_init_zero        {false, util_UUID_init_zero, {{NULL}, NULL}, false, 0, false, util_TimestampBetween_init_zero}
+#define read_v1_GetReadsResponse_init_zero       {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define read_v1_GetReadsRequest_reader_id_tag    1
+#define read_v1_GetReadsRequest_epc_tag          2
+#define read_v1_GetReadsRequest_antenna_tag      3
+#define read_v1_GetReadsRequest_timestamp_tag    4
+#define read_v1_GetReadsResponse_reads_tag       1
+
+/* Struct field encoding specification for nanopb */
+#define read_v1_GetReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, CALLBACK, OPTIONAL, STRING,   epc,               2) \
+X(a, STATIC,   OPTIONAL, UINT32,   antenna,           3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  timestamp,         4)
+#define read_v1_GetReadsRequest_CALLBACK pb_default_field_callback
+#define read_v1_GetReadsRequest_DEFAULT NULL
+#define read_v1_GetReadsRequest_reader_id_MSGTYPE util_UUID
+#define read_v1_GetReadsRequest_timestamp_MSGTYPE util_TimestampBetween
+
+#define read_v1_GetReadsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  reads,             1)
+#define read_v1_GetReadsResponse_CALLBACK pb_default_field_callback
+#define read_v1_GetReadsResponse_DEFAULT NULL
+#define read_v1_GetReadsResponse_reads_MSGTYPE read_v1_Read
+
+extern const pb_msgdesc_t read_v1_GetReadsRequest_msg;
+extern const pb_msgdesc_t read_v1_GetReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define read_v1_GetReadsRequest_fields &read_v1_GetReadsRequest_msg
+#define read_v1_GetReadsResponse_fields &read_v1_GetReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* read_v1_GetReadsRequest_size depends on runtime parameters */
+/* read_v1_GetReadsResponse_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/read/v1/read.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "read/v1/read.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(read_v1_Read, read_v1_Read, AUTO)
+
+
+

vendor/protobuf/read/v1/read.pb.h

@@ -0,0 +1,65 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READ_V1_READ_V1_READ_PB_H_INCLUDED
+#define PB_READ_V1_READ_V1_READ_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _read_v1_Read {
+    bool has_reader_id;
+    util_UUID reader_id;
+    pb_callback_t epc;
+    uint32_t antenna;
+    int32_t rssi;
+    bool has_timestamp;
+    google_protobuf_Timestamp timestamp;
+} read_v1_Read;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define read_v1_Read_init_default                {false, util_UUID_init_default, {{NULL}, NULL}, 0, 0, false, google_protobuf_Timestamp_init_default}
+#define read_v1_Read_init_zero                   {false, util_UUID_init_zero, {{NULL}, NULL}, 0, 0, false, google_protobuf_Timestamp_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define read_v1_Read_reader_id_tag               1
+#define read_v1_Read_epc_tag                     2
+#define read_v1_Read_antenna_tag                 3
+#define read_v1_Read_rssi_tag                    4
+#define read_v1_Read_timestamp_tag               5
+
+/* Struct field encoding specification for nanopb */
+#define read_v1_Read_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, CALLBACK, SINGULAR, STRING,   epc,               2) \
+X(a, STATIC,   SINGULAR, UINT32,   antenna,           3) \
+X(a, STATIC,   SINGULAR, SINT32,   rssi,              4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  timestamp,         5)
+#define read_v1_Read_CALLBACK pb_default_field_callback
+#define read_v1_Read_DEFAULT NULL
+#define read_v1_Read_reader_id_MSGTYPE util_UUID
+#define read_v1_Read_timestamp_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t read_v1_Read_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define read_v1_Read_fields &read_v1_Read_msg
+
+/* Maximum encoded size of messages (where known) */
+/* read_v1_Read_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/read/v1/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "read/v1/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/read/v1/service.pb.h

@@ -0,0 +1,23 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READ_V1_READ_V1_SERVICE_PB_H_INCLUDED
+#define PB_READ_V1_READ_V1_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "read/v1/get.pb.h"
+#include "read/v1/stream.pb.h"
+#include "read/v1/subscribe.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/read/v1/stream.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "read/v1/stream.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(read_v1_StreamReadsRequest, read_v1_StreamReadsRequest, AUTO)
+
+
+PB_BIND(read_v1_StreamReadsResponse, read_v1_StreamReadsResponse, AUTO)
+
+
+

vendor/protobuf/read/v1/stream.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READ_V1_READ_V1_STREAM_PB_H_INCLUDED
+#define PB_READ_V1_READ_V1_STREAM_PB_H_INCLUDED
+#include <pb.h>
+#include "read/v1/read.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _read_v1_StreamReadsRequest {
+    bool has_read;
+    read_v1_Read read;
+} read_v1_StreamReadsRequest;
+
+typedef struct _read_v1_StreamReadsResponse {
+    char dummy_field;
+} read_v1_StreamReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define read_v1_StreamReadsRequest_init_default  {false, read_v1_Read_init_default}
+#define read_v1_StreamReadsResponse_init_default {0}
+#define read_v1_StreamReadsRequest_init_zero     {false, read_v1_Read_init_zero}
+#define read_v1_StreamReadsResponse_init_zero    {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define read_v1_StreamReadsRequest_read_tag      1
+
+/* Struct field encoding specification for nanopb */
+#define read_v1_StreamReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  read,              1)
+#define read_v1_StreamReadsRequest_CALLBACK NULL
+#define read_v1_StreamReadsRequest_DEFAULT NULL
+#define read_v1_StreamReadsRequest_read_MSGTYPE read_v1_Read
+
+#define read_v1_StreamReadsResponse_FIELDLIST(X, a) \
+
+#define read_v1_StreamReadsResponse_CALLBACK NULL
+#define read_v1_StreamReadsResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t read_v1_StreamReadsRequest_msg;
+extern const pb_msgdesc_t read_v1_StreamReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define read_v1_StreamReadsRequest_fields &read_v1_StreamReadsRequest_msg
+#define read_v1_StreamReadsResponse_fields &read_v1_StreamReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(read_v1_Read_size)
+#define READ_V1_READ_V1_STREAM_PB_H_MAX_SIZE     read_v1_StreamReadsRequest_size
+#define read_v1_StreamReadsRequest_size          (6 + read_v1_Read_size)
+#endif
+#define read_v1_StreamReadsResponse_size         0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/read/v1/subscribe.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "read/v1/subscribe.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(read_v1_SubscribeReadsRequest, read_v1_SubscribeReadsRequest, AUTO)
+
+
+PB_BIND(read_v1_SubscribeReadsResponse, read_v1_SubscribeReadsResponse, AUTO)
+
+
+

vendor/protobuf/read/v1/subscribe.pb.h

@@ -0,0 +1,78 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READ_V1_READ_V1_SUBSCRIBE_PB_H_INCLUDED
+#define PB_READ_V1_READ_V1_SUBSCRIBE_PB_H_INCLUDED
+#include <pb.h>
+#include "read/v1/read.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _read_v1_SubscribeReadsRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+    pb_callback_t epc;
+    bool has_antenna;
+    uint32_t antenna;
+} read_v1_SubscribeReadsRequest;
+
+typedef struct _read_v1_SubscribeReadsResponse {
+    bool has_read;
+    read_v1_Read read;
+} read_v1_SubscribeReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define read_v1_SubscribeReadsRequest_init_default {false, util_UUID_init_default, {{NULL}, NULL}, false, 0}
+#define read_v1_SubscribeReadsResponse_init_default {false, read_v1_Read_init_default}
+#define read_v1_SubscribeReadsRequest_init_zero  {false, util_UUID_init_zero, {{NULL}, NULL}, false, 0}
+#define read_v1_SubscribeReadsResponse_init_zero {false, read_v1_Read_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define read_v1_SubscribeReadsRequest_reader_id_tag 1
+#define read_v1_SubscribeReadsRequest_epc_tag    2
+#define read_v1_SubscribeReadsRequest_antenna_tag 3
+#define read_v1_SubscribeReadsResponse_read_tag  1
+
+/* Struct field encoding specification for nanopb */
+#define read_v1_SubscribeReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, CALLBACK, OPTIONAL, STRING,   epc,               2) \
+X(a, STATIC,   OPTIONAL, UINT32,   antenna,           3)
+#define read_v1_SubscribeReadsRequest_CALLBACK pb_default_field_callback
+#define read_v1_SubscribeReadsRequest_DEFAULT NULL
+#define read_v1_SubscribeReadsRequest_reader_id_MSGTYPE util_UUID
+
+#define read_v1_SubscribeReadsResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  read,              1)
+#define read_v1_SubscribeReadsResponse_CALLBACK NULL
+#define read_v1_SubscribeReadsResponse_DEFAULT NULL
+#define read_v1_SubscribeReadsResponse_read_MSGTYPE read_v1_Read
+
+extern const pb_msgdesc_t read_v1_SubscribeReadsRequest_msg;
+extern const pb_msgdesc_t read_v1_SubscribeReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define read_v1_SubscribeReadsRequest_fields &read_v1_SubscribeReadsRequest_msg
+#define read_v1_SubscribeReadsResponse_fields &read_v1_SubscribeReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* read_v1_SubscribeReadsRequest_size depends on runtime parameters */
+#if defined(read_v1_Read_size)
+#define READ_V1_READ_V1_SUBSCRIBE_PB_H_MAX_SIZE  read_v1_SubscribeReadsResponse_size
+#define read_v1_SubscribeReadsResponse_size      (6 + read_v1_Read_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/restart/v1/restart.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/restart/v1/restart.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_restart_v1_RestartRequest, reader_restart_v1_RestartRequest, AUTO)
+
+
+PB_BIND(reader_restart_v1_RestartResponse, reader_restart_v1_RestartResponse, AUTO)
+
+
+

vendor/protobuf/reader/restart/v1/restart.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_RESTART_V1_READER_RESTART_V1_RESTART_PB_H_INCLUDED
+#define PB_READER_RESTART_V1_READER_RESTART_V1_RESTART_PB_H_INCLUDED
+#include <pb.h>
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_restart_v1_RestartRequest {
+    bool has_id;
+    util_UUID id;
+} reader_restart_v1_RestartRequest;
+
+typedef struct _reader_restart_v1_RestartResponse {
+    char dummy_field;
+} reader_restart_v1_RestartResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_restart_v1_RestartRequest_init_default {false, util_UUID_init_default}
+#define reader_restart_v1_RestartResponse_init_default {0}
+#define reader_restart_v1_RestartRequest_init_zero {false, util_UUID_init_zero}
+#define reader_restart_v1_RestartResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_restart_v1_RestartRequest_id_tag  1
+
+/* Struct field encoding specification for nanopb */
+#define reader_restart_v1_RestartRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1)
+#define reader_restart_v1_RestartRequest_CALLBACK NULL
+#define reader_restart_v1_RestartRequest_DEFAULT NULL
+#define reader_restart_v1_RestartRequest_id_MSGTYPE util_UUID
+
+#define reader_restart_v1_RestartResponse_FIELDLIST(X, a) \
+
+#define reader_restart_v1_RestartResponse_CALLBACK NULL
+#define reader_restart_v1_RestartResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_restart_v1_RestartRequest_msg;
+extern const pb_msgdesc_t reader_restart_v1_RestartResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_restart_v1_RestartRequest_fields &reader_restart_v1_RestartRequest_msg
+#define reader_restart_v1_RestartResponse_fields &reader_restart_v1_RestartResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define READER_RESTART_V1_READER_RESTART_V1_RESTART_PB_H_MAX_SIZE reader_restart_v1_RestartRequest_size
+#define reader_restart_v1_RestartRequest_size    (6 + util_UUID_size)
+#endif
+#define reader_restart_v1_RestartResponse_size   0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/restart/v1/subscribe.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/restart/v1/subscribe.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_restart_v1_SubscribeRestartRequest, reader_restart_v1_SubscribeRestartRequest, AUTO)
+
+
+PB_BIND(reader_restart_v1_SubscribeRestartResponse, reader_restart_v1_SubscribeRestartResponse, AUTO)
+
+
+

vendor/protobuf/reader/restart/v1/subscribe.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_RESTART_V1_READER_RESTART_V1_SUBSCRIBE_PB_H_INCLUDED
+#define PB_READER_RESTART_V1_READER_RESTART_V1_SUBSCRIBE_PB_H_INCLUDED
+#include <pb.h>
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_restart_v1_SubscribeRestartRequest {
+    bool has_id;
+    util_UUID id;
+} reader_restart_v1_SubscribeRestartRequest;
+
+typedef struct _reader_restart_v1_SubscribeRestartResponse {
+    char dummy_field;
+} reader_restart_v1_SubscribeRestartResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_restart_v1_SubscribeRestartRequest_init_default {false, util_UUID_init_default}
+#define reader_restart_v1_SubscribeRestartResponse_init_default {0}
+#define reader_restart_v1_SubscribeRestartRequest_init_zero {false, util_UUID_init_zero}
+#define reader_restart_v1_SubscribeRestartResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_restart_v1_SubscribeRestartRequest_id_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define reader_restart_v1_SubscribeRestartRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1)
+#define reader_restart_v1_SubscribeRestartRequest_CALLBACK NULL
+#define reader_restart_v1_SubscribeRestartRequest_DEFAULT NULL
+#define reader_restart_v1_SubscribeRestartRequest_id_MSGTYPE util_UUID
+
+#define reader_restart_v1_SubscribeRestartResponse_FIELDLIST(X, a) \
+
+#define reader_restart_v1_SubscribeRestartResponse_CALLBACK NULL
+#define reader_restart_v1_SubscribeRestartResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_restart_v1_SubscribeRestartRequest_msg;
+extern const pb_msgdesc_t reader_restart_v1_SubscribeRestartResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_restart_v1_SubscribeRestartRequest_fields &reader_restart_v1_SubscribeRestartRequest_msg
+#define reader_restart_v1_SubscribeRestartResponse_fields &reader_restart_v1_SubscribeRestartResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define READER_RESTART_V1_READER_RESTART_V1_SUBSCRIBE_PB_H_MAX_SIZE reader_restart_v1_SubscribeRestartRequest_size
+#define reader_restart_v1_SubscribeRestartRequest_size (6 + util_UUID_size)
+#endif
+#define reader_restart_v1_SubscribeRestartResponse_size 0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/claim.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/claim.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_ClaimReaderRequest, reader_v1_ClaimReaderRequest, AUTO)
+
+
+PB_BIND(reader_v1_ClaimReaderResponse, reader_v1_ClaimReaderResponse, AUTO)
+
+
+

vendor/protobuf/reader/v1/claim.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_CLAIM_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_CLAIM_PB_H_INCLUDED
+#include <pb.h>
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_ClaimReaderRequest {
+    bool has_id;
+    util_UUID id;
+} reader_v1_ClaimReaderRequest;
+
+typedef struct _reader_v1_ClaimReaderResponse {
+    char dummy_field;
+} reader_v1_ClaimReaderResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_ClaimReaderRequest_init_default {false, util_UUID_init_default}
+#define reader_v1_ClaimReaderResponse_init_default {0}
+#define reader_v1_ClaimReaderRequest_init_zero   {false, util_UUID_init_zero}
+#define reader_v1_ClaimReaderResponse_init_zero  {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_ClaimReaderRequest_id_tag      1
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_ClaimReaderRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1)
+#define reader_v1_ClaimReaderRequest_CALLBACK NULL
+#define reader_v1_ClaimReaderRequest_DEFAULT NULL
+#define reader_v1_ClaimReaderRequest_id_MSGTYPE util_UUID
+
+#define reader_v1_ClaimReaderResponse_FIELDLIST(X, a) \
+
+#define reader_v1_ClaimReaderResponse_CALLBACK NULL
+#define reader_v1_ClaimReaderResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_v1_ClaimReaderRequest_msg;
+extern const pb_msgdesc_t reader_v1_ClaimReaderResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_ClaimReaderRequest_fields &reader_v1_ClaimReaderRequest_msg
+#define reader_v1_ClaimReaderResponse_fields &reader_v1_ClaimReaderResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define READER_V1_READER_V1_CLAIM_PB_H_MAX_SIZE  reader_v1_ClaimReaderRequest_size
+#define reader_v1_ClaimReaderRequest_size        (6 + util_UUID_size)
+#endif
+#define reader_v1_ClaimReaderResponse_size       0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/create.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/create.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_CreateReaderRequest, reader_v1_CreateReaderRequest, AUTO)
+
+
+PB_BIND(reader_v1_CreateReaderResponse, reader_v1_CreateReaderResponse, 2)
+
+
+

vendor/protobuf/reader/v1/create.pb.h

@@ -0,0 +1,90 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_CREATE_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_CREATE_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "reader/v1/reader.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_CreateReaderRequest {
+    bool has_id;
+    util_UUID id;
+    uint32_t manufacturer;
+    uint32_t model;
+    pb_callback_t firmware;
+    uint32_t gpis; /* max uint8 */
+    uint32_t gpos; /* max uint8 */
+    pb_callback_t ip;
+} reader_v1_CreateReaderRequest;
+
+typedef struct _reader_v1_CreateReaderResponse {
+    bool has_reader;
+    reader_v1_Reader reader;
+} reader_v1_CreateReaderResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_CreateReaderRequest_init_default {false, util_UUID_init_default, 0, 0, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}}
+#define reader_v1_CreateReaderResponse_init_default {false, reader_v1_Reader_init_default}
+#define reader_v1_CreateReaderRequest_init_zero  {false, util_UUID_init_zero, 0, 0, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}}
+#define reader_v1_CreateReaderResponse_init_zero {false, reader_v1_Reader_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_CreateReaderRequest_id_tag     1
+#define reader_v1_CreateReaderRequest_manufacturer_tag 2
+#define reader_v1_CreateReaderRequest_model_tag  3
+#define reader_v1_CreateReaderRequest_firmware_tag 4
+#define reader_v1_CreateReaderRequest_gpis_tag   6
+#define reader_v1_CreateReaderRequest_gpos_tag   7
+#define reader_v1_CreateReaderRequest_ip_tag     8
+#define reader_v1_CreateReaderResponse_reader_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_CreateReaderRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1) \
+X(a, STATIC,   SINGULAR, UINT32,   manufacturer,      2) \
+X(a, STATIC,   SINGULAR, UINT32,   model,             3) \
+X(a, CALLBACK, SINGULAR, STRING,   firmware,          4) \
+X(a, STATIC,   SINGULAR, UINT32,   gpis,              6) \
+X(a, STATIC,   SINGULAR, UINT32,   gpos,              7) \
+X(a, CALLBACK, SINGULAR, STRING,   ip,                8)
+#define reader_v1_CreateReaderRequest_CALLBACK pb_default_field_callback
+#define reader_v1_CreateReaderRequest_DEFAULT NULL
+#define reader_v1_CreateReaderRequest_id_MSGTYPE util_UUID
+
+#define reader_v1_CreateReaderResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader,            1)
+#define reader_v1_CreateReaderResponse_CALLBACK NULL
+#define reader_v1_CreateReaderResponse_DEFAULT NULL
+#define reader_v1_CreateReaderResponse_reader_MSGTYPE reader_v1_Reader
+
+extern const pb_msgdesc_t reader_v1_CreateReaderRequest_msg;
+extern const pb_msgdesc_t reader_v1_CreateReaderResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_CreateReaderRequest_fields &reader_v1_CreateReaderRequest_msg
+#define reader_v1_CreateReaderResponse_fields &reader_v1_CreateReaderResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* reader_v1_CreateReaderRequest_size depends on runtime parameters */
+#if defined(reader_v1_Reader_size)
+#define READER_V1_READER_V1_CREATE_PB_H_MAX_SIZE reader_v1_CreateReaderResponse_size
+#define reader_v1_CreateReaderResponse_size      (6 + reader_v1_Reader_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/delete.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/delete.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_DeleteReaderRequest, reader_v1_DeleteReaderRequest, AUTO)
+
+
+PB_BIND(reader_v1_DeleteReaderResponse, reader_v1_DeleteReaderResponse, AUTO)
+
+
+

vendor/protobuf/reader/v1/delete.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_DELETE_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_DELETE_PB_H_INCLUDED
+#include <pb.h>
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_DeleteReaderRequest {
+    bool has_id;
+    util_UUID id;
+} reader_v1_DeleteReaderRequest;
+
+typedef struct _reader_v1_DeleteReaderResponse {
+    char dummy_field;
+} reader_v1_DeleteReaderResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_DeleteReaderRequest_init_default {false, util_UUID_init_default}
+#define reader_v1_DeleteReaderResponse_init_default {0}
+#define reader_v1_DeleteReaderRequest_init_zero  {false, util_UUID_init_zero}
+#define reader_v1_DeleteReaderResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_DeleteReaderRequest_id_tag     1
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_DeleteReaderRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1)
+#define reader_v1_DeleteReaderRequest_CALLBACK NULL
+#define reader_v1_DeleteReaderRequest_DEFAULT NULL
+#define reader_v1_DeleteReaderRequest_id_MSGTYPE util_UUID
+
+#define reader_v1_DeleteReaderResponse_FIELDLIST(X, a) \
+
+#define reader_v1_DeleteReaderResponse_CALLBACK NULL
+#define reader_v1_DeleteReaderResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_v1_DeleteReaderRequest_msg;
+extern const pb_msgdesc_t reader_v1_DeleteReaderResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_DeleteReaderRequest_fields &reader_v1_DeleteReaderRequest_msg
+#define reader_v1_DeleteReaderResponse_fields &reader_v1_DeleteReaderResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define READER_V1_READER_V1_DELETE_PB_H_MAX_SIZE reader_v1_DeleteReaderRequest_size
+#define reader_v1_DeleteReaderRequest_size       (6 + util_UUID_size)
+#endif
+#define reader_v1_DeleteReaderResponse_size      0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/export.pb.c

@@ -0,0 +1,17 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/export.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_ExportReadersRequest, reader_v1_ExportReadersRequest, AUTO)
+
+
+PB_BIND(reader_v1_ExportReadersResponse, reader_v1_ExportReadersResponse, AUTO)
+
+
+
+
+

vendor/protobuf/reader/v1/export.pb.h

@@ -0,0 +1,88 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_EXPORT_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_EXPORT_PB_H_INCLUDED
+#include <pb.h>
+#include "reader/v1/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _reader_v1_ReportType {
+    reader_v1_ReportType_REPORT_TYPE_UNSPECIFIED = 0,
+    reader_v1_ReportType_REPORT_TYPE_CSV = 1,
+    reader_v1_ReportType_REPORT_TYPE_XML = 2,
+    reader_v1_ReportType_REPORT_TYPE_JSON = 3
+} reader_v1_ReportType;
+
+/* Struct definitions */
+typedef struct _reader_v1_ExportReadersRequest {
+    reader_v1_ReportType type;
+    bool has_request;
+    reader_v1_GetReadersRequest request;
+} reader_v1_ExportReadersRequest;
+
+typedef struct _reader_v1_ExportReadersResponse {
+    pb_callback_t file;
+} reader_v1_ExportReadersResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _reader_v1_ReportType_MIN reader_v1_ReportType_REPORT_TYPE_UNSPECIFIED
+#define _reader_v1_ReportType_MAX reader_v1_ReportType_REPORT_TYPE_JSON
+#define _reader_v1_ReportType_ARRAYSIZE ((reader_v1_ReportType)(reader_v1_ReportType_REPORT_TYPE_JSON+1))
+
+#define reader_v1_ExportReadersRequest_type_ENUMTYPE reader_v1_ReportType
+
+
+
+/* Initializer values for message structs */
+#define reader_v1_ExportReadersRequest_init_default {_reader_v1_ReportType_MIN, false, reader_v1_GetReadersRequest_init_default}
+#define reader_v1_ExportReadersResponse_init_default {{{NULL}, NULL}}
+#define reader_v1_ExportReadersRequest_init_zero {_reader_v1_ReportType_MIN, false, reader_v1_GetReadersRequest_init_zero}
+#define reader_v1_ExportReadersResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_ExportReadersRequest_type_tag  1
+#define reader_v1_ExportReadersRequest_request_tag 2
+#define reader_v1_ExportReadersResponse_file_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_ExportReadersRequest_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  request,           2)
+#define reader_v1_ExportReadersRequest_CALLBACK NULL
+#define reader_v1_ExportReadersRequest_DEFAULT NULL
+#define reader_v1_ExportReadersRequest_request_MSGTYPE reader_v1_GetReadersRequest
+
+#define reader_v1_ExportReadersResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   file,              1)
+#define reader_v1_ExportReadersResponse_CALLBACK pb_default_field_callback
+#define reader_v1_ExportReadersResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_v1_ExportReadersRequest_msg;
+extern const pb_msgdesc_t reader_v1_ExportReadersResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_ExportReadersRequest_fields &reader_v1_ExportReadersRequest_msg
+#define reader_v1_ExportReadersResponse_fields &reader_v1_ExportReadersResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* reader_v1_ExportReadersResponse_size depends on runtime parameters */
+#if defined(reader_v1_GetReadersRequest_size)
+#define READER_V1_READER_V1_EXPORT_PB_H_MAX_SIZE reader_v1_ExportReadersRequest_size
+#define reader_v1_ExportReadersRequest_size      (8 + reader_v1_GetReadersRequest_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/get.pb.c

@@ -0,0 +1,21 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_GetReaderRequest, reader_v1_GetReaderRequest, AUTO)
+
+
+PB_BIND(reader_v1_GetReaderResponse, reader_v1_GetReaderResponse, 2)
+
+
+PB_BIND(reader_v1_GetReadersRequest, reader_v1_GetReadersRequest, AUTO)
+
+
+PB_BIND(reader_v1_GetReadersResponse, reader_v1_GetReadersResponse, AUTO)
+
+
+

vendor/protobuf/reader/v1/get.pb.h

@@ -0,0 +1,108 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_GET_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "reader/v1/reader.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_GetReaderRequest {
+    bool has_id;
+    util_UUID id;
+} reader_v1_GetReaderRequest;
+
+typedef struct _reader_v1_GetReaderResponse {
+    bool has_reader;
+    reader_v1_Reader reader;
+} reader_v1_GetReaderResponse;
+
+typedef struct _reader_v1_GetReadersRequest {
+    pb_callback_t filter;
+    bool has_unclaimed;
+    bool unclaimed;
+} reader_v1_GetReadersRequest;
+
+typedef struct _reader_v1_GetReadersResponse {
+    pb_callback_t readers;
+} reader_v1_GetReadersResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_GetReaderRequest_init_default  {false, util_UUID_init_default}
+#define reader_v1_GetReaderResponse_init_default {false, reader_v1_Reader_init_default}
+#define reader_v1_GetReadersRequest_init_default {{{NULL}, NULL}, false, 0}
+#define reader_v1_GetReadersResponse_init_default {{{NULL}, NULL}}
+#define reader_v1_GetReaderRequest_init_zero     {false, util_UUID_init_zero}
+#define reader_v1_GetReaderResponse_init_zero    {false, reader_v1_Reader_init_zero}
+#define reader_v1_GetReadersRequest_init_zero    {{{NULL}, NULL}, false, 0}
+#define reader_v1_GetReadersResponse_init_zero   {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_GetReaderRequest_id_tag        1
+#define reader_v1_GetReaderResponse_reader_tag   1
+#define reader_v1_GetReadersRequest_filter_tag   1
+#define reader_v1_GetReadersRequest_unclaimed_tag 2
+#define reader_v1_GetReadersResponse_readers_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_GetReaderRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1)
+#define reader_v1_GetReaderRequest_CALLBACK NULL
+#define reader_v1_GetReaderRequest_DEFAULT NULL
+#define reader_v1_GetReaderRequest_id_MSGTYPE util_UUID
+
+#define reader_v1_GetReaderResponse_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader,            1)
+#define reader_v1_GetReaderResponse_CALLBACK NULL
+#define reader_v1_GetReaderResponse_DEFAULT NULL
+#define reader_v1_GetReaderResponse_reader_MSGTYPE reader_v1_Reader
+
+#define reader_v1_GetReadersRequest_FIELDLIST(X, a) \
+X(a, CALLBACK, OPTIONAL, STRING,   filter,            1) \
+X(a, STATIC,   OPTIONAL, BOOL,     unclaimed,         2)
+#define reader_v1_GetReadersRequest_CALLBACK pb_default_field_callback
+#define reader_v1_GetReadersRequest_DEFAULT NULL
+
+#define reader_v1_GetReadersResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  readers,           1)
+#define reader_v1_GetReadersResponse_CALLBACK pb_default_field_callback
+#define reader_v1_GetReadersResponse_DEFAULT NULL
+#define reader_v1_GetReadersResponse_readers_MSGTYPE reader_v1_Reader
+
+extern const pb_msgdesc_t reader_v1_GetReaderRequest_msg;
+extern const pb_msgdesc_t reader_v1_GetReaderResponse_msg;
+extern const pb_msgdesc_t reader_v1_GetReadersRequest_msg;
+extern const pb_msgdesc_t reader_v1_GetReadersResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_GetReaderRequest_fields &reader_v1_GetReaderRequest_msg
+#define reader_v1_GetReaderResponse_fields &reader_v1_GetReaderResponse_msg
+#define reader_v1_GetReadersRequest_fields &reader_v1_GetReadersRequest_msg
+#define reader_v1_GetReadersResponse_fields &reader_v1_GetReadersResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* reader_v1_GetReadersRequest_size depends on runtime parameters */
+/* reader_v1_GetReadersResponse_size depends on runtime parameters */
+#if defined(util_UUID_size)
+#define READER_V1_READER_V1_GET_PB_H_MAX_SIZE    reader_v1_GetReaderRequest_size
+#define reader_v1_GetReaderRequest_size          (6 + util_UUID_size)
+#endif
+#if defined(reader_v1_Reader_size)
+#define reader_v1_GetReaderResponse_size         (6 + reader_v1_Reader_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/heartbeat.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/heartbeat.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_HeartbeatRequest, reader_v1_HeartbeatRequest, AUTO)
+
+
+PB_BIND(reader_v1_HeartbeatResponse, reader_v1_HeartbeatResponse, AUTO)
+
+
+

vendor/protobuf/reader/v1/heartbeat.pb.h

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_HEARTBEAT_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_HEARTBEAT_PB_H_INCLUDED
+#include <pb.h>
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_HeartbeatRequest {
+    bool has_id;
+    util_UUID id;
+} reader_v1_HeartbeatRequest;
+
+typedef struct _reader_v1_HeartbeatResponse {
+    char dummy_field;
+} reader_v1_HeartbeatResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_HeartbeatRequest_init_default  {false, util_UUID_init_default}
+#define reader_v1_HeartbeatResponse_init_default {0}
+#define reader_v1_HeartbeatRequest_init_zero     {false, util_UUID_init_zero}
+#define reader_v1_HeartbeatResponse_init_zero    {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_HeartbeatRequest_id_tag        1
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_HeartbeatRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1)
+#define reader_v1_HeartbeatRequest_CALLBACK NULL
+#define reader_v1_HeartbeatRequest_DEFAULT NULL
+#define reader_v1_HeartbeatRequest_id_MSGTYPE util_UUID
+
+#define reader_v1_HeartbeatResponse_FIELDLIST(X, a) \
+
+#define reader_v1_HeartbeatResponse_CALLBACK NULL
+#define reader_v1_HeartbeatResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_v1_HeartbeatRequest_msg;
+extern const pb_msgdesc_t reader_v1_HeartbeatResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_HeartbeatRequest_fields &reader_v1_HeartbeatRequest_msg
+#define reader_v1_HeartbeatResponse_fields &reader_v1_HeartbeatResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+#if defined(util_UUID_size)
+#define READER_V1_READER_V1_HEARTBEAT_PB_H_MAX_SIZE reader_v1_HeartbeatRequest_size
+#define reader_v1_HeartbeatRequest_size          (6 + util_UUID_size)
+#endif
+#define reader_v1_HeartbeatResponse_size         0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/reader.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/reader.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_Reader, reader_v1_Reader, 2)
+
+
+

vendor/protobuf/reader/v1/reader.pb.h

@@ -0,0 +1,119 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_READER_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_READER_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "reader/v1/settings.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_Reader {
+    bool has_id;
+    util_UUID id;
+    /* foreign keys */
+    bool has_account_id;
+    util_UUID account_id;
+    bool has_location_id;
+    util_UUID location_id;
+    /* metadata */
+    pb_callback_t name;
+    uint32_t manufacturer;
+    uint32_t model;
+    pb_callback_t firmware;
+    uint32_t gpis;
+    uint32_t gpos;
+    pb_callback_t ip;
+    bool has_heartbeat;
+    google_protobuf_Timestamp heartbeat;
+    bool has_last_updated;
+    google_protobuf_Timestamp last_updated;
+    /* aggregates */
+    bool has_read_count;
+    uint64_t read_count;
+    bool has_last_read_timestamp;
+    google_protobuf_Timestamp last_read_timestamp;
+    bool has_last_read_latitude;
+    float last_read_latitude;
+    bool has_last_read_longitude;
+    float last_read_longitude;
+    /* settings */
+    bool has_settings;
+    reader_v1_Settings settings;
+} reader_v1_Reader;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_Reader_init_default            {false, util_UUID_init_default, false, util_UUID_init_default, false, util_UUID_init_default, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default, false, google_protobuf_Timestamp_init_default, false, 0, false, google_protobuf_Timestamp_init_default, false, 0, false, 0, false, reader_v1_Settings_init_default}
+#define reader_v1_Reader_init_zero               {false, util_UUID_init_zero, false, util_UUID_init_zero, false, util_UUID_init_zero, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero, false, google_protobuf_Timestamp_init_zero, false, 0, false, google_protobuf_Timestamp_init_zero, false, 0, false, 0, false, reader_v1_Settings_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_Reader_id_tag                  1
+#define reader_v1_Reader_account_id_tag          2
+#define reader_v1_Reader_location_id_tag         3
+#define reader_v1_Reader_name_tag                4
+#define reader_v1_Reader_manufacturer_tag        5
+#define reader_v1_Reader_model_tag               6
+#define reader_v1_Reader_firmware_tag            7
+#define reader_v1_Reader_gpis_tag                8
+#define reader_v1_Reader_gpos_tag                9
+#define reader_v1_Reader_ip_tag                  10
+#define reader_v1_Reader_heartbeat_tag           11
+#define reader_v1_Reader_last_updated_tag        12
+#define reader_v1_Reader_read_count_tag          13
+#define reader_v1_Reader_last_read_timestamp_tag 14
+#define reader_v1_Reader_last_read_latitude_tag  15
+#define reader_v1_Reader_last_read_longitude_tag 16
+#define reader_v1_Reader_settings_tag            17
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_Reader_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  id,                1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  account_id,        2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location_id,       3) \
+X(a, CALLBACK, OPTIONAL, STRING,   name,              4) \
+X(a, STATIC,   SINGULAR, UINT32,   manufacturer,      5) \
+X(a, STATIC,   SINGULAR, UINT32,   model,             6) \
+X(a, CALLBACK, SINGULAR, STRING,   firmware,          7) \
+X(a, STATIC,   SINGULAR, UINT32,   gpis,              8) \
+X(a, STATIC,   SINGULAR, UINT32,   gpos,              9) \
+X(a, CALLBACK, SINGULAR, STRING,   ip,               10) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  heartbeat,        11) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_updated,     12) \
+X(a, STATIC,   OPTIONAL, UINT64,   read_count,       13) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_read_timestamp,  14) \
+X(a, STATIC,   OPTIONAL, FLOAT,    last_read_latitude,  15) \
+X(a, STATIC,   OPTIONAL, FLOAT,    last_read_longitude,  16) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,         17)
+#define reader_v1_Reader_CALLBACK pb_default_field_callback
+#define reader_v1_Reader_DEFAULT NULL
+#define reader_v1_Reader_id_MSGTYPE util_UUID
+#define reader_v1_Reader_account_id_MSGTYPE util_UUID
+#define reader_v1_Reader_location_id_MSGTYPE util_UUID
+#define reader_v1_Reader_heartbeat_MSGTYPE google_protobuf_Timestamp
+#define reader_v1_Reader_last_updated_MSGTYPE google_protobuf_Timestamp
+#define reader_v1_Reader_last_read_timestamp_MSGTYPE google_protobuf_Timestamp
+#define reader_v1_Reader_settings_MSGTYPE reader_v1_Settings
+
+extern const pb_msgdesc_t reader_v1_Reader_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_Reader_fields &reader_v1_Reader_msg
+
+/* Maximum encoded size of messages (where known) */
+/* reader_v1_Reader_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/reader/v1/service.pb.h

@@ -0,0 +1,29 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_SERVICE_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "reader/restart/v1/restart.pb.h"
+#include "reader/restart/v1/subscribe.pb.h"
+#include "reader/v1/claim.pb.h"
+#include "reader/v1/create.pb.h"
+#include "reader/v1/delete.pb.h"
+#include "reader/v1/export.pb.h"
+#include "reader/v1/get.pb.h"
+#include "reader/v1/heartbeat.pb.h"
+#include "reader/v1/update.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/settings.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/settings.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_Settings, reader_v1_Settings, AUTO)
+
+
+

vendor/protobuf/reader/v1/settings.pb.h

@@ -0,0 +1,91 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_SETTINGS_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_SETTINGS_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "util/between.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_Settings {
+    pb_callback_t epc_prefix;
+    bool has_total;
+    util_UInt64Between total;
+    bool has_peak_rssi;
+    util_SInt32Between peak_rssi;
+    bool has_skew_rssi;
+    util_DoubleBetween skew_rssi;
+    bool has_variance_rssi;
+    util_DoubleBetween variance_rssi;
+    bool has_entropy_rssi;
+    util_DoubleBetween entropy_rssi;
+    bool has_duration;
+    util_DurationBetween duration;
+    pb_callback_t signals;
+    /* antenna settings */
+    bool has_intersections;
+    util_UInt64Between intersections;
+    pb_callback_t antennas;
+} reader_v1_Settings;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_Settings_init_default          {{{NULL}, NULL}, false, util_UInt64Between_init_default, false, util_SInt32Between_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DurationBetween_init_default, {{NULL}, NULL}, false, util_UInt64Between_init_default, {{NULL}, NULL}}
+#define reader_v1_Settings_init_zero             {{{NULL}, NULL}, false, util_UInt64Between_init_zero, false, util_SInt32Between_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DurationBetween_init_zero, {{NULL}, NULL}, false, util_UInt64Between_init_zero, {{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_Settings_epc_prefix_tag        1
+#define reader_v1_Settings_total_tag             2
+#define reader_v1_Settings_peak_rssi_tag         3
+#define reader_v1_Settings_skew_rssi_tag         4
+#define reader_v1_Settings_variance_rssi_tag     5
+#define reader_v1_Settings_entropy_rssi_tag      6
+#define reader_v1_Settings_duration_tag          7
+#define reader_v1_Settings_signals_tag           8
+#define reader_v1_Settings_intersections_tag     9
+#define reader_v1_Settings_antennas_tag          10
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_Settings_FIELDLIST(X, a) \
+X(a, CALLBACK, OPTIONAL, STRING,   epc_prefix,        1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  total,             2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  peak_rssi,         3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  skew_rssi,         4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  variance_rssi,     5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  entropy_rssi,      6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  duration,          7) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,           8) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  intersections,     9) \
+X(a, CALLBACK, REPEATED, UINT32,   antennas,         10)
+#define reader_v1_Settings_CALLBACK pb_default_field_callback
+#define reader_v1_Settings_DEFAULT NULL
+#define reader_v1_Settings_total_MSGTYPE util_UInt64Between
+#define reader_v1_Settings_peak_rssi_MSGTYPE util_SInt32Between
+#define reader_v1_Settings_skew_rssi_MSGTYPE util_DoubleBetween
+#define reader_v1_Settings_variance_rssi_MSGTYPE util_DoubleBetween
+#define reader_v1_Settings_entropy_rssi_MSGTYPE util_DoubleBetween
+#define reader_v1_Settings_duration_MSGTYPE util_DurationBetween
+#define reader_v1_Settings_intersections_MSGTYPE util_UInt64Between
+
+extern const pb_msgdesc_t reader_v1_Settings_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_Settings_fields &reader_v1_Settings_msg
+
+/* Maximum encoded size of messages (where known) */
+/* reader_v1_Settings_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/reader/v1/update.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "reader/v1/update.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(reader_v1_UpdateReaderRequest, reader_v1_UpdateReaderRequest, 2)
+
+
+PB_BIND(reader_v1_UpdateReaderResponse, reader_v1_UpdateReaderResponse, AUTO)
+
+
+

vendor/protobuf/reader/v1/update.pb.h

@@ -0,0 +1,96 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READER_V1_READER_V1_UPDATE_PB_H_INCLUDED
+#define PB_READER_V1_READER_V1_UPDATE_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "reader/v1/settings.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _reader_v1_UpdateReaderRequest {
+    bool has_reader_id;
+    util_UUID reader_id;
+    /* foreign keys */
+    bool has_location_id;
+    util_UUID location_id;
+    /* metadata */
+    pb_callback_t firmware;
+    bool has_gpis;
+    uint32_t gpis; /* max uint8 */
+    bool has_gpos;
+    uint32_t gpos; /* max uint8 */
+    pb_callback_t ip;
+    pb_callback_t label;
+    /* settings */
+    bool has_settings;
+    reader_v1_Settings settings;
+} reader_v1_UpdateReaderRequest;
+
+typedef struct _reader_v1_UpdateReaderResponse {
+    char dummy_field;
+} reader_v1_UpdateReaderResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define reader_v1_UpdateReaderRequest_init_default {false, util_UUID_init_default, false, util_UUID_init_default, {{NULL}, NULL}, false, 0, false, 0, {{NULL}, NULL}, {{NULL}, NULL}, false, reader_v1_Settings_init_default}
+#define reader_v1_UpdateReaderResponse_init_default {0}
+#define reader_v1_UpdateReaderRequest_init_zero  {false, util_UUID_init_zero, false, util_UUID_init_zero, {{NULL}, NULL}, false, 0, false, 0, {{NULL}, NULL}, {{NULL}, NULL}, false, reader_v1_Settings_init_zero}
+#define reader_v1_UpdateReaderResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define reader_v1_UpdateReaderRequest_reader_id_tag 1
+#define reader_v1_UpdateReaderRequest_location_id_tag 2
+#define reader_v1_UpdateReaderRequest_firmware_tag 3
+#define reader_v1_UpdateReaderRequest_gpis_tag   4
+#define reader_v1_UpdateReaderRequest_gpos_tag   5
+#define reader_v1_UpdateReaderRequest_ip_tag     6
+#define reader_v1_UpdateReaderRequest_label_tag  7
+#define reader_v1_UpdateReaderRequest_settings_tag 8
+
+/* Struct field encoding specification for nanopb */
+#define reader_v1_UpdateReaderRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  location_id,       2) \
+X(a, CALLBACK, OPTIONAL, STRING,   firmware,          3) \
+X(a, STATIC,   OPTIONAL, UINT32,   gpis,              4) \
+X(a, STATIC,   OPTIONAL, UINT32,   gpos,              5) \
+X(a, CALLBACK, OPTIONAL, STRING,   ip,                6) \
+X(a, CALLBACK, OPTIONAL, STRING,   label,             7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,          8)
+#define reader_v1_UpdateReaderRequest_CALLBACK pb_default_field_callback
+#define reader_v1_UpdateReaderRequest_DEFAULT NULL
+#define reader_v1_UpdateReaderRequest_reader_id_MSGTYPE util_UUID
+#define reader_v1_UpdateReaderRequest_location_id_MSGTYPE util_UUID
+#define reader_v1_UpdateReaderRequest_settings_MSGTYPE reader_v1_Settings
+
+#define reader_v1_UpdateReaderResponse_FIELDLIST(X, a) \
+
+#define reader_v1_UpdateReaderResponse_CALLBACK NULL
+#define reader_v1_UpdateReaderResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t reader_v1_UpdateReaderRequest_msg;
+extern const pb_msgdesc_t reader_v1_UpdateReaderResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define reader_v1_UpdateReaderRequest_fields &reader_v1_UpdateReaderRequest_msg
+#define reader_v1_UpdateReaderResponse_fields &reader_v1_UpdateReaderResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* reader_v1_UpdateReaderRequest_size depends on runtime parameters */
+#define reader_v1_UpdateReaderResponse_size      0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/antenna/v2/export.pb.c

@@ -0,0 +1,17 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/antenna/v2/export.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_antenna_v2_ExportReadsRequest, readgroup_antenna_v2_ExportReadsRequest, 2)
+
+
+PB_BIND(readgroup_antenna_v2_ExportReadsResponse, readgroup_antenna_v2_ExportReadsResponse, AUTO)
+
+
+
+
+

vendor/protobuf/readgroup/antenna/v2/export.pb.h

@@ -0,0 +1,88 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_EXPORT_PB_H_INCLUDED
+#define PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_EXPORT_PB_H_INCLUDED
+#include <pb.h>
+#include "readgroup/antenna/v2/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _readgroup_antenna_v2_ReportType {
+    readgroup_antenna_v2_ReportType_REPORT_TYPE_UNSPECIFIED = 0,
+    readgroup_antenna_v2_ReportType_REPORT_TYPE_CSV = 1,
+    readgroup_antenna_v2_ReportType_REPORT_TYPE_XML = 2,
+    readgroup_antenna_v2_ReportType_REPORT_TYPE_JSON = 3
+} readgroup_antenna_v2_ReportType;
+
+/* Struct definitions */
+typedef struct _readgroup_antenna_v2_ExportReadsRequest {
+    readgroup_antenna_v2_ReportType type;
+    bool has_request;
+    readgroup_antenna_v2_GetReadsRequest request;
+} readgroup_antenna_v2_ExportReadsRequest;
+
+typedef struct _readgroup_antenna_v2_ExportReadsResponse {
+    pb_callback_t file;
+} readgroup_antenna_v2_ExportReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _readgroup_antenna_v2_ReportType_MIN readgroup_antenna_v2_ReportType_REPORT_TYPE_UNSPECIFIED
+#define _readgroup_antenna_v2_ReportType_MAX readgroup_antenna_v2_ReportType_REPORT_TYPE_JSON
+#define _readgroup_antenna_v2_ReportType_ARRAYSIZE ((readgroup_antenna_v2_ReportType)(readgroup_antenna_v2_ReportType_REPORT_TYPE_JSON+1))
+
+#define readgroup_antenna_v2_ExportReadsRequest_type_ENUMTYPE readgroup_antenna_v2_ReportType
+
+
+
+/* Initializer values for message structs */
+#define readgroup_antenna_v2_ExportReadsRequest_init_default {_readgroup_antenna_v2_ReportType_MIN, false, readgroup_antenna_v2_GetReadsRequest_init_default}
+#define readgroup_antenna_v2_ExportReadsResponse_init_default {{{NULL}, NULL}}
+#define readgroup_antenna_v2_ExportReadsRequest_init_zero {_readgroup_antenna_v2_ReportType_MIN, false, readgroup_antenna_v2_GetReadsRequest_init_zero}
+#define readgroup_antenna_v2_ExportReadsResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_antenna_v2_ExportReadsRequest_type_tag 1
+#define readgroup_antenna_v2_ExportReadsRequest_request_tag 2
+#define readgroup_antenna_v2_ExportReadsResponse_file_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_antenna_v2_ExportReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  request,           2)
+#define readgroup_antenna_v2_ExportReadsRequest_CALLBACK NULL
+#define readgroup_antenna_v2_ExportReadsRequest_DEFAULT NULL
+#define readgroup_antenna_v2_ExportReadsRequest_request_MSGTYPE readgroup_antenna_v2_GetReadsRequest
+
+#define readgroup_antenna_v2_ExportReadsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   file,              1)
+#define readgroup_antenna_v2_ExportReadsResponse_CALLBACK pb_default_field_callback
+#define readgroup_antenna_v2_ExportReadsResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t readgroup_antenna_v2_ExportReadsRequest_msg;
+extern const pb_msgdesc_t readgroup_antenna_v2_ExportReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_antenna_v2_ExportReadsRequest_fields &readgroup_antenna_v2_ExportReadsRequest_msg
+#define readgroup_antenna_v2_ExportReadsResponse_fields &readgroup_antenna_v2_ExportReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_antenna_v2_ExportReadsResponse_size depends on runtime parameters */
+#if defined(readgroup_antenna_v2_GetReadsRequest_size)
+#define READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_EXPORT_PB_H_MAX_SIZE readgroup_antenna_v2_ExportReadsRequest_size
+#define readgroup_antenna_v2_ExportReadsRequest_size (8 + readgroup_antenna_v2_GetReadsRequest_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/antenna/v2/get.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/antenna/v2/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_antenna_v2_GetReadsRequest, readgroup_antenna_v2_GetReadsRequest, 2)
+
+
+PB_BIND(readgroup_antenna_v2_GetReadsResponse, readgroup_antenna_v2_GetReadsResponse, AUTO)
+
+
+

vendor/protobuf/readgroup/antenna/v2/get.pb.h

@@ -0,0 +1,139 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_GET_PB_H_INCLUDED
+#define PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "google/protobuf/timestamp.pb.h"
+#include "readgroup/antenna/v2/read.pb.h"
+#include "util/between.pb.h"
+#include "util/like.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _readgroup_antenna_v2_GetReadsRequest {
+    /* filters */
+    bool has_reader_id;
+    util_UUID reader_id;
+    bool has_group_id;
+    util_UUID group_id;
+    bool has_antenna;
+    uint32_t antenna;
+    bool has_epc;
+    util_Like epc;
+    bool has_total;
+    util_UInt64Between total;
+    bool has_timestamp;
+    util_TimestampBetween timestamp;
+    bool has_peak_rssi;
+    util_SInt32Between peak_rssi;
+    bool has_skew_rssi;
+    util_DoubleBetween skew_rssi;
+    bool has_variance_rssi;
+    util_DoubleBetween variance_rssi;
+    bool has_entropy_rssi;
+    util_DoubleBetween entropy_rssi;
+    bool has_duration;
+    util_DurationBetween duration;
+    pb_callback_t signals;
+    /* pagination */
+    bool has_limit;
+    uint64_t limit;
+    bool has_cursor;
+    google_protobuf_Timestamp cursor;
+} readgroup_antenna_v2_GetReadsRequest;
+
+typedef struct _readgroup_antenna_v2_GetReadsResponse {
+    pb_callback_t reads;
+    bool has_next_cursor;
+    google_protobuf_Timestamp next_cursor;
+} readgroup_antenna_v2_GetReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define readgroup_antenna_v2_GetReadsRequest_init_default {false, util_UUID_init_default, false, util_UUID_init_default, false, 0, false, util_Like_init_default, false, util_UInt64Between_init_default, false, util_TimestampBetween_init_default, false, util_SInt32Between_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DurationBetween_init_default, {{NULL}, NULL}, false, 0, false, google_protobuf_Timestamp_init_default}
+#define readgroup_antenna_v2_GetReadsResponse_init_default {{{NULL}, NULL}, false, google_protobuf_Timestamp_init_default}
+#define readgroup_antenna_v2_GetReadsRequest_init_zero {false, util_UUID_init_zero, false, util_UUID_init_zero, false, 0, false, util_Like_init_zero, false, util_UInt64Between_init_zero, false, util_TimestampBetween_init_zero, false, util_SInt32Between_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DurationBetween_init_zero, {{NULL}, NULL}, false, 0, false, google_protobuf_Timestamp_init_zero}
+#define readgroup_antenna_v2_GetReadsResponse_init_zero {{{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_antenna_v2_GetReadsRequest_reader_id_tag 1
+#define readgroup_antenna_v2_GetReadsRequest_group_id_tag 2
+#define readgroup_antenna_v2_GetReadsRequest_antenna_tag 3
+#define readgroup_antenna_v2_GetReadsRequest_epc_tag 4
+#define readgroup_antenna_v2_GetReadsRequest_total_tag 5
+#define readgroup_antenna_v2_GetReadsRequest_timestamp_tag 6
+#define readgroup_antenna_v2_GetReadsRequest_peak_rssi_tag 7
+#define readgroup_antenna_v2_GetReadsRequest_skew_rssi_tag 8
+#define readgroup_antenna_v2_GetReadsRequest_variance_rssi_tag 9
+#define readgroup_antenna_v2_GetReadsRequest_entropy_rssi_tag 10
+#define readgroup_antenna_v2_GetReadsRequest_duration_tag 11
+#define readgroup_antenna_v2_GetReadsRequest_signals_tag 12
+#define readgroup_antenna_v2_GetReadsRequest_limit_tag 13
+#define readgroup_antenna_v2_GetReadsRequest_cursor_tag 14
+#define readgroup_antenna_v2_GetReadsResponse_reads_tag 1
+#define readgroup_antenna_v2_GetReadsResponse_next_cursor_tag 2
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_antenna_v2_GetReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  group_id,          2) \
+X(a, STATIC,   OPTIONAL, UINT32,   antenna,           3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  epc,               4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  total,             5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  timestamp,         6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  peak_rssi,         7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  skew_rssi,         8) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  variance_rssi,     9) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  entropy_rssi,     10) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  duration,         11) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,          12) \
+X(a, STATIC,   OPTIONAL, UINT64,   limit,            13) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  cursor,           14)
+#define readgroup_antenna_v2_GetReadsRequest_CALLBACK pb_default_field_callback
+#define readgroup_antenna_v2_GetReadsRequest_DEFAULT NULL
+#define readgroup_antenna_v2_GetReadsRequest_reader_id_MSGTYPE util_UUID
+#define readgroup_antenna_v2_GetReadsRequest_group_id_MSGTYPE util_UUID
+#define readgroup_antenna_v2_GetReadsRequest_epc_MSGTYPE util_Like
+#define readgroup_antenna_v2_GetReadsRequest_total_MSGTYPE util_UInt64Between
+#define readgroup_antenna_v2_GetReadsRequest_timestamp_MSGTYPE util_TimestampBetween
+#define readgroup_antenna_v2_GetReadsRequest_peak_rssi_MSGTYPE util_SInt32Between
+#define readgroup_antenna_v2_GetReadsRequest_skew_rssi_MSGTYPE util_DoubleBetween
+#define readgroup_antenna_v2_GetReadsRequest_variance_rssi_MSGTYPE util_DoubleBetween
+#define readgroup_antenna_v2_GetReadsRequest_entropy_rssi_MSGTYPE util_DoubleBetween
+#define readgroup_antenna_v2_GetReadsRequest_duration_MSGTYPE util_DurationBetween
+#define readgroup_antenna_v2_GetReadsRequest_cursor_MSGTYPE google_protobuf_Timestamp
+
+#define readgroup_antenna_v2_GetReadsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  reads,             1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  next_cursor,       2)
+#define readgroup_antenna_v2_GetReadsResponse_CALLBACK pb_default_field_callback
+#define readgroup_antenna_v2_GetReadsResponse_DEFAULT NULL
+#define readgroup_antenna_v2_GetReadsResponse_reads_MSGTYPE readgroup_antenna_v2_Read
+#define readgroup_antenna_v2_GetReadsResponse_next_cursor_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t readgroup_antenna_v2_GetReadsRequest_msg;
+extern const pb_msgdesc_t readgroup_antenna_v2_GetReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_antenna_v2_GetReadsRequest_fields &readgroup_antenna_v2_GetReadsRequest_msg
+#define readgroup_antenna_v2_GetReadsResponse_fields &readgroup_antenna_v2_GetReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_antenna_v2_GetReadsRequest_size depends on runtime parameters */
+/* readgroup_antenna_v2_GetReadsResponse_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/antenna/v2/read.pb.c

@@ -0,0 +1,20 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/antenna/v2/read.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_antenna_v2_Read, readgroup_antenna_v2_Read, AUTO)
+
+
+
+#ifndef PB_CONVERT_DOUBLE_FLOAT
+/* On some platforms (such as AVR), double is really float.
+ * To be able to encode/decode double on these platforms, you need.
+ * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
+ */
+PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
+#endif
+

vendor/protobuf/readgroup/antenna/v2/read.pb.h

@@ -0,0 +1,103 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_READ_PB_H_INCLUDED
+#define PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_READ_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _readgroup_antenna_v2_Read {
+    bool has_group_id;
+    util_UUID group_id;
+    bool has_reader_id;
+    util_UUID reader_id;
+    uint32_t antenna;
+    pb_callback_t epc;
+    uint64_t total;
+    bool has_latitude;
+    float latitude;
+    bool has_longitude;
+    float longitude;
+    bool has_first_timestamp;
+    google_protobuf_Timestamp first_timestamp;
+    /* filled on read exit */
+    bool has_last_timestamp;
+    google_protobuf_Timestamp last_timestamp;
+    bool has_peak_rssi;
+    int32_t peak_rssi;
+    bool has_skew_rssi;
+    double skew_rssi;
+    bool has_variance_rssi;
+    double variance_rssi;
+    bool has_entropy_rssi;
+    double entropy_rssi;
+    pb_callback_t signals;
+} readgroup_antenna_v2_Read;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define readgroup_antenna_v2_Read_init_default   {false, util_UUID_init_default, false, util_UUID_init_default, 0, {{NULL}, NULL}, 0, false, 0, false, 0, false, google_protobuf_Timestamp_init_default, false, google_protobuf_Timestamp_init_default, false, 0, false, 0, false, 0, false, 0, {{NULL}, NULL}}
+#define readgroup_antenna_v2_Read_init_zero      {false, util_UUID_init_zero, false, util_UUID_init_zero, 0, {{NULL}, NULL}, 0, false, 0, false, 0, false, google_protobuf_Timestamp_init_zero, false, google_protobuf_Timestamp_init_zero, false, 0, false, 0, false, 0, false, 0, {{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_antenna_v2_Read_group_id_tag   1
+#define readgroup_antenna_v2_Read_reader_id_tag  2
+#define readgroup_antenna_v2_Read_antenna_tag    3
+#define readgroup_antenna_v2_Read_epc_tag        4
+#define readgroup_antenna_v2_Read_total_tag      5
+#define readgroup_antenna_v2_Read_latitude_tag   6
+#define readgroup_antenna_v2_Read_longitude_tag  7
+#define readgroup_antenna_v2_Read_first_timestamp_tag 8
+#define readgroup_antenna_v2_Read_last_timestamp_tag 9
+#define readgroup_antenna_v2_Read_peak_rssi_tag  10
+#define readgroup_antenna_v2_Read_skew_rssi_tag  11
+#define readgroup_antenna_v2_Read_variance_rssi_tag 12
+#define readgroup_antenna_v2_Read_entropy_rssi_tag 13
+#define readgroup_antenna_v2_Read_signals_tag    14
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_antenna_v2_Read_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  group_id,          1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         2) \
+X(a, STATIC,   SINGULAR, UINT32,   antenna,           3) \
+X(a, CALLBACK, SINGULAR, STRING,   epc,               4) \
+X(a, STATIC,   SINGULAR, UINT64,   total,             5) \
+X(a, STATIC,   OPTIONAL, FLOAT,    latitude,          6) \
+X(a, STATIC,   OPTIONAL, FLOAT,    longitude,         7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  first_timestamp,   8) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_timestamp,    9) \
+X(a, STATIC,   OPTIONAL, SINT32,   peak_rssi,        10) \
+X(a, STATIC,   OPTIONAL, DOUBLE,   skew_rssi,        11) \
+X(a, STATIC,   OPTIONAL, DOUBLE,   variance_rssi,    12) \
+X(a, STATIC,   OPTIONAL, DOUBLE,   entropy_rssi,     13) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,          14)
+#define readgroup_antenna_v2_Read_CALLBACK pb_default_field_callback
+#define readgroup_antenna_v2_Read_DEFAULT NULL
+#define readgroup_antenna_v2_Read_group_id_MSGTYPE util_UUID
+#define readgroup_antenna_v2_Read_reader_id_MSGTYPE util_UUID
+#define readgroup_antenna_v2_Read_first_timestamp_MSGTYPE google_protobuf_Timestamp
+#define readgroup_antenna_v2_Read_last_timestamp_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t readgroup_antenna_v2_Read_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_antenna_v2_Read_fields &readgroup_antenna_v2_Read_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_antenna_v2_Read_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/antenna/v2/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/antenna/v2/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/readgroup/antenna/v2/service.pb.h

@@ -0,0 +1,22 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_SERVICE_PB_H_INCLUDED
+#define PB_READGROUP_ANTENNA_V2_READGROUP_ANTENNA_V2_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "readgroup/antenna/v2/export.pb.h"
+#include "readgroup/antenna/v2/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/reader/v2/export.pb.c

@@ -0,0 +1,17 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/reader/v2/export.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_reader_v2_ExportReadsRequest, readgroup_reader_v2_ExportReadsRequest, 2)
+
+
+PB_BIND(readgroup_reader_v2_ExportReadsResponse, readgroup_reader_v2_ExportReadsResponse, AUTO)
+
+
+
+
+

vendor/protobuf/readgroup/reader/v2/export.pb.h

@@ -0,0 +1,88 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_READER_V2_READGROUP_READER_V2_EXPORT_PB_H_INCLUDED
+#define PB_READGROUP_READER_V2_READGROUP_READER_V2_EXPORT_PB_H_INCLUDED
+#include <pb.h>
+#include "readgroup/reader/v2/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _readgroup_reader_v2_ReportType {
+    readgroup_reader_v2_ReportType_REPORT_TYPE_UNSPECIFIED = 0,
+    readgroup_reader_v2_ReportType_REPORT_TYPE_CSV = 1,
+    readgroup_reader_v2_ReportType_REPORT_TYPE_XML = 2,
+    readgroup_reader_v2_ReportType_REPORT_TYPE_JSON = 3
+} readgroup_reader_v2_ReportType;
+
+/* Struct definitions */
+typedef struct _readgroup_reader_v2_ExportReadsRequest {
+    readgroup_reader_v2_ReportType type;
+    bool has_request;
+    readgroup_reader_v2_GetReadsRequest request;
+} readgroup_reader_v2_ExportReadsRequest;
+
+typedef struct _readgroup_reader_v2_ExportReadsResponse {
+    pb_callback_t file;
+} readgroup_reader_v2_ExportReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _readgroup_reader_v2_ReportType_MIN readgroup_reader_v2_ReportType_REPORT_TYPE_UNSPECIFIED
+#define _readgroup_reader_v2_ReportType_MAX readgroup_reader_v2_ReportType_REPORT_TYPE_JSON
+#define _readgroup_reader_v2_ReportType_ARRAYSIZE ((readgroup_reader_v2_ReportType)(readgroup_reader_v2_ReportType_REPORT_TYPE_JSON+1))
+
+#define readgroup_reader_v2_ExportReadsRequest_type_ENUMTYPE readgroup_reader_v2_ReportType
+
+
+
+/* Initializer values for message structs */
+#define readgroup_reader_v2_ExportReadsRequest_init_default {_readgroup_reader_v2_ReportType_MIN, false, readgroup_reader_v2_GetReadsRequest_init_default}
+#define readgroup_reader_v2_ExportReadsResponse_init_default {{{NULL}, NULL}}
+#define readgroup_reader_v2_ExportReadsRequest_init_zero {_readgroup_reader_v2_ReportType_MIN, false, readgroup_reader_v2_GetReadsRequest_init_zero}
+#define readgroup_reader_v2_ExportReadsResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_reader_v2_ExportReadsRequest_type_tag 1
+#define readgroup_reader_v2_ExportReadsRequest_request_tag 2
+#define readgroup_reader_v2_ExportReadsResponse_file_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_reader_v2_ExportReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  request,           2)
+#define readgroup_reader_v2_ExportReadsRequest_CALLBACK NULL
+#define readgroup_reader_v2_ExportReadsRequest_DEFAULT NULL
+#define readgroup_reader_v2_ExportReadsRequest_request_MSGTYPE readgroup_reader_v2_GetReadsRequest
+
+#define readgroup_reader_v2_ExportReadsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   file,              1)
+#define readgroup_reader_v2_ExportReadsResponse_CALLBACK pb_default_field_callback
+#define readgroup_reader_v2_ExportReadsResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t readgroup_reader_v2_ExportReadsRequest_msg;
+extern const pb_msgdesc_t readgroup_reader_v2_ExportReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_reader_v2_ExportReadsRequest_fields &readgroup_reader_v2_ExportReadsRequest_msg
+#define readgroup_reader_v2_ExportReadsResponse_fields &readgroup_reader_v2_ExportReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_reader_v2_ExportReadsResponse_size depends on runtime parameters */
+#if defined(readgroup_reader_v2_GetReadsRequest_size)
+#define READGROUP_READER_V2_READGROUP_READER_V2_EXPORT_PB_H_MAX_SIZE readgroup_reader_v2_ExportReadsRequest_size
+#define readgroup_reader_v2_ExportReadsRequest_size (8 + readgroup_reader_v2_GetReadsRequest_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/reader/v2/get.pb.c

@@ -0,0 +1,15 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/reader/v2/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_reader_v2_GetReadsRequest, readgroup_reader_v2_GetReadsRequest, 2)
+
+
+PB_BIND(readgroup_reader_v2_GetReadsResponse, readgroup_reader_v2_GetReadsResponse, AUTO)
+
+
+

vendor/protobuf/readgroup/reader/v2/get.pb.h

@@ -0,0 +1,154 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_READER_V2_READGROUP_READER_V2_GET_PB_H_INCLUDED
+#define PB_READGROUP_READER_V2_READGROUP_READER_V2_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "buf/validate/validate.pb.h"
+#include "google/protobuf/timestamp.pb.h"
+#include "readgroup/reader/v2/read.pb.h"
+#include "util/between.pb.h"
+#include "util/like.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _readgroup_reader_v2_GetReadsRequest {
+    /* filters */
+    bool has_reader_id;
+    util_UUID reader_id;
+    bool has_group_id;
+    util_UUID group_id;
+    bool has_epc;
+    util_Like epc;
+    bool has_total;
+    util_UInt64Between total;
+    bool has_timestamp;
+    util_TimestampBetween timestamp;
+    bool has_peak_rssi;
+    util_SInt32Between peak_rssi;
+    bool has_skew_rssi;
+    util_DoubleBetween skew_rssi;
+    bool has_variance_rssi;
+    util_DoubleBetween variance_rssi;
+    bool has_entropy_rssi;
+    util_DoubleBetween entropy_rssi;
+    bool has_duration;
+    util_DurationBetween duration;
+    pb_callback_t signals;
+    /* antenna filters */
+    bool has_intersections;
+    util_UInt64Between intersections;
+    bool has_intersection_start;
+    util_TimestampBetween intersection_start;
+    bool has_intersection_end;
+    util_TimestampBetween intersection_end;
+    pb_callback_t antennas;
+    /* pagination */
+    bool has_limit;
+    uint64_t limit;
+    bool has_cursor;
+    google_protobuf_Timestamp cursor;
+} readgroup_reader_v2_GetReadsRequest;
+
+typedef struct _readgroup_reader_v2_GetReadsResponse {
+    pb_callback_t reads;
+    bool has_next_cursor;
+    google_protobuf_Timestamp next_cursor;
+} readgroup_reader_v2_GetReadsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define readgroup_reader_v2_GetReadsRequest_init_default {false, util_UUID_init_default, false, util_UUID_init_default, false, util_Like_init_default, false, util_UInt64Between_init_default, false, util_TimestampBetween_init_default, false, util_SInt32Between_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DoubleBetween_init_default, false, util_DurationBetween_init_default, {{NULL}, NULL}, false, util_UInt64Between_init_default, false, util_TimestampBetween_init_default, false, util_TimestampBetween_init_default, {{NULL}, NULL}, false, 0, false, google_protobuf_Timestamp_init_default}
+#define readgroup_reader_v2_GetReadsResponse_init_default {{{NULL}, NULL}, false, google_protobuf_Timestamp_init_default}
+#define readgroup_reader_v2_GetReadsRequest_init_zero {false, util_UUID_init_zero, false, util_UUID_init_zero, false, util_Like_init_zero, false, util_UInt64Between_init_zero, false, util_TimestampBetween_init_zero, false, util_SInt32Between_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DoubleBetween_init_zero, false, util_DurationBetween_init_zero, {{NULL}, NULL}, false, util_UInt64Between_init_zero, false, util_TimestampBetween_init_zero, false, util_TimestampBetween_init_zero, {{NULL}, NULL}, false, 0, false, google_protobuf_Timestamp_init_zero}
+#define readgroup_reader_v2_GetReadsResponse_init_zero {{{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_reader_v2_GetReadsRequest_reader_id_tag 1
+#define readgroup_reader_v2_GetReadsRequest_group_id_tag 2
+#define readgroup_reader_v2_GetReadsRequest_epc_tag 3
+#define readgroup_reader_v2_GetReadsRequest_total_tag 4
+#define readgroup_reader_v2_GetReadsRequest_timestamp_tag 5
+#define readgroup_reader_v2_GetReadsRequest_peak_rssi_tag 6
+#define readgroup_reader_v2_GetReadsRequest_skew_rssi_tag 7
+#define readgroup_reader_v2_GetReadsRequest_variance_rssi_tag 8
+#define readgroup_reader_v2_GetReadsRequest_entropy_rssi_tag 9
+#define readgroup_reader_v2_GetReadsRequest_duration_tag 10
+#define readgroup_reader_v2_GetReadsRequest_signals_tag 11
+#define readgroup_reader_v2_GetReadsRequest_intersections_tag 12
+#define readgroup_reader_v2_GetReadsRequest_intersection_start_tag 13
+#define readgroup_reader_v2_GetReadsRequest_intersection_end_tag 14
+#define readgroup_reader_v2_GetReadsRequest_antennas_tag 15
+#define readgroup_reader_v2_GetReadsRequest_limit_tag 16
+#define readgroup_reader_v2_GetReadsRequest_cursor_tag 17
+#define readgroup_reader_v2_GetReadsResponse_reads_tag 1
+#define readgroup_reader_v2_GetReadsResponse_next_cursor_tag 2
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_reader_v2_GetReadsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  group_id,          2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  epc,               3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  total,             4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  timestamp,         5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  peak_rssi,         6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  skew_rssi,         7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  variance_rssi,     8) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  entropy_rssi,      9) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  duration,         10) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,          11) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  intersections,    12) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  intersection_start,  13) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  intersection_end,  14) \
+X(a, CALLBACK, REPEATED, UINT32,   antennas,         15) \
+X(a, STATIC,   OPTIONAL, UINT64,   limit,            16) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  cursor,           17)
+#define readgroup_reader_v2_GetReadsRequest_CALLBACK pb_default_field_callback
+#define readgroup_reader_v2_GetReadsRequest_DEFAULT NULL
+#define readgroup_reader_v2_GetReadsRequest_reader_id_MSGTYPE util_UUID
+#define readgroup_reader_v2_GetReadsRequest_group_id_MSGTYPE util_UUID
+#define readgroup_reader_v2_GetReadsRequest_epc_MSGTYPE util_Like
+#define readgroup_reader_v2_GetReadsRequest_total_MSGTYPE util_UInt64Between
+#define readgroup_reader_v2_GetReadsRequest_timestamp_MSGTYPE util_TimestampBetween
+#define readgroup_reader_v2_GetReadsRequest_peak_rssi_MSGTYPE util_SInt32Between
+#define readgroup_reader_v2_GetReadsRequest_skew_rssi_MSGTYPE util_DoubleBetween
+#define readgroup_reader_v2_GetReadsRequest_variance_rssi_MSGTYPE util_DoubleBetween
+#define readgroup_reader_v2_GetReadsRequest_entropy_rssi_MSGTYPE util_DoubleBetween
+#define readgroup_reader_v2_GetReadsRequest_duration_MSGTYPE util_DurationBetween
+#define readgroup_reader_v2_GetReadsRequest_intersections_MSGTYPE util_UInt64Between
+#define readgroup_reader_v2_GetReadsRequest_intersection_start_MSGTYPE util_TimestampBetween
+#define readgroup_reader_v2_GetReadsRequest_intersection_end_MSGTYPE util_TimestampBetween
+#define readgroup_reader_v2_GetReadsRequest_cursor_MSGTYPE google_protobuf_Timestamp
+
+#define readgroup_reader_v2_GetReadsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  reads,             1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  next_cursor,       2)
+#define readgroup_reader_v2_GetReadsResponse_CALLBACK pb_default_field_callback
+#define readgroup_reader_v2_GetReadsResponse_DEFAULT NULL
+#define readgroup_reader_v2_GetReadsResponse_reads_MSGTYPE readgroup_reader_v2_Read
+#define readgroup_reader_v2_GetReadsResponse_next_cursor_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t readgroup_reader_v2_GetReadsRequest_msg;
+extern const pb_msgdesc_t readgroup_reader_v2_GetReadsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_reader_v2_GetReadsRequest_fields &readgroup_reader_v2_GetReadsRequest_msg
+#define readgroup_reader_v2_GetReadsResponse_fields &readgroup_reader_v2_GetReadsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_reader_v2_GetReadsRequest_size depends on runtime parameters */
+/* readgroup_reader_v2_GetReadsResponse_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/reader/v2/read.pb.c

@@ -0,0 +1,20 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/reader/v2/read.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_reader_v2_Read, readgroup_reader_v2_Read, 2)
+
+
+
+#ifndef PB_CONVERT_DOUBLE_FLOAT
+/* On some platforms (such as AVR), double is really float.
+ * To be able to encode/decode double on these platforms, you need.
+ * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
+ */
+PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
+#endif
+

vendor/protobuf/readgroup/reader/v2/read.pb.h

@@ -0,0 +1,118 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_READER_V2_READGROUP_READER_V2_READ_PB_H_INCLUDED
+#define PB_READGROUP_READER_V2_READGROUP_READER_V2_READ_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _readgroup_reader_v2_Read {
+    bool has_group_id;
+    util_UUID group_id;
+    bool has_reader_id;
+    util_UUID reader_id;
+    pb_callback_t epc;
+    uint64_t total;
+    bool has_latitude;
+    float latitude;
+    bool has_longitude;
+    float longitude;
+    bool has_first_timestamp;
+    google_protobuf_Timestamp first_timestamp;
+    /* filled on read exit */
+    bool has_last_timestamp;
+    google_protobuf_Timestamp last_timestamp;
+    bool has_peak_rssi;
+    int32_t peak_rssi;
+    bool has_skew_rssi;
+    double skew_rssi;
+    bool has_variance_rssi;
+    double variance_rssi;
+    bool has_entropy_rssi;
+    double entropy_rssi;
+    pb_callback_t signals;
+    /* -- antenna aggregates -- */
+    bool has_intersections;
+    uint64_t intersections;
+    bool has_intersections_start;
+    google_protobuf_Timestamp intersections_start;
+    bool has_intersections_end;
+    google_protobuf_Timestamp intersections_end;
+    pb_callback_t antennas;
+} readgroup_reader_v2_Read;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define readgroup_reader_v2_Read_init_default    {false, util_UUID_init_default, false, util_UUID_init_default, {{NULL}, NULL}, 0, false, 0, false, 0, false, google_protobuf_Timestamp_init_default, false, google_protobuf_Timestamp_init_default, false, 0, false, 0, false, 0, false, 0, {{NULL}, NULL}, false, 0, false, google_protobuf_Timestamp_init_default, false, google_protobuf_Timestamp_init_default, {{NULL}, NULL}}
+#define readgroup_reader_v2_Read_init_zero       {false, util_UUID_init_zero, false, util_UUID_init_zero, {{NULL}, NULL}, 0, false, 0, false, 0, false, google_protobuf_Timestamp_init_zero, false, google_protobuf_Timestamp_init_zero, false, 0, false, 0, false, 0, false, 0, {{NULL}, NULL}, false, 0, false, google_protobuf_Timestamp_init_zero, false, google_protobuf_Timestamp_init_zero, {{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_reader_v2_Read_group_id_tag    1
+#define readgroup_reader_v2_Read_reader_id_tag   2
+#define readgroup_reader_v2_Read_epc_tag         3
+#define readgroup_reader_v2_Read_total_tag       4
+#define readgroup_reader_v2_Read_latitude_tag    5
+#define readgroup_reader_v2_Read_longitude_tag   6
+#define readgroup_reader_v2_Read_first_timestamp_tag 7
+#define readgroup_reader_v2_Read_last_timestamp_tag 8
+#define readgroup_reader_v2_Read_peak_rssi_tag   9
+#define readgroup_reader_v2_Read_skew_rssi_tag   10
+#define readgroup_reader_v2_Read_variance_rssi_tag 11
+#define readgroup_reader_v2_Read_entropy_rssi_tag 12
+#define readgroup_reader_v2_Read_signals_tag     13
+#define readgroup_reader_v2_Read_intersections_tag 14
+#define readgroup_reader_v2_Read_intersections_start_tag 15
+#define readgroup_reader_v2_Read_intersections_end_tag 16
+#define readgroup_reader_v2_Read_antennas_tag    17
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_reader_v2_Read_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  group_id,          1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         2) \
+X(a, CALLBACK, SINGULAR, STRING,   epc,               3) \
+X(a, STATIC,   SINGULAR, UINT64,   total,             4) \
+X(a, STATIC,   OPTIONAL, FLOAT,    latitude,          5) \
+X(a, STATIC,   OPTIONAL, FLOAT,    longitude,         6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  first_timestamp,   7) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_timestamp,    8) \
+X(a, STATIC,   OPTIONAL, SINT32,   peak_rssi,         9) \
+X(a, STATIC,   OPTIONAL, DOUBLE,   skew_rssi,        10) \
+X(a, STATIC,   OPTIONAL, DOUBLE,   variance_rssi,    11) \
+X(a, STATIC,   OPTIONAL, DOUBLE,   entropy_rssi,     12) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,          13) \
+X(a, STATIC,   OPTIONAL, UINT64,   intersections,    14) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  intersections_start,  15) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  intersections_end,  16) \
+X(a, CALLBACK, REPEATED, UINT32,   antennas,         17)
+#define readgroup_reader_v2_Read_CALLBACK pb_default_field_callback
+#define readgroup_reader_v2_Read_DEFAULT NULL
+#define readgroup_reader_v2_Read_group_id_MSGTYPE util_UUID
+#define readgroup_reader_v2_Read_reader_id_MSGTYPE util_UUID
+#define readgroup_reader_v2_Read_first_timestamp_MSGTYPE google_protobuf_Timestamp
+#define readgroup_reader_v2_Read_last_timestamp_MSGTYPE google_protobuf_Timestamp
+#define readgroup_reader_v2_Read_intersections_start_MSGTYPE google_protobuf_Timestamp
+#define readgroup_reader_v2_Read_intersections_end_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t readgroup_reader_v2_Read_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_reader_v2_Read_fields &readgroup_reader_v2_Read_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_reader_v2_Read_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/reader/v2/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/reader/v2/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/readgroup/reader/v2/service.pb.h

@@ -0,0 +1,22 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_READER_V2_READGROUP_READER_V2_SERVICE_PB_H_INCLUDED
+#define PB_READGROUP_READER_V2_READGROUP_READER_V2_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "readgroup/reader/v2/export.pb.h"
+#include "readgroup/reader/v2/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/v1/export.pb.c

@@ -0,0 +1,17 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/v1/export.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_v1_ExportReadGroupsRequest, readgroup_v1_ExportReadGroupsRequest, 2)
+
+
+PB_BIND(readgroup_v1_ExportReadGroupsResponse, readgroup_v1_ExportReadGroupsResponse, AUTO)
+
+
+
+
+

vendor/protobuf/readgroup/v1/export.pb.h

@@ -0,0 +1,88 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_V1_READGROUP_V1_EXPORT_PB_H_INCLUDED
+#define PB_READGROUP_V1_READGROUP_V1_EXPORT_PB_H_INCLUDED
+#include <pb.h>
+#include "readgroup/v1/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _readgroup_v1_ReportType {
+    readgroup_v1_ReportType_REPORT_TYPE_UNSPECIFIED = 0,
+    readgroup_v1_ReportType_REPORT_TYPE_CSV = 1,
+    readgroup_v1_ReportType_REPORT_TYPE_XML = 2,
+    readgroup_v1_ReportType_REPORT_TYPE_JSON = 3
+} readgroup_v1_ReportType;
+
+/* Struct definitions */
+typedef struct _readgroup_v1_ExportReadGroupsRequest {
+    readgroup_v1_ReportType type;
+    bool has_request;
+    readgroup_v1_GetReadGroupsRequest request;
+} readgroup_v1_ExportReadGroupsRequest;
+
+typedef struct _readgroup_v1_ExportReadGroupsResponse {
+    pb_callback_t file;
+} readgroup_v1_ExportReadGroupsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _readgroup_v1_ReportType_MIN readgroup_v1_ReportType_REPORT_TYPE_UNSPECIFIED
+#define _readgroup_v1_ReportType_MAX readgroup_v1_ReportType_REPORT_TYPE_JSON
+#define _readgroup_v1_ReportType_ARRAYSIZE ((readgroup_v1_ReportType)(readgroup_v1_ReportType_REPORT_TYPE_JSON+1))
+
+#define readgroup_v1_ExportReadGroupsRequest_type_ENUMTYPE readgroup_v1_ReportType
+
+
+
+/* Initializer values for message structs */
+#define readgroup_v1_ExportReadGroupsRequest_init_default {_readgroup_v1_ReportType_MIN, false, readgroup_v1_GetReadGroupsRequest_init_default}
+#define readgroup_v1_ExportReadGroupsResponse_init_default {{{NULL}, NULL}}
+#define readgroup_v1_ExportReadGroupsRequest_init_zero {_readgroup_v1_ReportType_MIN, false, readgroup_v1_GetReadGroupsRequest_init_zero}
+#define readgroup_v1_ExportReadGroupsResponse_init_zero {{{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_v1_ExportReadGroupsRequest_type_tag 1
+#define readgroup_v1_ExportReadGroupsRequest_request_tag 2
+#define readgroup_v1_ExportReadGroupsResponse_file_tag 1
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_v1_ExportReadGroupsRequest_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    type,              1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  request,           2)
+#define readgroup_v1_ExportReadGroupsRequest_CALLBACK NULL
+#define readgroup_v1_ExportReadGroupsRequest_DEFAULT NULL
+#define readgroup_v1_ExportReadGroupsRequest_request_MSGTYPE readgroup_v1_GetReadGroupsRequest
+
+#define readgroup_v1_ExportReadGroupsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   file,              1)
+#define readgroup_v1_ExportReadGroupsResponse_CALLBACK pb_default_field_callback
+#define readgroup_v1_ExportReadGroupsResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t readgroup_v1_ExportReadGroupsRequest_msg;
+extern const pb_msgdesc_t readgroup_v1_ExportReadGroupsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_v1_ExportReadGroupsRequest_fields &readgroup_v1_ExportReadGroupsRequest_msg
+#define readgroup_v1_ExportReadGroupsResponse_fields &readgroup_v1_ExportReadGroupsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_v1_ExportReadGroupsResponse_size depends on runtime parameters */
+#if defined(readgroup_v1_GetReadGroupsRequest_size)
+#define READGROUP_V1_READGROUP_V1_EXPORT_PB_H_MAX_SIZE readgroup_v1_ExportReadGroupsRequest_size
+#define readgroup_v1_ExportReadGroupsRequest_size (8 + readgroup_v1_GetReadGroupsRequest_size)
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/v1/get.pb.c

@@ -0,0 +1,19 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/v1/get.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_v1_GetReadGroupsRequest, readgroup_v1_GetReadGroupsRequest, 2)
+
+
+PB_BIND(readgroup_v1_GetReadGroupsResponse, readgroup_v1_GetReadGroupsResponse, AUTO)
+
+
+
+
+
+
+

vendor/protobuf/readgroup/v1/get.pb.h

@@ -0,0 +1,170 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_V1_READGROUP_V1_GET_PB_H_INCLUDED
+#define PB_READGROUP_V1_READGROUP_V1_GET_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/duration.pb.h"
+#include "google/protobuf/timestamp.pb.h"
+#include "readgroup/v1/readgroup.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _readgroup_v1_SortOrder {
+    readgroup_v1_SortOrder_SORT_ORDER_UNSPECIFIED = 0,
+    readgroup_v1_SortOrder_SORT_ORDER_LAST_SEEN_ASCENDING = 1,
+    readgroup_v1_SortOrder_SORT_ORDER_LAST_SEEN_DESCENDING = 2,
+    readgroup_v1_SortOrder_SORT_ORDER_FIRST_SEEN_ASCENDING = 3,
+    readgroup_v1_SortOrder_SORT_ORDER_FIRST_SEEN_DESCENDING = 4
+} readgroup_v1_SortOrder;
+
+typedef enum _readgroup_v1_Group {
+    readgroup_v1_Group_GROUP_UNSPECIFIED = 0,
+    readgroup_v1_Group_GROUP_READER = 1,
+    readgroup_v1_Group_GROUP_ANTENNA = 2
+} readgroup_v1_Group;
+
+/* Struct definitions */
+typedef struct _readgroup_v1_GetReadGroupsRequest {
+    pb_callback_t reader_ids;
+    pb_callback_t location_ids;
+    pb_callback_t antennas;
+    pb_callback_t epc;
+    pb_callback_t epc_filter;
+    /* aggregates */
+    bool has_start;
+    google_protobuf_Timestamp start;
+    bool has_end;
+    google_protobuf_Timestamp end;
+    pb_callback_t signals;
+    bool has_minimum_avg_rssi;
+    int32_t minimum_avg_rssi;
+    bool has_sort;
+    readgroup_v1_SortOrder sort;
+    bool has_minimum_count;
+    int32_t minimum_count;
+    bool has_minimum_peak_rssi;
+    int32_t minimum_peak_rssi;
+    bool has_duration;
+    google_protobuf_Duration duration;
+    int64_t limit;
+    int64_t offset;
+    bool has_all;
+    bool all;
+    bool has_inbound;
+    bool inbound;
+    bool has_outbound;
+    bool outbound;
+    bool has_group_by;
+    readgroup_v1_Group group_by;
+    pb_callback_t group_id;
+} readgroup_v1_GetReadGroupsRequest;
+
+typedef struct _readgroup_v1_GetReadGroupsResponse {
+    pb_callback_t reads;
+    uint64_t count;
+} readgroup_v1_GetReadGroupsResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helper constants for enums */
+#define _readgroup_v1_SortOrder_MIN readgroup_v1_SortOrder_SORT_ORDER_UNSPECIFIED
+#define _readgroup_v1_SortOrder_MAX readgroup_v1_SortOrder_SORT_ORDER_FIRST_SEEN_DESCENDING
+#define _readgroup_v1_SortOrder_ARRAYSIZE ((readgroup_v1_SortOrder)(readgroup_v1_SortOrder_SORT_ORDER_FIRST_SEEN_DESCENDING+1))
+
+#define _readgroup_v1_Group_MIN readgroup_v1_Group_GROUP_UNSPECIFIED
+#define _readgroup_v1_Group_MAX readgroup_v1_Group_GROUP_ANTENNA
+#define _readgroup_v1_Group_ARRAYSIZE ((readgroup_v1_Group)(readgroup_v1_Group_GROUP_ANTENNA+1))
+
+#define readgroup_v1_GetReadGroupsRequest_sort_ENUMTYPE readgroup_v1_SortOrder
+#define readgroup_v1_GetReadGroupsRequest_group_by_ENUMTYPE readgroup_v1_Group
+
+
+
+/* Initializer values for message structs */
+#define readgroup_v1_GetReadGroupsRequest_init_default {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default, false, google_protobuf_Timestamp_init_default, {{NULL}, NULL}, false, 0, false, _readgroup_v1_SortOrder_MIN, false, 0, false, 0, false, google_protobuf_Duration_init_default, 0, 0, false, 0, false, 0, false, 0, false, _readgroup_v1_Group_MIN, {{NULL}, NULL}}
+#define readgroup_v1_GetReadGroupsResponse_init_default {{{NULL}, NULL}, 0}
+#define readgroup_v1_GetReadGroupsRequest_init_zero {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero, false, google_protobuf_Timestamp_init_zero, {{NULL}, NULL}, false, 0, false, _readgroup_v1_SortOrder_MIN, false, 0, false, 0, false, google_protobuf_Duration_init_zero, 0, 0, false, 0, false, 0, false, 0, false, _readgroup_v1_Group_MIN, {{NULL}, NULL}}
+#define readgroup_v1_GetReadGroupsResponse_init_zero {{{NULL}, NULL}, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_v1_GetReadGroupsRequest_reader_ids_tag 1
+#define readgroup_v1_GetReadGroupsRequest_location_ids_tag 2
+#define readgroup_v1_GetReadGroupsRequest_antennas_tag 3
+#define readgroup_v1_GetReadGroupsRequest_epc_tag 4
+#define readgroup_v1_GetReadGroupsRequest_epc_filter_tag 5
+#define readgroup_v1_GetReadGroupsRequest_start_tag 6
+#define readgroup_v1_GetReadGroupsRequest_end_tag 7
+#define readgroup_v1_GetReadGroupsRequest_signals_tag 8
+#define readgroup_v1_GetReadGroupsRequest_minimum_avg_rssi_tag 9
+#define readgroup_v1_GetReadGroupsRequest_sort_tag 10
+#define readgroup_v1_GetReadGroupsRequest_minimum_count_tag 11
+#define readgroup_v1_GetReadGroupsRequest_minimum_peak_rssi_tag 12
+#define readgroup_v1_GetReadGroupsRequest_duration_tag 13
+#define readgroup_v1_GetReadGroupsRequest_limit_tag 14
+#define readgroup_v1_GetReadGroupsRequest_offset_tag 15
+#define readgroup_v1_GetReadGroupsRequest_all_tag 16
+#define readgroup_v1_GetReadGroupsRequest_inbound_tag 17
+#define readgroup_v1_GetReadGroupsRequest_outbound_tag 18
+#define readgroup_v1_GetReadGroupsRequest_group_by_tag 19
+#define readgroup_v1_GetReadGroupsRequest_group_id_tag 20
+#define readgroup_v1_GetReadGroupsResponse_reads_tag 1
+#define readgroup_v1_GetReadGroupsResponse_count_tag 2
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_v1_GetReadGroupsRequest_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, INT32,    reader_ids,        1) \
+X(a, CALLBACK, REPEATED, INT32,    location_ids,      2) \
+X(a, CALLBACK, REPEATED, INT32,    antennas,          3) \
+X(a, CALLBACK, OPTIONAL, STRING,   epc,               4) \
+X(a, CALLBACK, OPTIONAL, STRING,   epc_filter,        5) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  start,             6) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  end,               7) \
+X(a, CALLBACK, REPEATED, INT32,    signals,           8) \
+X(a, STATIC,   OPTIONAL, SINT32,   minimum_avg_rssi,   9) \
+X(a, STATIC,   OPTIONAL, UENUM,    sort,             10) \
+X(a, STATIC,   OPTIONAL, INT32,    minimum_count,    11) \
+X(a, STATIC,   OPTIONAL, SINT32,   minimum_peak_rssi,  12) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  duration,         13) \
+X(a, STATIC,   SINGULAR, INT64,    limit,            14) \
+X(a, STATIC,   SINGULAR, INT64,    offset,           15) \
+X(a, STATIC,   OPTIONAL, BOOL,     all,              16) \
+X(a, STATIC,   OPTIONAL, BOOL,     inbound,          17) \
+X(a, STATIC,   OPTIONAL, BOOL,     outbound,         18) \
+X(a, STATIC,   OPTIONAL, UENUM,    group_by,         19) \
+X(a, CALLBACK, OPTIONAL, STRING,   group_id,         20)
+#define readgroup_v1_GetReadGroupsRequest_CALLBACK pb_default_field_callback
+#define readgroup_v1_GetReadGroupsRequest_DEFAULT NULL
+#define readgroup_v1_GetReadGroupsRequest_start_MSGTYPE google_protobuf_Timestamp
+#define readgroup_v1_GetReadGroupsRequest_end_MSGTYPE google_protobuf_Timestamp
+#define readgroup_v1_GetReadGroupsRequest_duration_MSGTYPE google_protobuf_Duration
+
+#define readgroup_v1_GetReadGroupsResponse_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  reads,             1) \
+X(a, STATIC,   SINGULAR, UINT64,   count,             2)
+#define readgroup_v1_GetReadGroupsResponse_CALLBACK pb_default_field_callback
+#define readgroup_v1_GetReadGroupsResponse_DEFAULT NULL
+#define readgroup_v1_GetReadGroupsResponse_reads_MSGTYPE readgroup_v1_ReadGroup
+
+extern const pb_msgdesc_t readgroup_v1_GetReadGroupsRequest_msg;
+extern const pb_msgdesc_t readgroup_v1_GetReadGroupsResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_v1_GetReadGroupsRequest_fields &readgroup_v1_GetReadGroupsRequest_msg
+#define readgroup_v1_GetReadGroupsResponse_fields &readgroup_v1_GetReadGroupsResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_v1_GetReadGroupsRequest_size depends on runtime parameters */
+/* readgroup_v1_GetReadGroupsResponse_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/v1/readgroup.pb.c

@@ -0,0 +1,20 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/v1/readgroup.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_v1_ReadGroup, readgroup_v1_ReadGroup, 2)
+
+
+
+#ifndef PB_CONVERT_DOUBLE_FLOAT
+/* On some platforms (such as AVR), double is really float.
+ * To be able to encode/decode double on these platforms, you need.
+ * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
+ */
+PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
+#endif
+

vendor/protobuf/readgroup/v1/readgroup.pb.h

@@ -0,0 +1,108 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_V1_READGROUP_V1_READGROUP_PB_H_INCLUDED
+#define PB_READGROUP_V1_READGROUP_V1_READGROUP_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _readgroup_v1_ReadGroup {
+    pb_callback_t id;
+    /* reader */
+    uint32_t reader_id;
+    pb_callback_t reader_name;
+    pb_callback_t epc;
+    bool has_first_seen;
+    google_protobuf_Timestamp first_seen;
+    pb_callback_t name;
+    int32_t peak_rssi;
+    uint64_t count;
+    pb_callback_t reader_label;
+    bool has_last_seen;
+    google_protobuf_Timestamp last_seen;
+    /* location */
+    pb_callback_t location;
+    pb_callback_t antennas;
+    double avg_rssi;
+    pb_callback_t signals;
+    bool reader_inbound;
+    bool reader_outbound;
+    double skew;
+    double kurt;
+    pb_callback_t group_id;
+} readgroup_v1_ReadGroup;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define readgroup_v1_ReadGroup_init_default      {{{NULL}, NULL}, 0, {{NULL}, NULL}, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default, {{NULL}, NULL}, {{NULL}, NULL}, 0, {{NULL}, NULL}, 0, 0, 0, 0, {{NULL}, NULL}}
+#define readgroup_v1_ReadGroup_init_zero         {{{NULL}, NULL}, 0, {{NULL}, NULL}, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero, {{NULL}, NULL}, 0, 0, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero, {{NULL}, NULL}, {{NULL}, NULL}, 0, {{NULL}, NULL}, 0, 0, 0, 0, {{NULL}, NULL}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_v1_ReadGroup_id_tag            1
+#define readgroup_v1_ReadGroup_reader_id_tag     2
+#define readgroup_v1_ReadGroup_reader_name_tag   3
+#define readgroup_v1_ReadGroup_epc_tag           4
+#define readgroup_v1_ReadGroup_first_seen_tag    5
+#define readgroup_v1_ReadGroup_name_tag          6
+#define readgroup_v1_ReadGroup_peak_rssi_tag     7
+#define readgroup_v1_ReadGroup_count_tag         8
+#define readgroup_v1_ReadGroup_reader_label_tag  9
+#define readgroup_v1_ReadGroup_last_seen_tag     10
+#define readgroup_v1_ReadGroup_location_tag      11
+#define readgroup_v1_ReadGroup_antennas_tag      12
+#define readgroup_v1_ReadGroup_avg_rssi_tag      13
+#define readgroup_v1_ReadGroup_signals_tag       14
+#define readgroup_v1_ReadGroup_reader_inbound_tag 15
+#define readgroup_v1_ReadGroup_reader_outbound_tag 16
+#define readgroup_v1_ReadGroup_skew_tag          17
+#define readgroup_v1_ReadGroup_kurt_tag          18
+#define readgroup_v1_ReadGroup_group_id_tag      19
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_v1_ReadGroup_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   id,                1) \
+X(a, STATIC,   SINGULAR, UINT32,   reader_id,         2) \
+X(a, CALLBACK, SINGULAR, STRING,   reader_name,       3) \
+X(a, CALLBACK, SINGULAR, STRING,   epc,               4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  first_seen,        5) \
+X(a, CALLBACK, OPTIONAL, STRING,   name,              6) \
+X(a, STATIC,   SINGULAR, SINT32,   peak_rssi,         7) \
+X(a, STATIC,   SINGULAR, UINT64,   count,             8) \
+X(a, CALLBACK, OPTIONAL, STRING,   reader_label,      9) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  last_seen,        10) \
+X(a, CALLBACK, OPTIONAL, STRING,   location,         11) \
+X(a, CALLBACK, REPEATED, UINT32,   antennas,         12) \
+X(a, STATIC,   SINGULAR, DOUBLE,   avg_rssi,         13) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,          14) \
+X(a, STATIC,   SINGULAR, BOOL,     reader_inbound,   15) \
+X(a, STATIC,   SINGULAR, BOOL,     reader_outbound,  16) \
+X(a, STATIC,   SINGULAR, DOUBLE,   skew,             17) \
+X(a, STATIC,   SINGULAR, DOUBLE,   kurt,             18) \
+X(a, CALLBACK, SINGULAR, STRING,   group_id,         19)
+#define readgroup_v1_ReadGroup_CALLBACK pb_default_field_callback
+#define readgroup_v1_ReadGroup_DEFAULT NULL
+#define readgroup_v1_ReadGroup_first_seen_MSGTYPE google_protobuf_Timestamp
+#define readgroup_v1_ReadGroup_last_seen_MSGTYPE google_protobuf_Timestamp
+
+extern const pb_msgdesc_t readgroup_v1_ReadGroup_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_v1_ReadGroup_fields &readgroup_v1_ReadGroup_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_v1_ReadGroup_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/v1/service.pb.c

@@ -0,0 +1,9 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/v1/service.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+

vendor/protobuf/readgroup/v1/service.pb.h

@@ -0,0 +1,22 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_V1_READGROUP_V1_SERVICE_PB_H_INCLUDED
+#define PB_READGROUP_V1_READGROUP_V1_SERVICE_PB_H_INCLUDED
+#include <pb.h>
+#include "readgroup/v1/export.pb.h"
+#include "readgroup/v1/get.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

vendor/protobuf/readgroup/v2/end.pb.c

@@ -0,0 +1,23 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.9 */
+
+#include "readgroup/v2/end.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(readgroup_v2_EndReadGroupRequest, readgroup_v2_EndReadGroupRequest, AUTO)
+
+
+PB_BIND(readgroup_v2_EndReadGroupResponse, readgroup_v2_EndReadGroupResponse, AUTO)
+
+
+
+#ifndef PB_CONVERT_DOUBLE_FLOAT
+/* On some platforms (such as AVR), double is really float.
+ * To be able to encode/decode double on these platforms, you need.
+ * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
+ */
+PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
+#endif
+

vendor/protobuf/readgroup/v2/end.pb.h

@@ -0,0 +1,96 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.9 */
+
+#ifndef PB_READGROUP_V2_READGROUP_V2_END_PB_H_INCLUDED
+#define PB_READGROUP_V2_READGROUP_V2_END_PB_H_INCLUDED
+#include <pb.h>
+#include "google/protobuf/timestamp.pb.h"
+#include "util/uuid.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _readgroup_v2_EndReadGroupRequest {
+    bool has_group_id;
+    util_UUID group_id;
+    bool has_reader_id;
+    util_UUID reader_id;
+    uint32_t antenna;
+    pb_callback_t epc;
+    bool has_timestamp;
+    google_protobuf_Timestamp timestamp;
+    int32_t peak_rssi;
+    double skew_rssi;
+    double variance_rssi;
+    double entropy_rssi;
+    pb_callback_t signals;
+} readgroup_v2_EndReadGroupRequest;
+
+typedef struct _readgroup_v2_EndReadGroupResponse {
+    char dummy_field;
+} readgroup_v2_EndReadGroupResponse;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define readgroup_v2_EndReadGroupRequest_init_default {false, util_UUID_init_default, false, util_UUID_init_default, 0, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_default, 0, 0, 0, 0, {{NULL}, NULL}}
+#define readgroup_v2_EndReadGroupResponse_init_default {0}
+#define readgroup_v2_EndReadGroupRequest_init_zero {false, util_UUID_init_zero, false, util_UUID_init_zero, 0, {{NULL}, NULL}, false, google_protobuf_Timestamp_init_zero, 0, 0, 0, 0, {{NULL}, NULL}}
+#define readgroup_v2_EndReadGroupResponse_init_zero {0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define readgroup_v2_EndReadGroupRequest_group_id_tag 1
+#define readgroup_v2_EndReadGroupRequest_reader_id_tag 2
+#define readgroup_v2_EndReadGroupRequest_antenna_tag 3
+#define readgroup_v2_EndReadGroupRequest_epc_tag 4
+#define readgroup_v2_EndReadGroupRequest_timestamp_tag 5
+#define readgroup_v2_EndReadGroupRequest_peak_rssi_tag 6
+#define readgroup_v2_EndReadGroupRequest_skew_rssi_tag 7
+#define readgroup_v2_EndReadGroupRequest_variance_rssi_tag 8
+#define readgroup_v2_EndReadGroupRequest_entropy_rssi_tag 9
+#define readgroup_v2_EndReadGroupRequest_signals_tag 10
+
+/* Struct field encoding specification for nanopb */
+#define readgroup_v2_EndReadGroupRequest_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  group_id,          1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  reader_id,         2) \
+X(a, STATIC,   SINGULAR, UINT32,   antenna,           3) \
+X(a, CALLBACK, SINGULAR, STRING,   epc,               4) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  timestamp,         5) \
+X(a, STATIC,   SINGULAR, SINT32,   peak_rssi,         6) \
+X(a, STATIC,   SINGULAR, DOUBLE,   skew_rssi,         7) \
+X(a, STATIC,   SINGULAR, DOUBLE,   variance_rssi,     8) \
+X(a, STATIC,   SINGULAR, DOUBLE,   entropy_rssi,      9) \
+X(a, CALLBACK, REPEATED, UINT32,   signals,          10)
+#define readgroup_v2_EndReadGroupRequest_CALLBACK pb_default_field_callback
+#define readgroup_v2_EndReadGroupRequest_DEFAULT NULL
+#define readgroup_v2_EndReadGroupRequest_group_id_MSGTYPE util_UUID
+#define readgroup_v2_EndReadGroupRequest_reader_id_MSGTYPE util_UUID
+#define readgroup_v2_EndReadGroupRequest_timestamp_MSGTYPE google_protobuf_Timestamp
+
+#define readgroup_v2_EndReadGroupResponse_FIELDLIST(X, a) \
+
+#define readgroup_v2_EndReadGroupResponse_CALLBACK NULL
+#define readgroup_v2_EndReadGroupResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t readgroup_v2_EndReadGroupRequest_msg;
+extern const pb_msgdesc_t readgroup_v2_EndReadGroupResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define readgroup_v2_EndReadGroupRequest_fields &readgroup_v2_EndReadGroupRequest_msg
+#define readgroup_v2_EndReadGroupResponse_fields &readgroup_v2_EndReadGroupResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* readgroup_v2_EndReadGroupRequest_size depends on runtime parameters */
+#define readgroup_v2_EndReadGroupResponse_size   0
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif