├── .dockerignore
├── .github
    ├── Contributing.md
    ├── PULL_REQUEST_TEMPLATE.md
    ├── dependabot.yml
    ├── semantic.yml
    └── workflows
    │   └── release.yml
├── .gitignore
├── .golangci.yml
├── Attribution.txt
├── CHANGELOG.md
├── Dockerfile
├── GOVERNANCE.md
├── Jenkinsfile
├── LICENSE
├── Makefile
├── OWNERS.md
├── README.md
├── bin
    ├── auto-configure.sh
    └── test-attribution-txt.sh
├── cmd
    ├── llrp
    │   └── llrp.go
    ├── main.go
    └── res
    │   ├── configuration.yaml
    │   ├── profiles
    │       ├── llrp.device.profile.yaml
    │       └── llrp.impinj.profile.yaml
    │   └── provision_watchers
    │       ├── impinj.provision.watcher.yaml
    │       └── llrp.provision.watcher.yaml
├── examples
    ├── AccessSpec.json
    ├── ImpinjCap.json
    ├── ImpinjEnableCustomExt.json
    ├── ImpinjReadFast.json
    ├── ImpinjReaderConf.json
    ├── ImpinjStaticSuppress.json
    ├── ROSpec.json
    ├── ReaderConfig.json
    ├── command.sh
    ├── data.sh
    ├── example.sh
    ├── impinjCustomConfReq.json
    └── readImpinjTID.sh
├── go.mod
├── go.sum
├── images
    └── delete_consul.png
├── internal
    ├── driver
    │   ├── config.go
    │   ├── config_test.go
    │   ├── device.go
    │   ├── discover.go
    │   ├── discover_test.go
    │   ├── driver.go
    │   ├── driver_test.go
    │   ├── logging.go
    │   ├── types.go
    │   └── types_string.go
    └── retry
    │   ├── retry.go
    │   └── retry_test.go
├── pkg
    └── llrp
    │   ├── LLRPMsgStructure.pdf
    │   ├── binary_test.go
    │   ├── generate_param_code.py
    │   ├── generated_encoder.go
    │   ├── generated_marshal.go
    │   ├── generated_structs.go
    │   ├── generated_unmarshal.go
    │   ├── hacking_with_llrp.md
    │   ├── messages.go
    │   ├── messages.yaml
    │   ├── msg_builder.go
    │   ├── params.go
    │   ├── params_test.go
    │   ├── paramtype_string.go
    │   ├── reader.go
    │   ├── reader_data_test.go
    │   ├── reader_functional_test.go
    │   ├── reader_test.go
    │   ├── test_emulator.go
    │   ├── test_helpers.go
    │   ├── testdata
    │       ├── CloseConnectionResponse-000.bytes
    │       ├── CloseConnectionResponse-000.json
    │       ├── GetAccessSpecsResponse-000.bytes
    │       ├── GetAccessSpecsResponse-000.json
    │       ├── GetROSpecsResponse-000.bytes
    │       ├── GetROSpecsResponse-000.json
    │       ├── GetReaderCapabilitiesResponse-000.bytes
    │       ├── GetReaderCapabilitiesResponse-000.json
    │       ├── GetReaderConfigResponse-000.bytes
    │       ├── GetReaderConfigResponse-000.json
    │       ├── ReaderEventNotification-000.bytes
    │       ├── ReaderEventNotification-000.json
    │       └── roAccessReports
    │       │   ├── ROAccessReport-001.bytes
    │       │   ├── ROAccessReport-001.json
    │       │   ├── ROAccessReport-002.bytes
    │       │   ├── ROAccessReport-002.json
    │       │   ├── ROAccessReport-003.bytes
    │       │   ├── ROAccessReport-003.json
    │       │   ├── ROAccessReport-004.bytes
    │       │   ├── ROAccessReport-004.json
    │       │   ├── ROAccessReport-005.bytes
    │       │   ├── ROAccessReport-005.json
    │       │   ├── ROAccessReport-006.bytes
    │       │   ├── ROAccessReport-006.json
    │       │   ├── ROAccessReport-007.bytes
    │       │   ├── ROAccessReport-007.json
    │       │   ├── ROAccessReport-008.bytes
    │       │   ├── ROAccessReport-008.json
    │       │   ├── ROAccessReport-009.bytes
    │       │   └── ROAccessReport-009.json
    │   └── versionnum_string.go
└── version.go


/.dockerignore:
--------------------------------------------------------------------------------
 1 | go.sum
 2 | docker-compose*.yml
 3 | coverage.out
 4 | .idea
 5 | .gitignore
 6 | Dockerfile*
 7 | .dockerignore
 8 | .git
 9 | .gitignore
10 | .env
11 | */bin
12 | */obj
13 | README.md
14 | .vscode
15 | 


--------------------------------------------------------------------------------
/.github/Contributing.md:
--------------------------------------------------------------------------------
 1 | ## <a name="commit"></a> Commit Message Guidelines
 2 | 
 3 | We have very precise rules over how our git commit messages can be formatted.  This leads to **more readable messages** that are easy to follow when looking through the **project history**. For full contribution guidelines visit
 4 | the [Contributors Guide](https://wiki.edgexfoundry.org/display/FA/Committing+Code+Guidelines#CommittingCodeGuidelines-Commits) on the EdgeX Wiki
 5 | 
 6 | ### Commit Message Format
 7 | Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special format that includes a **type**, a **scope** and a **subject**:
 8 | 
 9 | ```
10 | <type>(<scope>): <subject>
11 | <BLANK LINE>
12 | <body>
13 | <BLANK LINE>
14 | <footer>
15 | ```
16 | 
17 | The **header** with **type** is mandatory.  The **scope** of the header is optional as far as the automated PR checks are concerned, but be advised that PR reviewers **may request** you provide an applicable scope.
18 | 
19 | Any line of the commit message cannot be longer 100 characters! This allows the message to be easier to read on GitHub as well as in various git tools.
20 | 
21 | The footer should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.
22 | 
23 | Example 1:
24 | ```
25 | build(deploy): add K3s deployment example
26 | ```
27 | ```
28 | fix(app): correct app service configurable logging
29 | 
30 | Previously remote logging failed due to improper initialization of the logging client. This commit fixes the initialization to properly support remote logging.
31 | 
32 | Closes: #123
33 | ```
34 | 
35 | ### Revert
36 | If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body it should say: `This reverts commit <hash>.`, where the hash is the SHA of the commit being reverted.
37 | 
38 | ### Type
39 | Must be one of the following:
40 | 
41 | * **feat**: A new feature
42 | * **fix**: A bug fix
43 | * **docs**: Documentation only changes
44 | * **style**: Changes that do not affect the meaning of the code (white-space, formatting, etc)
45 | * **refactor**: A code change that neither fixes a bug nor adds a feature
46 | * **perf**: A code change that improves performance
47 | * **test**: Adding missing tests or correcting existing tests
48 | * **build**: Changes that affect the CI/CD pipeline or build system or external dependencies (example scopes: travis, jenkins, makefile)
49 | * **ci**: Changes provided by DevOps for CI purposes.
50 | * **revert**: Reverts a previous commit.
51 | 
52 | ### Subject
53 | The subject contains a succinct description of the change:
54 | 
55 | * use the imperative, present tense: "change" not "changed" nor "changes"
56 | * don't capitalize the first letter
57 | * no dot (.) at the end
58 | 
59 | ### Body
60 | Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
61 | The body should include the motivation for the change and contrast this with previous behavior.
62 | 
63 | ### Footer
64 | The footer should contain any information about **Breaking Changes** and is also the place to
65 | reference GitHub issues that this commit **Closes**.
66 | 
67 | **Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.
68 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | <!-- Expected Commit Message Description (imported automatically by GitHub) -->
 2 | <!-- Must conform to [conventional commits guidelines](https://github.com/edgexfoundry/device-rfid-llrp-go/blob/main/.github/Contributing.md) -->
 3 | <!-- Expected Commit message must contain Closes/Fixes #IssueNumber statement when there is a related issue -->
 4 | 
 5 | <!-- Add additional detailed description of need for change if no related issue -->
 6 | 
 7 | **If your build fails** due to your commit message not passing the build checks, please review the guidelines here: https://github.com/edgexfoundry/device-rfid-llrp-go/blob/main/.github/Contributing.md
 8 | 
 9 | ## PR Checklist
10 | Please check if your PR fulfills the following requirements:
11 | 
12 | - [ ] I am not introducing a breaking change (if you are, flag in conventional commit message with `BREAKING CHANGE:` describing the break)
13 | - [ ] I am not introducing a new dependency (add notes below if you are)
14 | - [ ] I have added unit tests for the new feature or bug fix (if not, why?)
15 | - [ ] I have fully tested (add details below) this the new feature or bug fix (if not, why?)
16 | - [ ] I have opened a PR for the related docs change (if not, why?)
17 |   <link to docs PR>
18 | 
19 | ## Testing Instructions
20 | <!-- How can the reviewers test your change? -->
21 | 
22 | ## New Dependency Instructions (If applicable)
23 | <!-- Please follow [vetting instructions](https://wiki.edgexfoundry.org/display/FA/Vetting+Process+for+3rd+Party+Dependencies) and place results here -->


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | updates:
 3 | 
 4 |   # Maintain dependencies for GitHub Actions
 5 |   - package-ecosystem: "gomod"
 6 |     directory: "/"
 7 |     schedule:
 8 |       interval: "daily"
 9 |     ignore:
10 |       - dependency-name: "github.com/edgexfoundry/go-mod-core-contracts/v4"
11 |         # Included when device-sdk-go is updated
12 |       - dependency-name: "github.com/edgexfoundry/go-mod-messaging/v4"
13 |         # Included when device-sdk-go is updated
14 |       - dependency-name: "github.com/edgexfoundry/go-mod-registry/v4"
15 |         # Included when device-sdk-go is updated
16 |       - dependency-name: "github.com/edgexfoundry/go-mod-secrets/v4"
17 |         # Included when device-sdk-go is updated
18 |       - dependency-name: "github.com/edgexfoundry/go-mod-bootstrap/v3"
19 |         # Included when device-sdk-go is updated      
20 | 
21 | 


--------------------------------------------------------------------------------
/.github/semantic.yml:
--------------------------------------------------------------------------------
 1 | allowMergeCommits: true
 2 | # Always validate the PR title AND all the commits
 3 | titleAndCommits: true
 4 | types:
 5 |   - feat
 6 |   - fix
 7 |   - docs
 8 |   - style
 9 |   - refactor
10 |   - perf
11 |   - test
12 |   - build
13 |   - ci
14 |   - revert


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Create Release
 2 | on:
 3 |   push:
 4 |     tags:
 5 |       - 'v*.*.*'
 6 |       - '!v*-dev*'
 7 | jobs:
 8 |   release:
 9 |     uses: edgexfoundry/edgex-global-pipelines/.github/workflows/release.yml@stable
10 |     permissions:
11 |       contents: write


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Binaries for programs and plugins
 2 | *.exe
 3 | *.exe~
 4 | *.dll
 5 | *.so
 6 | *.dylib
 7 | 
 8 | # Test binary, build with `go test -c`
 9 | *.test
10 | 
11 | # Profiling results
12 | *.prof
13 | 
14 | # Output of the go coverage tool, specifically when used with LiteIDE
15 | *.out
16 | 
17 | *.log
18 | 
19 | .idea/
20 | vendor/
21 | cmd/device-rfid-llrp
22 | glide.lock
23 | 
24 | coverage.out
25 | VERSION
26 | 
27 | # Very Important: This line is needed to keep your credentials from being checked into github.
28 | **/.env
29 | 
30 | # Binaries for programs and plugins
31 | main
32 | DEVNULL
33 | 
34 | test.txt
35 | .vscode/*# Output of the go coverage tool, specifically when used with LiteIDE
36 | logs/*
37 | logs/
38 | 
39 | #Do not include any python cache or compiled files
40 | **/*.pyc
41 | **/__pycache__
42 | venv
43 | 
44 | #Skip the reports generated by robot
45 | **/reports
46 | **/*.xml
47 | **/*.html
48 | 
49 | # Don't save _every_ RO report
50 | internal/llrp/testdata/**/*.json
51 | internal/llrp/testdata/**/*.bytes
52 | !internal/llrp/testdata/roAccessReports/*-00?*
53 | 
54 | #do not track vscode
55 | .vscode/*
56 | 


--------------------------------------------------------------------------------
/.golangci.yml:
--------------------------------------------------------------------------------
 1 | linters:
 2 |   disable:
 3 |   enable:
 4 |     - gosec
 5 | linters-settings:
 6 |   gosec:
 7 |     excludes:
 8 |       # G115: integer overflow conversion
 9 |       # exclude the rule since it tends to be false positive
10 |       - G115
11 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Device RFID LLRP
  2 | 
  3 | ## Change Logs for EdgeX Dependencies
  4 | 
  5 | - [device-sdk-go](https://github.com/edgexfoundry/device-sdk-go/blob/main/CHANGELOG.md)
  6 | - [go-mod-core-contracts](https://github.com/edgexfoundry/go-mod-core-contracts/blob/main/CHANGELOG.md)
  7 | - [go-mod-bootstrap](https://github.com/edgexfoundry/go-mod-bootstrap/blob/main/CHANGELOG.md)  (indirect dependency)
  8 | - [go-mod-messaging](https://github.com/edgexfoundry/go-mod-messaging/blob/main/CHANGELOG.md) (indirect dependency)
  9 | - [go-mod-registry](https://github.com/edgexfoundry/go-mod-registry/blob/main/CHANGELOG.md)  (indirect dependency)
 10 | - [go-mod-secrets](https://github.com/edgexfoundry/go-mod-secrets/blob/main/CHANGELOG.md) (indirect dependency)
 11 | - [go-mod-configuration](https://github.com/edgexfoundry/go-mod-configuration/blob/main/CHANGELOG.md) (indirect dependency)
 12 | 
 13 | ## [4.0.0] Odessa - 2025-03-12 (Only compatible with the 4.x releases)
 14 | 
 15 | ### ✨  Features
 16 | 
 17 | - Enable PIE support for ASLR and full RELRO ([be40ce9…](https://github.com/edgexfoundry/device-rest-go/commit/be40ce9c5fc91884215293b6bf7bbda8bd3c0d2f))
 18 | 
 19 | ### ♻ Code Refactoring
 20 | 
 21 | - Allow the LLRP package to be imported by others ([14e8eb7…](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/14e8eb7d7f4eee0b29d9e816e25ce3adc8d21199)) 
 22 | - Update module to v4 ([6bfdd3f…](https://github.com/edgexfoundry/device-rest-go/commit/6bfdd3ff5f3e792eafad2b4c95b01495d5837e2e))
 23 | ```text
 24 | BREAKING CHANGE: update go module to v4
 25 | ```
 26 | 
 27 | ### 🐛 Bug Fixes
 28 | 
 29 | - Only one ldflags flag is allowed ([ec1ec23…](https://github.com/edgexfoundry/device-rest-go/commit/ec1ec23295ae906f939fdcce9f1e5a4eef1babde))
 30 | 
 31 | ### 👷 Build
 32 | 
 33 | - Upgrade to go-1.23, Linter1.61.0 and Alpine 3.20 ([21d3830…](https://github.com/edgexfoundry/device-rest-go/commit/21d3830f1720a37f1895b62ff4ca15d755f1aed1))
 34 | 
 35 | ## [v3.1.0] Napa - 2023-11-15 (Only compatible with the 3.x releases)
 36 | 
 37 | 
 38 | ### ✨  Features
 39 | 
 40 | - Remove snap packaging ([#261](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/261)) ([ec76fef…](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/ec76fefacd564d5a805f4b6ee2c3fdcc17777694))
 41 | ```text
 42 | 
 43 | BREAKING CHANGE: Remove snap packaging ([#261](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/261))
 44 | 
 45 | ```
 46 | 
 47 | 
 48 | ### ♻ Code Refactoring
 49 | 
 50 | - Remove obsolete comments from config file ([#263](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/263)) ([a457c92…](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/a457c9218e2f2d18d865ffb73302d735402b2cfc))
 51 | - Replace github.com/pkg/errors with errors ([d9392d6…](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/d9392d64b2716c69a3fa73cacae0ad3d93159cfa))
 52 | 
 53 | 
 54 | ### 👷 Build
 55 | 
 56 | - Upgrade to go-1.21, Linter1.54.2 and Alpine 3.18 ([#249](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/249)) ([40e7fd9…](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/40e7fd9457312c7ba73491b63d6fc33ef6c19e69))
 57 | 
 58 | 
 59 | ### 🤖 Continuous Integration
 60 | 
 61 | - Add automated release workflow on tag creation ([c07abfb…](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/c07abfb52c8088b08d188c7a5744e77525c2764f))
 62 | 
 63 | 
 64 | ## [v3.0.0] Minnesota - 2023-05-31 (Only compatible with the 3.x releases)
 65 | 
 66 | ### Features ✨
 67 | 
 68 | - Consume SDK interface changes ([#b1a5b18](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/b1a5b18c40bc5298787db029b48d6f2a66d57e4a))
 69 |   ```text
 70 |   BREAKING CHANGE: Consume SDK interface changes by adding Discover and ValidateDevice func on driver
 71 |   ```
 72 | - Updates for common config ([#41aa6f5](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/41aa6f5707b2967661adaa3bff727b563a777840))
 73 |   ```text
 74 |   BREAKING CHANGE: configuration file changed to remove common config settings
 75 |   ```
 76 | - Remove ZeroMQ MessageBus capability ([#ca5f12e](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/ca5f12e3f5b0dcc2e9f99ab405ce0dc1158ea6a8))
 77 |   ```text
 78 |   BREAKING CHANGE: ZeroMQ MessageBus capability no longer available
 79 |   ```
 80 | 
 81 | ### Bug Fixes 🐛
 82 | 
 83 | - Move initialization of registered llrp devices from initialize to start ([#236](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/236)) ([#d994045](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/d994045))
 84 | - Add missing 3rd party go-winio for attribution.txt to pass make test ([#051e4cb](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/051e4cb))
 85 | - **snap:** Refactor to avoid conflicts with readonly config provider directory ([#189](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/189)) ([#56ebd08](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/56ebd08))
 86 | 
 87 | ### Code Refactoring ♻
 88 | 
 89 | - Change configuration and provision watcher file formats to YAML ([#a41d6dc](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/a41d6dc477aab60bbffd9796b8b3bd1f25c661ce))
 90 |   ```text
 91 |   BREAKING CHANGE: Configuration and Provision Watcher files now uses YAML format
 92 |   ```
 93 | - Replace internal topics from config with new constants ([#6afc6be](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/6afc6bebc55851e438483997c27c526932a4a7b3))
 94 |   ```text
 95 |   BREAKING CHANGE: Internal topics no longer configurable, except the base topic.
 96 |   ```
 97 | - Rework code for refactored MessageBus Configuration ([#b3638b7](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/b3638b72d5666b5d505fc5b42b31027c44889b0a))
 98 |   ```text
 99 |   BREAKING CHANGE: MessageQueue renamed to MessageBus and fields changed. See v3 Migration guide.
100 |   ```
101 | - Rename command line flags for the sake of consistency ([#67743ce](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/67743ce73b5f11851f5a3332a1e6bc4b63a9e69f))
102 |   ```text
103 |   BREAKING CHANGE: renamed -c/--confdir to -cd/--configDirand -f/--file to -cf/--configFile
104 |   ```
105 | - Use latest SDK for flattened config stem ([#604c686](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/604c68618d9d9b7225b2b59984522e40f548fc27))
106 |   ```text
107 |   BREAKING CHANGE: location of service configuration in Consul changed; Also required updating for v3 modules
108 |   ```
109 | 
110 | - Rename toml references to yaml ([#195](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/195)) ([#2ab1936](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/2ab1936))
111 | - Consume latest SDK and adjust for breaking change ([#227](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/227)) ([#1e3cba0](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/1e3cba0))
112 | - Consume Provision Watcher changes for running multiple instances ([#225](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/225)) ([#e4a020d](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/e4a020d))
113 | - Remove code that loads static provision watchers ([#152](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/152)) ([#c8ddb79](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/c8ddb79))
114 | - **snap:** Drop the support for legacy snap env options ([#963987e](https://github.com/edgexfoundry/device-rfid-llrp-go/commit/963987e627e8dcac0df49593e42f1bbbca2c5392))
115 |   ```text
116 |   BREAKING CHANGE: Drop the support for deprecated snap options starting with `env.`
117 |   ```
118 | - **snap:** Update command and metadata sourcing ([#185](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/185)) ([#8c4faf2](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/8c4faf2))
119 | 
120 | ### Build 👷
121 | 
122 | - Update to Go 1.20, Alpine 3.17 and linter v1.51.2 ([#cd71eb7](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/cd71eb7))
123 | - Ignore all go-mods except device-sdk-go ([#95fcffc](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/95fcffc))
124 | 
125 | ## [v2.3.0] - Levski - 2022-11-09  (Only compatible with the 2.x releases)
126 | 
127 | ### Features ✨
128 | 
129 | - Add NATS and Service Metrics configuration ([#119](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/119)) ([#f6bccf3](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/f6bccf3))
130 | - Add commanding via message configuration ([#7fd8555](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/7fd8555))
131 | - Add make target to build with NATS capability ([#a67b182](https://github.com/edgexfoundry/device-rfid-llrp-go/pull/120/commits/a67b182))
132 | - **snap:** add config interface with unique identifier ([#114](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/114)) ([#21adccc](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/21adccc))
133 | 
134 | ### Code Refactoring ♻
135 | 
136 | - Service wrapper was removed as it has been rolled into the DeviceServiceSDK interface ([#104](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/104)) ([#0476de2](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/0476de2))
137 | - **snap:** edgex-snap-hooks related upgrade ([#101](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/101)) ([#5edf930](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/5edf930))
138 | 
139 | ### Build 👷
140 | 
141 | - Upgrade to Go 1.18 and optimize attribution script ([#98](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/98)) ([#a486f61](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/a486f61))
142 | 
143 | 
144 | 
145 | ## [v2.2.0] - Kamakura - 2022-05-11  (Only compatible with the 2.x releases)
146 | 
147 | ### Features ✨
148 | 
149 | - Update to latest go-mod-messaging w/o ZMQ on windows ([#a222f54](https://github.com/edgexfoundry/device-sdk-go/commits/a222f54))
150 | 
151 |   ```
152 |   BREAKING CHANGE:
153 |   ZeroMQ no longer supported on native Windows for EdgeX
154 |   MessageBus
155 |   ```
156 | 
157 | ## [v2.1.0] Jakarta - 2022-04-27  (Only compatible with the 2.x releases)
158 | ### Features ✨
159 | - Migrate service to V2 ([#52](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/52)) ([#60419ad](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/60419ad))
160 | - added CORS configuration to service section in configuration TOML ([#67](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/67)) ([#e0db465](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/e0db465))
161 | ### Test
162 | - **snap:** add snap CI workflow ([#73](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/73)) ([#8b44d22](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/8b44d22))
163 | ### Bug Fixes 🐛
164 | - updated inventory_service link from https://github.com/edgexfoundry-holding/rfid-llrp-inventory-service to https://github.com/edgexfoundry/app-rfid-llrp-inventory ([#76](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/76)) ([#8fb081e](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/8fb081e))
165 | - misuse of unbuffered os.Signal channel error ([#56](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/56)) ([#2631263](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/2631263))
166 | ### Build 👷
167 | - update alpine base to 3.14 ([#49](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/49)) ([#e0ebc7e](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/e0ebc7e))
168 | - Added "make lint" to target and added it to make test. Resolved all lint errors as well ([#60](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/60)) ([#fdb8dc9](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/fdb8dc9))
169 | 
170 | <a name="v1.0.0"></a>
171 | ## [v1.0.0] - 2021-08-20 (Only Compatible with 1.x releases)
172 | ### Feature
173 | - **discover:** trigger debounced discovery on consul config change ([#35](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/35)) ([#8772bf5](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/8772bf5))
174 | ### Bug Fixes 🐛
175 | - update all TOML to use quote and not single-quote ([#46](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/46)) ([#8818edd](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/8818edd))
176 | - Disable UpdateLastConnected in toml file ([#45](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/45)) ([#2489b51](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/2489b51))
177 | - use provision watcher logic for discovered devices ([#42](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/42)) ([#a792bd6](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/a792bd6))
178 | - invalid boolean logic in UpdateDevice code ([#41](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/41)) ([#b1162a6](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/b1162a6))
179 | - **config:** Add CheckInterval to toml file for registry ([#37](https://github.com/edgexfoundry/device-rfid-llrp-go/issues/37)) ([#13be571](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/13be571))
180 | - **url:** remove holding suffix from module url ([#b528ca6](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/b528ca6))
181 | ### Documentation 📖
182 | - Add badges to readme ([#84d0a8d](https://github.com/edgexfoundry/device-rfid-llrp-go/commits/84d0a8d))
183 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | #
 2 | # Copyright (c) 2023 Intel Corporation
 3 | # Copyright (c) 2024 IOTech Ltd
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #      http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | #
17 | 
18 | ARG BASE=golang:1.23-alpine3.20
19 | FROM ${BASE} AS builder
20 | 
21 | ARG ADD_BUILD_TAGS=""
22 | ARG MAKE="make -e ADD_BUILD_TAGS=$ADD_BUILD_TAGS build"
23 | ARG ALPINE_PKG_BASE="make git"
24 | ARG ALPINE_PKG_EXTRA=""
25 | 
26 | RUN apk add --no-cache ${ALPINE_PKG_BASE} ${ALPINE_PKG_EXTRA}
27 | 
28 | WORKDIR /app
29 | 
30 | COPY go.mod vendor* ./
31 | RUN [ ! -d "vendor" ] && go mod download all || echo "skipping..."
32 | 
33 | COPY . .
34 | RUN $MAKE
35 | 
36 | FROM alpine:3.20
37 | 
38 | LABEL license='SPDX-License-Identifier: Apache-2.0' \
39 |   copyright='Copyright (c) 2023: Intel'
40 | 
41 | RUN apk add --update --no-cache dumb-init
42 | # Ensure using latest versions of all installed packages to avoid any recent CVEs
43 | RUN apk --no-cache upgrade
44 | 
45 | COPY --from=builder /app/LICENSE /
46 | COPY --from=builder /app/Attribution.txt /
47 | COPY --from=builder /app/cmd/ /
48 | 
49 | EXPOSE 59989
50 | 
51 | ENTRYPOINT ["/device-rfid-llrp"]
52 | CMD ["-cp=keeper.http://edgex-core-keeper:59890", "--registry"]
53 | 


--------------------------------------------------------------------------------
/GOVERNANCE.md:
--------------------------------------------------------------------------------
1 | # Governance
2 | 
3 | Project governance as well as policies, procedures and instructions for contributing to EdgeX Foundry can be found on our Wiki site at the following locations:
4 | 
5 | - [EdgeX Technical Steering Committee](https://wiki.edgexfoundry.org/pages/viewpage.action?pageId=329436)
6 | - [Contributor's Guide](https://wiki.edgexfoundry.org/display/FA/Contributor%27s+Guide)
7 | - [Contributor's Process](https://wiki.edgexfoundry.org/display/FA/Contributor%27s+Process)
8 | - [Technical Work](https://wiki.edgexfoundry.org/display/FA/Technical+Work+in+the+EdgeX+Foundry+Project)
9 | - [Contributors, Committers & Maintainers](https://wiki.edgexfoundry.org/pages/viewpage.action?pageId=21823860)


--------------------------------------------------------------------------------
/Jenkinsfile:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (c) 2020 Intel Corporation
 3 | //
 4 | // Licensed under the Apache License, Version 2.0 (the "License");
 5 | // you may not use this file except in compliance with the License.
 6 | // You may obtain a copy of the License at
 7 | //
 8 | //      http://www.apache.org/licenses/LICENSE-2.0
 9 | //
10 | // Unless required by applicable law or agreed to in writing, software
11 | // distributed under the License is distributed on an "AS IS" BASIS,
12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | // See the License for the specific language governing permissions and
14 | // limitations under the License.
15 | //
16 | 
17 | edgeXBuildGoApp (
18 |     project: 'device-rfid-llrp-go'
19 | )
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright 2020 Intel Corporation.
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |       http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | .PHONY: build test unittest lint clean prepare update docker
 2 | 
 3 | # change the following boolean flag to enable or disable the Full RELRO (RELocation Read Only) for linux ELF (Executable and Linkable Format) binaries
 4 | ENABLE_FULL_RELRO=true
 5 | # change the following boolean flag to enable or disable PIE for linux binaries which is needed for ASLR (Address Space Layout Randomization) on Linux, the ASLR support on Windows is enabled by default
 6 | ENABLE_PIE=true
 7 | 
 8 | ARCH=$(shell uname -m)
 9 | 
10 | MICROSERVICES=cmd/device-rfid-llrp
11 | 
12 | .PHONY: $(MICROSERVICES)
13 | 
14 | # This pulls the version of the SDK from the go.mod file. It works by looking for the line
15 | # with the SDK and printing just the version number that comes after it.
16 | SDKVERSION=$(shell sed -En 's|.*github.com/edgexfoundry/device-sdk-go/v4 (v[\.0-9a-zA-Z-]+).*|\1|p' go.mod)
17 | 
18 | # this pulls the version from local VERSION file that is created by the Jenkins Pipeline.
19 | VERSION=$(shell cat ./VERSION 2>/dev/null || echo 0.0.0)
20 | 
21 | ifeq ($(ENABLE_FULL_RELRO), true)
22 | 	ENABLE_FULL_RELRO_GOFLAGS = -bindnow
23 | endif
24 | 
25 | GIT_SHA=$(shell git rev-parse HEAD)
26 | GOFLAGS=-ldflags "-X github.com/edgexfoundry/device-rfid-llrp-go.Version=$(VERSION) \
27 |                   -X github.com/edgexfoundry/device-sdk-go/v4/internal/common.SDKVersion=$(SDKVERSION) \
28 |                   $(ENABLE_FULL_RELRO_GOFLAGS)" \
29 |                    -trimpath -mod=readonly
30 | 
31 | ifeq ($(ENABLE_PIE), true)
32 | 	GOFLAGS += -buildmode=pie
33 | endif
34 | 
35 | build: $(MICROSERVICES)
36 | 
37 | build-nats:
38 | 	make -e ADD_BUILD_TAGS=include_nats_messaging build
39 | 
40 | tidy:
41 | 	go mod tidy
42 | 
43 | cmd/device-rfid-llrp:
44 | 	CGO_ENABLED=0 go build -tags "$(ADD_BUILD_TAGS)" $(GOFLAGS) -o $@ ./cmd
45 | 
46 | unittest:
47 | 	go test ./... -coverprofile=coverage.out ./...
48 | 
49 | lint:
50 | 	@which golangci-lint >/dev/null || echo "WARNING: go linter not installed. To install, run make install-lint"
51 | 	@if [ "z${ARCH}" = "zx86_64" ] && which golangci-lint >/dev/null ; then golangci-lint run --config .golangci.yml ; else echo "WARNING: Linting skipped (not on x86_64 or linter not installed)"; fi
52 | 
53 | install-lint:
54 | 	sudo curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $$(go env GOPATH)/bin v1.61.0
55 | 
56 | test: unittest lint
57 | 	go vet ./...
58 | 	gofmt -l $$(find . -type f -name '*.go'| grep -v "/vendor/")
59 | 	[ "`gofmt -l $$(find . -type f -name '*.go'| grep -v "/vendor/")`" = "" ]
60 | 	./bin/test-attribution-txt.sh
61 | 
62 | clean:
63 | 	rm -f $(MICROSERVICES)
64 | 
65 | docker:
66 | 	docker build \
67 | 		--build-arg ADD_BUILD_TAGS=$(ADD_BUILD_TAGS) \
68 | 		--build-arg http_proxy \
69 | 		--build-arg https_proxy \
70 | 		--label "git_sha=$(GIT_SHA)" \
71 | 		-t edgexfoundry/device-rfid-llrp:$(GIT_SHA) \
72 | 		-t edgexfoundry/device-rfid-llrp:$(VERSION)-dev \
73 | 		.
74 | 
75 | docker-nats:
76 | 	make -e ADD_BUILD_TAGS=include_nats_messaging docker
77 | 
78 | vendor:
79 | 	CGO_ENABLED=0 go mod vendor
80 | 


--------------------------------------------------------------------------------
/OWNERS.md:
--------------------------------------------------------------------------------
1 | # Repository Owners
2 | 
3 | This repository is managed by the EdgeX Device Services Working Group.  As such, the **Device Services Working Group** chairman is considered the "owner" of the repository and approves all committers of the repository.
4 | 
5 | See the [project Wiki TSC page](https://wiki.edgexfoundry.org/pages/viewpage.action?pageId=329436#TechnicalSteeringCommittee(TSC)-WorkingGroups) for information on the current EdgeX TSC and who occupies the role of Device Service Working Group chair.
6 | 
7 | For a complete list of current committers see:  https://github.com/orgs/edgexfoundry/teams/device-rfid-llrp-go-committers/members.
8 | 
9 | 


--------------------------------------------------------------------------------
/bin/auto-configure.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | 
  3 | #
  4 | # Copyright (C) 2020-2021 Intel Corporation
  5 | #
  6 | # SPDX-License-Identifier: Apache-2.0
  7 | #
  8 | 
  9 | #
 10 | # The purpose of this script is to make it easier for an end user to configure LLRP device discovery
 11 | # without the need to have knowledge about subnets and/or CIDR format. The "DiscoverySubnets" config
 12 | # option defaults to blank in the configuration.yaml file, and needs to be provided before a discovery can occur.
 13 | # This allows the LLRP device service to be run in a NAT-ed environment without host-mode networking because the subnet information
 14 | # is user-provided and does not rely on the device-rfid-llrp service to detect it.
 15 | #
 16 | # Essentially how this script works is it polls the machine it is running on and finds the active subnet for
 17 | # any and all network interfaces that are on the machine which are physical (non-virtual) and online.
 18 | # It uses this information to automatically fill out the "DiscoverySubnets" configuration option through Consul of a deployed
 19 | # device-rfid-llrp instance.
 20 | #
 21 | # NOTE 1: This script requires EdgeX Consul and the device-rfid-llrp service to have been run before this
 22 | # script will function.
 23 | #
 24 | # NOTE 2: If the "DiscoverySubnets" config is provided via "configuration.yaml" this script does
 25 | # not need to be run.
 26 | #
 27 | 
 28 | set -eu
 29 | 
 30 | # If ran with DEBUG=1, enable bash command tracing
 31 | DEBUG=${DEBUG:-0}
 32 | if [ "${DEBUG}" == "1" ]; then
 33 |     set -x
 34 | fi
 35 | 
 36 | spacing=18; prev_line="\e[1A\e[$((spacing + 2))C"
 37 | green="\e[32m"; red="\e[31m"; clear="\e[0m"; bold="\e[1m"; normal="\e[22;24m"
 38 | 
 39 | trap 'err' ERR
 40 | err() {
 41 |     echo -e "${red}${bold}Failed!${clear}"
 42 |     exit 1
 43 | }
 44 |  
 45 | CONSUL_TOKEN=${1:-""}
 46 | CONSUL_URL=${CONSUL_URL:-http://localhost:8500}
 47 | url="${CONSUL_URL}/v1/kv/edgex/devices/2.0/device-rfid-llrp/AppCustom/DiscoverySubnets"
 48 | 
 49 | 
 50 | ### Dependencies Check
 51 | # Note: trailing ${red} is to colorize red all potential error output from the following commands
 52 | printf "${bold}%${spacing}s${clear}: ...\n${red}" "Dependencies Check"
 53 | if ! type -P curl >/dev/null; then
 54 |     echo -e "${bold}${red}Failed!${normal} Please install ${bold}curl${normal} in order to use this script!${clear}"
 55 |     exit 1
 56 | fi
 57 | echo -e "${prev_line}${green}Success${clear}"
 58 | 
 59 | ### Consul Check
 60 | # Note: trailing ${red} is to colorize red all potential error output from the following commands
 61 | printf "${bold}%${spacing}s${clear}: ...\n${red}" "Consul Check"
 62 | 
 63 | if [ -z $CONSUL_TOKEN ]; then
 64 |     code=$(curl -X GET -w "%{http_code}" -o /dev/null -s "${url}" || echo $?)
 65 | else
 66 |     code=$(curl -X GET -H "X-Consul-Token:$CONSUL_TOKEN" -w "%{http_code}" -o /dev/null -s "${url}" || echo $?)
 67 | fi
 68 | 
 69 | if [ $((code)) -ne 200 ]; then
 70 |     echo -e "${red}${bold}Failed!${normal} curl returned a status code of '${bold}$((code))'${normal}"
 71 |     # Special message for error code 7
 72 |     if [ $((code)) -eq 7 ]; then
 73 |       echo -e "* Error code '7' denotes 'Failed to connect to host or proxy'"
 74 |     fi
 75 |     # Error 404 means it connected to consul but couldn't find the key
 76 |     if [ $((code)) -eq 404 ]; then
 77 |         echo -e "* Have you deployed the ${bold}device-rfid-llrp${normal} service?${clear}"
 78 |     else
 79 |         echo -e "* Is Consul deployed and accessible?${clear}"
 80 |     fi
 81 |     exit $((code))
 82 | fi
 83 | echo -e "${prev_line}${green}Success${clear}"
 84 | 
 85 | ### Detect Interfaces
 86 | printf "${bold}%${spacing}s${clear}: ...\n${red}" "Interfaces"
 87 | # find all online non-virtual network interfaces and print them separated by `|` for regex matching.
 88 | # example output: eno1|eno2|eno3|...|
 89 | # note: a trailing '|' is produced which is removed in a later step
 90 | ifaces=$(
 91 |     find /sys/class/net -mindepth 1 -maxdepth 2   `# list all network interfaces`  \
 92 |         -not -lname '*devices/virtual*'           `# filter out all virtual interfaces` \
 93 |         -execdir grep -q 'up' "{}/operstate" \;   `# ensure interface is online (operstate == up)` \
 94 |         -printf '%f|'                             `# print them separated by | for regex matching`
 95 | )
 96 | 
 97 | if [ -z "${ifaces}" ]; then
 98 |     echo "Error, no online physical network interfaces detected.${clear}"
 99 |     exit 1
100 | fi
101 | echo -e "${prev_line}${clear}${ifaces//|/ }"
102 | 
103 | ### Detect Subnets
104 | printf "${bold}%${spacing}s${clear}: ...\n${red}" "Subnets"
105 | # print all ipv4 subnets, filter for just the ones associated with our physical interfaces,
106 | # grab the unique ones and join them by commas
107 | #
108 | # sed -n followed by "s///p" means find and print (with replacements) only the lines containing a match
109 | # '::-1' strips the last character (trailing |)
110 | # 'eno1|eno2|' becomes "s/ dev (eno1|eno2).+//p"
111 | # (eno1|eno2) is a matched group of possible values (| means OR)
112 | # .+ is a catch all to prevent printing the rest of the line
113 | #
114 | # Example Input:
115 | #   10.0.0.0/24 dev eno1 proto kernel src 10.0.0.212 metric 600
116 | #   192.168.1.0/24 dev eno2 proto kernel src 192.168.1.134 metric 900
117 | #   172.17.0.0/16 dev docker0 proto kernel src 172.17.0.1 linkdown
118 | #
119 | # Example Output:
120 | #   10.0.0.0/24
121 | #   192.168.1.0/24
122 | #
123 | # Explanation:
124 | # - The first line matched the 'eno1' interface, so everything starting from " dev eno1 ..."
125 | #     is stripped out, and we are left with just the subnet (10.0.0.0/24).
126 | # - The second line matched the 'eno2' interface, same process as before and we are left with just the subnet.
127 | # - The third line does not match either interface and is not printed.
128 | 
129 | subnets=$(
130 |     # Print all IPv4 routes, one per line
131 |     ip -4 -o route list scope link |
132 |         # Regex match it against all of our online physical interfaces
133 |         sed -En "s/ dev (${ifaces::-1}).+//p" |
134 |         # Remove [link-local subnet](https://en.wikipedia.org/wiki/Link-local_address) using grep reverse match (-v)
135 |         grep -v "169.254.0.0/16" |
136 |         # Sort and remove potential duplicates
137 |         sort -u |
138 |         # Merge all lines into a single line separated by commas (no trailing ,)
139 |         paste -sd, -
140 | )
141 | 
142 | if [ -z "${subnets}" ]; then
143 |     echo -e "Error, no subnets detected.${clear}"
144 |     exit 1
145 | fi
146 | echo -e "${prev_line}${clear}${subnets}"
147 | 
148 | ### Configure Consul
149 | printf "${bold}%${spacing}s${clear}: ...\n${red}" "Configure"
150 | if [ -z $CONSUL_TOKEN ]; then
151 |     code=$(curl -X PUT --data "${subnets}" -w "%{http_code}" -o /dev/null -s "${url}" || echo $?)
152 | else
153 |     code=$(curl -X PUT -H "X-Consul-Token:$CONSUL_TOKEN" --data "${subnets}" -w "%{http_code}" -o /dev/null -s "${url}" || echo $?)
154 | fi
155 | 
156 | if [ $((code)) -ne 200 ]; then
157 |     echo -e "${red}${bold}Failed!${normal} curl returned a status code of '${bold}${code}'${clear}"
158 |     exit $((code))
159 | fi
160 | echo -e "${prev_line}${green}Success${clear}"
161 | 


--------------------------------------------------------------------------------
/bin/test-attribution-txt.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -e
 2 | 
 3 | # get the directory of this script
 4 | # snippet from https://stackoverflow.com/a/246128/10102404
 5 | SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
 6 | GIT_ROOT=$(dirname "$SCRIPT_DIR")
 7 | 
 8 | EXIT_CODE=0
 9 | 
10 | cd "$GIT_ROOT"
11 | 
12 | if [ ! -f Attribution.txt ]; then
13 |     echo "An Attribution.txt file is missing, please add"
14 |     EXIT_CODE=1
15 | else
16 |     # loop over every library in the go.mod file
17 |     while IFS= read -r lib; do
18 |         if ! grep -q "$lib" Attribution.txt; then
19 |             echo "An attribution for $lib is missing from Attribution.txt, please add"
20 |             # need to do this in a bash subshell, see SC2031
21 |             (( EXIT_CODE=1 ))
22 |         fi
23 |     done < <(cat $GIT_ROOT/go.mod | grep -v 'module ' | grep -v TODO | grep '/' | sed 's/require //' | sed 's/replace //' | awk '{print $1}')
24 | fi


--------------------------------------------------------------------------------
/cmd/main.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | package main
 7 | 
 8 | import (
 9 | 	device_llrp "github.com/edgexfoundry/device-rfid-llrp-go"
10 | 	"github.com/edgexfoundry/device-rfid-llrp-go/internal/driver"
11 | 	"github.com/edgexfoundry/device-sdk-go/v4/pkg/startup"
12 | )
13 | 
14 | func main() {
15 | 	sd := driver.Instance()
16 | 	startup.Bootstrap(driver.ServiceName, device_llrp.Version, sd)
17 | }
18 | 


--------------------------------------------------------------------------------
/cmd/res/configuration.yaml:
--------------------------------------------------------------------------------
 1 | Writable:
 2 |   LogLevel: "INFO"
 3 | 
 4 | Service:
 5 |   Host: "localhost"
 6 |   Port: 59989
 7 |   StartupMsg: "device llrp started"
 8 | 
 9 | MessageBus:
10 |   Optional:
11 |     ClientId: "device-rfid-llrp"
12 | 
13 | Device:
14 |   # This setting has common value (currently), but must be here for service local env overrides to apply when customized
15 |   ProfilesDir: "./res/profiles"
16 |   # This service doesn't define any static devices. Devices are added via auto provisioning
17 |   DevicesDir: ""
18 |   ProvisionWatchersDir: "./res/provision_watchers"
19 |   Discovery:
20 |     Enabled: true
21 |     Interval: "1h"
22 | 
23 | AppCustom:
24 |   # List of IPv4 subnets to perform LLRP discovery process on, in CIDR format (X.X.X.X/Y)
25 |   # separated by commas ex: "192.168.1.0/24,10.0.0.0/24"
26 |   DiscoverySubnets: ""
27 | 
28 |   # Maximum simultaneous network probes
29 |   ProbeAsyncLimit: 4000
30 | 
31 |   # Maximum amount of seconds to wait for each IP probe before timing out.
32 |   # This will also be the minimum time the discovery process can take.
33 |   ProbeTimeoutSeconds: 2
34 | 
35 |   # Port to scan for LLRP devices on
36 |   ScanPort: "5084"
37 | 
38 |   # Maximum amount of seconds the discovery process is allowed to run before it will be cancelled.
39 |   # It is especially important to have this configured in the case of larger subnets such as /16 and /8
40 |   MaxDiscoverDurationSeconds: 300
41 | 


--------------------------------------------------------------------------------
/cmd/res/profiles/llrp.device.profile.yaml:
--------------------------------------------------------------------------------
  1 | name: "LLRP-Device-Profile"
  2 | manufacturer: "Intel"
  3 | model: "RFID Reader"
  4 | labels:
  5 |   - "LLRP"
  6 |   - "RFID"
  7 | description: "A generic device profile for readers that communicate over LLRP"
  8 | 
  9 | deviceResources:
 10 |   - 
 11 |     name: "ReaderCapabilities"
 12 |     description: "The capabilities of a reader"
 13 |     properties:
 14 |       valueType: "Object"
 15 |       readWrite: "R"
 16 | 
 17 |   - 
 18 |     name: "ReaderConfig"
 19 |     description: "Current configuration info of a reader"
 20 |     properties:
 21 |       valueType: "Object"
 22 |       readWrite: "RW"
 23 | 
 24 |   - 
 25 |     name: "ROSpecID"
 26 |     description: "Client-generated Reader Operation Specification Identifier"
 27 |     properties:
 28 |       valueType: "uint32"
 29 |       readWrite: "W"
 30 |       defaultValue: "1"
 31 | 
 32 |   - 
 33 |     name: "AccessSpecID"
 34 |     description: "Client-generated Access Specification Identifier"
 35 |     properties:
 36 |       valueType: "uint32"
 37 |       readWrite: "W"
 38 |       defaultValue: "1"
 39 | 
 40 |   - 
 41 |     name: "ROSpec"
 42 |     description: >-
 43 |       An ROSpec is a "Reader Operation Specification", i.e.,
 44 |       a declarative description of when and how
 45 |       a reader should turn on its antennas and report data.
 46 |       It's passed via EdgeX as a JSON object.
 47 |     properties:
 48 |       valueType: "Object"
 49 |       readWrite: "RW"
 50 | 
 51 |   - 
 52 |     name: "AccessSpec"
 53 |     description: ""
 54 |     properties:
 55 |       valueType: "Object"
 56 |       readWrite: "RW"
 57 |       
 58 |   - 
 59 |     name: "ROAccessReport"
 60 |     description: >-
 61 |       An ROAccessReport is the main report type in LLRP.
 62 |       They contain the TagReportData or RFSurveyReportData,
 63 |       as well as any Custom parameter data.
 64 |     isHidden: true # resource is only async
 65 |     properties:
 66 |       valueType: "Object" 
 67 |       readWrite: "R"
 68 | 
 69 |   - 
 70 |     name: "ReaderEventNotification"
 71 |     description: >-
 72 |       Readers generate Reader Event Notifications for a variety of events,
 73 |       including changes in connectivity, antenna additions/removals,
 74 |       GPIO state changes, new report data, and exception events.
 75 |       Some event notifications are configurable.
 76 |     isHidden: true # resource is only async
 77 |     properties:
 78 |       valueType: "Object"
 79 |       readWrite: "R" 
 80 | 
 81 |   - 
 82 |     name: "Action"
 83 |     description: >-
 84 |       EdgeX's Device Service SDK only distinguishes between "GET" and "PUT",
 85 |       and all PUT parameters must be defined deviceResources.
 86 |       Since we won't have, e.g., information about the HTTP path used in a request,
 87 |       this resource exists only to distinguish actions to take on other resources.
 88 |     properties:
 89 |       valueType: "String"
 90 |       readWrite: "W"
 91 | 
 92 | deviceCommands:
 93 | 
 94 |   - 
 95 |     name: enableROSpec
 96 |     isHidden: false
 97 |     readWrite: "W"
 98 |     resourceOperations:
 99 |       - { deviceResource: "ROSpecID"}
100 |       - { deviceResource: "Action", defaultValue: "Enable" }
101 | 
102 |   - 
103 |     name: startROSpec
104 |     isHidden: false
105 |     readWrite: "W"
106 |     resourceOperations:
107 |       - { deviceResource: "ROSpecID" }
108 |       - { deviceResource: "Action", defaultValue: "Start" }
109 | 
110 |   - 
111 |     name: stopROSpec
112 |     isHidden: false
113 |     readWrite: "W"
114 |     resourceOperations:
115 |       - { deviceResource: "ROSpecID"}
116 |       - { deviceResource: "Action", defaultValue: "Stop" }
117 | 
118 |   - 
119 |     name: disableROSpec
120 |     isHidden: false
121 |     readWrite: "W"
122 |     resourceOperations:
123 |       - { deviceResource: "ROSpecID"}
124 |       - { deviceResource: "Action", defaultValue: "Disable" }
125 | 
126 |   - 
127 |     name: deleteROSpec
128 |     isHidden: false
129 |     readWrite: "W"
130 |     resourceOperations:
131 |       - { deviceResource: "ROSpecID"}
132 |       - { deviceResource: "Action", defaultValue: "Delete" }
133 | 
134 |   - 
135 |     name: enableAccessSpec
136 |     isHidden: false
137 |     readWrite: "W"
138 |     resourceOperations:
139 |       - { deviceResource: "AccessSpecID" }
140 |       - { deviceResource: "Action", defaultValue: "Enable" }
141 | 
142 |   - 
143 |     name: disableAccessSpec
144 |     isHidden: false
145 |     readWrite: "W"
146 |     resourceOperations:
147 |       - { deviceResource: "AccessSpecID"}
148 |       - { deviceResource: "Action", defaultValue: "Disable" }
149 | 
150 |   - 
151 |     name: deleteAccessSpec
152 |     isHidden: false
153 |     readWrite: "W"
154 |     resourceOperations:
155 |       - { deviceResource: "AccessSpecID"}
156 |       - { deviceResource: "Action", defaultValue: "Delete" }
157 | 


--------------------------------------------------------------------------------
/cmd/res/profiles/llrp.impinj.profile.yaml:
--------------------------------------------------------------------------------
  1 | name: "LLRP-Impinj-Profile"
  2 | manufacturer: "Impinj"
  3 | labels:
  4 |   - "LLRP"
  5 |   - "RFID"
  6 |   - "Impinj"
  7 | description: "A device profile with added Impinj support."
  8 | 
  9 | deviceResources:
 10 |   - 
 11 |     name: "EnableImpinjExtensions"
 12 |     properties:
 13 |       valueType: "String"
 14 |       readWrite: "W"
 15 |       defaultValue: "AAAAAA=="
 16 |     attributes:
 17 |       vendor: "25882"
 18 |       subtype: "21"
 19 | 
 20 |   - 
 21 |     name: "ImpinjSaveSettingsMessage"
 22 |     properties:
 23 |       valueType: "String"
 24 |       readWrite: "W"
 25 |     attributes:
 26 |       vendor: "25882"
 27 |       subtype: "23"
 28 | 
 29 |   - 
 30 |     name: "ReaderCapabilities"
 31 |     description: "The capabilities of a reader"
 32 |     properties:
 33 |       valueType: "Object"
 34 |       readWrite: "R"
 35 | 
 36 |   - 
 37 |     name: "ReaderConfig"
 38 |     description: "A Reader's configuration"
 39 |     properties:
 40 |       valueType: "Object"
 41 |       readWrite: "RW"
 42 | 
 43 |   - 
 44 |     name: "ROSpecID"
 45 |     description: "Client-generated Reader Operation Specification Identifier"
 46 |     properties:
 47 |       valueType: "uint32"
 48 |       readWrite: "W"
 49 |       defaultValue: "1"
 50 | 
 51 |   - 
 52 |     name: "AccessSpecID"
 53 |     description: "Client-generated Access Specification Identifier"
 54 |     properties:
 55 |       valueType: "uint32"
 56 |       readWrite: "W"
 57 |       defaultValue: "1"
 58 | 
 59 |   - 
 60 |     name: "ROSpec"
 61 |     properties:
 62 |       valueType: "Object"
 63 |       readWrite: "RW"
 64 | 
 65 |   - 
 66 |     name: "AccessSpec"
 67 |     properties:
 68 |       valueType: "Object"
 69 |       readWrite: "RW"
 70 | 
 71 |   - 
 72 |     name: "Action"
 73 |     properties:
 74 |       valueType: "String"
 75 |       readWrite: "W"
 76 | 
 77 |   - 
 78 |     name: "ROAccessReport"
 79 |     isHidden: true # resource is only async
 80 |     properties:
 81 |       valueType: "Object"
 82 |       readWrite: "R" 
 83 | 
 84 |   - 
 85 |     name: "ReaderEventNotification"
 86 |     isHidden: true # resource is only async
 87 |     properties:
 88 |       valueType: "Object"
 89 |       readWrite: "R" 
 90 | 
 91 | deviceCommands:
 92 |   - 
 93 |     name: enableROSpec
 94 |     isHidden: false
 95 |     readWrite: "W"
 96 |     resourceOperations:
 97 |       - { deviceResource: "ROSpecID", defaultValue: "0" }
 98 |       - { deviceResource: "Action", defaultValue: "Enable" }
 99 | 
100 |   - 
101 |     name: startROSpec
102 |     isHidden: false
103 |     readWrite: "W"
104 |     resourceOperations:
105 |       - { deviceResource: "ROSpecID", defaultValue: "0" }
106 |       - { deviceResource: "Action", defaultValue: "Start" }
107 | 
108 |   - 
109 |     name: stopROSpec
110 |     isHidden: false
111 |     readWrite: "W"
112 |     resourceOperations:
113 |       - { deviceResource: "ROSpecID", defaultValue: "0" }
114 |       - { deviceResource: "Action", defaultValue: "Stop" }
115 | 
116 |   - 
117 |     name: disableROSpec
118 |     isHidden: false
119 |     readWrite: "W"
120 |     resourceOperations:
121 |       - { deviceResource: "ROSpecID", defaultValue: "0" }
122 |       - { deviceResource: "Action", defaultValue: "Disable" }
123 | 
124 |   - 
125 |     name: deleteROSpec
126 |     isHidden: false
127 |     readWrite: "W"
128 |     resourceOperations:
129 |       - { deviceResource: "ROSpecID", defaultValue: "0" }
130 |       - { deviceResource: "Action", defaultValue: "Delete" }
131 | 
132 |   - 
133 |     name: enableAccessSpec
134 |     isHidden: false
135 |     readWrite: "W"
136 |     resourceOperations:
137 |       - { deviceResource: "AccessSpecID", defaultValue: "0" }
138 |       - { deviceResource: "Action", defaultValue: "Enable" }
139 | 
140 |   - 
141 |     name: disableAccessSpec
142 |     isHidden: false
143 |     readWrite: "W"
144 |     resourceOperations:
145 |       - { deviceResource: "AccessSpecID", defaultValue: "0" }
146 |       - { deviceResource: "Action", defaultValue: "Disable" }
147 | 
148 |   - 
149 |     name: deleteAccessSpec
150 |     isHidden: false
151 |     readWrite: "W"
152 |     resourceOperations:
153 |       - { deviceResource: "AccessSpecID" }
154 |       - { deviceResource: "Action", defaultValue: "Delete" }
155 | 


--------------------------------------------------------------------------------
/cmd/res/provision_watchers/impinj.provision.watcher.yaml:
--------------------------------------------------------------------------------
1 | name: "llrp-impinj-provision-watcher"
2 | serviceName: "device-rfid-llrp"
3 | identifiers:
4 |   vendorPEN: "25882"
5 | blockingIdentifiers: {}
6 | adminState: "UNLOCKED"
7 | discoveredDevice:
8 |   profileName: "LLRP-Impinj-Profile"
9 |   adminState: "UNLOCKED"


--------------------------------------------------------------------------------
/cmd/res/provision_watchers/llrp.provision.watcher.yaml:
--------------------------------------------------------------------------------
 1 | name: "llrp-provision-watcher"
 2 | serviceName: "device-rfid-llrp"
 3 | identifiers:
 4 |   vendorPEN: "."
 5 | blockingIdentifiers:
 6 |   vendorPEN:
 7 |     - "25882"
 8 | adminState: "UNLOCKED"
 9 | discoveredDevice:
10 |   profileName: "LLRP-Device-Profile"
11 |   adminState: "UNLOCKED"
12 | 


--------------------------------------------------------------------------------
/examples/AccessSpec.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"AccessSpecID": 1,
 3 | 	"AirProtocolID": 1,
 4 | 	"AccessCommand": {
 5 | 		"C1G2TagSpec": {
 6 | 			"TagPattern1": {
 7 | 				"C1G2MemoryBank": 1,
 8 | 				"MatchFlag": true
 9 | 			}
10 | 		},
11 | 		"C1G2Read": {
12 | 			"OpSpecID": 1,
13 | 			"C1G2MemoryBank": 2,
14 | 			"WordCount": 6
15 | 		}
16 | 	}
17 | }
18 | 


--------------------------------------------------------------------------------
/examples/ImpinjEnableCustomExt.json:
--------------------------------------------------------------------------------
1 | [{
2 | 	"VendorID": 25882,
3 | 	"MessageSubtype": 21,
4 | 	"Data": "AAAAAA=="
5 | }]
6 | 


--------------------------------------------------------------------------------
/examples/ImpinjReadFast.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ROSpecID": 1,
 3 | 	"Priority": 0,
 4 | 	"ROSpecCurrentState": 0,
 5 | 	"ROBoundarySpec": {
 6 | 		"StartTrigger": {
 7 | 			"Trigger": 1,
 8 | 			"PeriodicTrigger": null,
 9 | 			"GPITrigger": null
10 | 		},
11 | 		"StopTrigger": {
12 | 			"Trigger": 0
13 | 		}
14 | 	},
15 | 	"AISpecs": [
16 | 		{
17 | 			"AntennaIDs": [
18 | 				2
19 | 			],
20 | 			"StopTrigger": {
21 | 				"Trigger": 0
22 | 			},
23 | 			"InventoryParameterSpecs": [
24 | 				{
25 | 					"InventoryParameterSpecID": 2,
26 | 					"AirProtocolID": 1,
27 | 					"AntennaConfigurations": [
28 | 						{
29 | 							"AntennaID": 2,
30 | 							"RFTransmitter": {
31 | 								"HopTableID": 1,
32 | 								"TransmitPowerIndex": 81
33 | 							},
34 | 							"C1G2InventoryCommand": {
35 | 								"RFControl": {
36 | 									"RFModeID": 0
37 | 								},
38 | 								"SingulationControl": {
39 | 									"Session": 0,
40 | 									"TagPopulation": 16,
41 | 									"TagTransitTime": 1000
42 | 								},
43 | 								"Custom": [
44 | 									{
45 | 										"VendorID": 25882,
46 | 										"Subtype": 23,
47 | 										"Data": "AAI="
48 | 									}
49 | 								]
50 | 							}
51 | 						}
52 | 					],
53 | 					"Custom": null
54 | 				}
55 | 			],
56 | 			"Custom": null
57 | 		}
58 | 	],
59 | 	"ROReportSpec": {
60 | 		"Trigger": 1,
61 | 		"N": 1,
62 | 		"TagReportContentSelector": {
63 | 			"EnableROSpecID": false,
64 | 			"EnableSpecIndex": false,
65 | 			"EnableInventoryParamSpecID": true,
66 | 			"EnableAntennaID": true,
67 | 			"EnableChannelIndex": true,
68 | 			"EnablePeakRSSI": true,
69 | 			"EnableFirstSeenTimestamp": true,
70 | 			"EnableLastSeenTimestamp": true,
71 | 			"EnableTagSeenCount": true,
72 | 			"EnableAccessSpecID": false,
73 | 			"C1G2EPCMemorySelectors": {
74 | 				"CRCEnabled": false,
75 | 				"PCBitsEnabled": false
76 | 			}
77 | 		},
78 | 		"Custom": [
79 | 			{
80 | 				"VendorID": 25882,
81 | 				"Subtype": 50,
82 | 				"Data": "A/8ADgAAZRoAAAA0AAE="
83 | 			}
84 | 		]
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/examples/ImpinjReaderConf.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "LLRPStatus": {
  3 |     "Status": 0,
  4 |     "ErrorDescription": "",
  5 |     "FieldError": null,
  6 |     "ParameterError": null
  7 |   },
  8 |   "Identification": {
  9 |     "IDType": 0,
 10 |     "ReaderID": "ABYl//8RJdY="
 11 |   },
 12 |   "AntennaProperties": [
 13 |     {
 14 |       "AntennaConnected": false,
 15 |       "AntennaID": 1,
 16 |       "AntennaGain": 0
 17 |     },
 18 |     {
 19 |       "AntennaConnected": true,
 20 |       "AntennaID": 2,
 21 |       "AntennaGain": 0
 22 |     },
 23 |     {
 24 |       "AntennaConnected": false,
 25 |       "AntennaID": 3,
 26 |       "AntennaGain": 0
 27 |     },
 28 |     {
 29 |       "AntennaConnected": false,
 30 |       "AntennaID": 4,
 31 |       "AntennaGain": 0
 32 |     }
 33 |   ],
 34 |   "AntennaConfigurations": [
 35 |     {
 36 |       "AntennaID": 1,
 37 |       "RFReceiver": 1,
 38 |       "RFTransmitter": {
 39 |         "HopTableID": 1,
 40 |         "ChannelIndex": 0,
 41 |         "TransmitPowerIndex": 81
 42 |       },
 43 |       "C1G2InventoryCommand": {
 44 |         "TagInventoryStateAware": false,
 45 |         "Filters": null,
 46 |         "RFControl": {
 47 |           "RFModeID": 1000,
 48 |           "Tari": 0
 49 |         },
 50 |         "SingulationControl": {
 51 |           "Session": 1,
 52 |           "TagPopulation": 32,
 53 |           "TagTransitTime": 0,
 54 |           "InvAwareAction": null
 55 |         },
 56 |         "Custom": [
 57 |           {
 58 |             "VendorID": 25882,
 59 |             "Subtype": 23,
 60 |             "Data": "AAA="
 61 |           },
 62 |           {
 63 |             "VendorID": 25882,
 64 |             "Subtype": 26,
 65 |             "Data": "AAAAAAAA"
 66 |           },
 67 |           {
 68 |             "VendorID": 25882,
 69 |             "Subtype": 27,
 70 |             "Data": "AAAAAAAA"
 71 |           },
 72 |           {
 73 |             "VendorID": 25882,
 74 |             "Subtype": 28,
 75 |             "Data": "AAAAAAAA"
 76 |           },
 77 |           {
 78 |             "VendorID": 25882,
 79 |             "Subtype": 69,
 80 |             "Data": "gA=="
 81 |           },
 82 |           {
 83 |             "VendorID": 25882,
 84 |             "Subtype": 1554,
 85 |             "Data": "gA=="
 86 |           },
 87 |           {
 88 |             "VendorID": 25882,
 89 |             "Subtype": 1582,
 90 |             "Data": "AAAAAAA="
 91 |           }
 92 |         ]
 93 |       },
 94 |       "Custom": null
 95 |     },
 96 |     {
 97 |       "AntennaID": 2,
 98 |       "RFReceiver": 1,
 99 |       "RFTransmitter": {
100 |         "HopTableID": 1,
101 |         "ChannelIndex": 0,
102 |         "TransmitPowerIndex": 81
103 |       },
104 |       "C1G2InventoryCommand": {
105 |         "TagInventoryStateAware": false,
106 |         "Filters": null,
107 |         "RFControl": {
108 |           "RFModeID": 1000,
109 |           "Tari": 0
110 |         },
111 |         "SingulationControl": {
112 |           "Session": 1,
113 |           "TagPopulation": 32,
114 |           "TagTransitTime": 0,
115 |           "InvAwareAction": null
116 |         },
117 |         "Custom": [
118 |           {
119 |             "VendorID": 25882,
120 |             "Subtype": 23,
121 |             "Data": "AAA="
122 |           },
123 |           {
124 |             "VendorID": 25882,
125 |             "Subtype": 26,
126 |             "Data": "AAAAAAAA"
127 |           },
128 |           {
129 |             "VendorID": 25882,
130 |             "Subtype": 27,
131 |             "Data": "AAAAAAAA"
132 |           },
133 |           {
134 |             "VendorID": 25882,
135 |             "Subtype": 28,
136 |             "Data": "AAAAAAAA"
137 |           },
138 |           {
139 |             "VendorID": 25882,
140 |             "Subtype": 69,
141 |             "Data": "gA=="
142 |           },
143 |           {
144 |             "VendorID": 25882,
145 |             "Subtype": 1554,
146 |             "Data": "gA=="
147 |           },
148 |           {
149 |             "VendorID": 25882,
150 |             "Subtype": 1582,
151 |             "Data": "AAAAAAA="
152 |           }
153 |         ]
154 |       },
155 |       "Custom": null
156 |     },
157 |     {
158 |       "AntennaID": 3,
159 |       "RFReceiver": 1,
160 |       "RFTransmitter": {
161 |         "HopTableID": 1,
162 |         "ChannelIndex": 0,
163 |         "TransmitPowerIndex": 81
164 |       },
165 |       "C1G2InventoryCommand": {
166 |         "TagInventoryStateAware": false,
167 |         "Filters": null,
168 |         "RFControl": {
169 |           "RFModeID": 1000,
170 |           "Tari": 0
171 |         },
172 |         "SingulationControl": {
173 |           "Session": 1,
174 |           "TagPopulation": 32,
175 |           "TagTransitTime": 0,
176 |           "InvAwareAction": null
177 |         },
178 |         "Custom": [
179 |           {
180 |             "VendorID": 25882,
181 |             "Subtype": 23,
182 |             "Data": "AAA="
183 |           },
184 |           {
185 |             "VendorID": 25882,
186 |             "Subtype": 26,
187 |             "Data": "AAAAAAAA"
188 |           },
189 |           {
190 |             "VendorID": 25882,
191 |             "Subtype": 27,
192 |             "Data": "AAAAAAAA"
193 |           },
194 |           {
195 |             "VendorID": 25882,
196 |             "Subtype": 28,
197 |             "Data": "AAAAAAAA"
198 |           },
199 |           {
200 |             "VendorID": 25882,
201 |             "Subtype": 69,
202 |             "Data": "gA=="
203 |           },
204 |           {
205 |             "VendorID": 25882,
206 |             "Subtype": 1554,
207 |             "Data": "gA=="
208 |           },
209 |           {
210 |             "VendorID": 25882,
211 |             "Subtype": 1582,
212 |             "Data": "AAAAAAA="
213 |           }
214 |         ]
215 |       },
216 |       "Custom": null
217 |     },
218 |     {
219 |       "AntennaID": 4,
220 |       "RFReceiver": 1,
221 |       "RFTransmitter": {
222 |         "HopTableID": 1,
223 |         "ChannelIndex": 0,
224 |         "TransmitPowerIndex": 81
225 |       },
226 |       "C1G2InventoryCommand": {
227 |         "TagInventoryStateAware": false,
228 |         "Filters": null,
229 |         "RFControl": {
230 |           "RFModeID": 1000,
231 |           "Tari": 0
232 |         },
233 |         "SingulationControl": {
234 |           "Session": 1,
235 |           "TagPopulation": 32,
236 |           "TagTransitTime": 0,
237 |           "InvAwareAction": null
238 |         },
239 |         "Custom": [
240 |           {
241 |             "VendorID": 25882,
242 |             "Subtype": 23,
243 |             "Data": "AAA="
244 |           },
245 |           {
246 |             "VendorID": 25882,
247 |             "Subtype": 26,
248 |             "Data": "AAAAAAAA"
249 |           },
250 |           {
251 |             "VendorID": 25882,
252 |             "Subtype": 27,
253 |             "Data": "AAAAAAAA"
254 |           },
255 |           {
256 |             "VendorID": 25882,
257 |             "Subtype": 28,
258 |             "Data": "AAAAAAAA"
259 |           },
260 |           {
261 |             "VendorID": 25882,
262 |             "Subtype": 69,
263 |             "Data": "gA=="
264 |           },
265 |           {
266 |             "VendorID": 25882,
267 |             "Subtype": 1554,
268 |             "Data": "gA=="
269 |           },
270 |           {
271 |             "VendorID": 25882,
272 |             "Subtype": 1582,
273 |             "Data": "AAAAAAA="
274 |           }
275 |         ]
276 |       },
277 |       "Custom": null
278 |     }
279 |   ],
280 |   "ReaderEventNotificationSpec": {
281 |     "EventNotificationStates": [
282 |       {
283 |         "ReaderEventType": 0,
284 |         "NotificationEnabled": false
285 |       },
286 |       {
287 |         "ReaderEventType": 1,
288 |         "NotificationEnabled": false
289 |       },
290 |       {
291 |         "ReaderEventType": 2,
292 |         "NotificationEnabled": false
293 |       },
294 |       {
295 |         "ReaderEventType": 3,
296 |         "NotificationEnabled": true
297 |       },
298 |       {
299 |         "ReaderEventType": 4,
300 |         "NotificationEnabled": true
301 |       },
302 |       {
303 |         "ReaderEventType": 5,
304 |         "NotificationEnabled": false
305 |       },
306 |       {
307 |         "ReaderEventType": 6,
308 |         "NotificationEnabled": false
309 |       },
310 |       {
311 |         "ReaderEventType": 7,
312 |         "NotificationEnabled": false
313 |       },
314 |       {
315 |         "ReaderEventType": 8,
316 |         "NotificationEnabled": true
317 |       }
318 |     ]
319 |   },
320 |   "ROReportSpec": {
321 |     "Trigger": 2,
322 |     "N": 1,
323 |     "TagReportContentSelector": {
324 |       "EnableROSpecID": false,
325 |       "EnableSpecIndex": false,
326 |       "EnableInventoryParamSpecID": false,
327 |       "EnableAntennaID": true,
328 |       "EnableChannelIndex": false,
329 |       "EnablePeakRSSI": true,
330 |       "EnableFirstSeenTimestamp": true,
331 |       "EnableLastSeenTimestamp": false,
332 |       "EnableTagSeenCount": false,
333 |       "EnableAccessSpecID": false,
334 |       "C1G2EPCMemorySelector": {
335 |         "CRCEnabled": false,
336 |         "PCBitsEnabled": false,
337 |         "XPCBitsEnabled": false
338 |       },
339 |       "Custom": null
340 |     },
341 |     "Custom": [
342 |       {
343 |         "VendorID": 25882,
344 |         "Subtype": 50,
345 |         "Data": "A/8ADgAAZRoAAAAzAAAD/wAOAABlGgAAADQAAAP/AA4AAGUaAAAANQAAA/8ADgAAZRoAAAA2AAAD/wAOAABlGgAAAEEAAAP/AA4AAGUaAAAAQwAAA/8ADgAAZRoAAABIAAA="
346 |       }
347 |     ]
348 |   },
349 |   "AccessReportSpec": 1,
350 |   "LLRPConfigurationStateValue": 947464803,
351 |   "KeepAliveSpec": {
352 |     "Trigger": 1,
353 |     "Interval": 30000
354 |   },
355 |   "GPIPortCurrentStates": [
356 |     {
357 |       "Port": 1,
358 |       "Enabled": false,
359 |       "State": 0
360 |     },
361 |     {
362 |       "Port": 2,
363 |       "Enabled": false,
364 |       "State": 0
365 |     },
366 |     {
367 |       "Port": 3,
368 |       "Enabled": false,
369 |       "State": 0
370 |     },
371 |     {
372 |       "Port": 4,
373 |       "Enabled": false,
374 |       "State": 0
375 |     }
376 |   ],
377 |   "GPOWriteData": [
378 |     {
379 |       "Port": 1,
380 |       "Data": false
381 |     },
382 |     {
383 |       "Port": 2,
384 |       "Data": false
385 |     },
386 |     {
387 |       "Port": 3,
388 |       "Data": false
389 |     },
390 |     {
391 |       "Port": 4,
392 |       "Data": false
393 |     }
394 |   ],
395 |   "EventsAndReports": false,
396 |   "Custom": [
397 |     {
398 |       "VendorID": 25882,
399 |       "Subtype": 22,
400 |       "Data": "AAA="
401 |     },
402 |     {
403 |       "VendorID": 25882,
404 |       "Subtype": 36,
405 |       "Data": "AAEAAAAU"
406 |     },
407 |     {
408 |       "VendorID": 25882,
409 |       "Subtype": 36,
410 |       "Data": "AAIAAAAU"
411 |     },
412 |     {
413 |       "VendorID": 25882,
414 |       "Subtype": 36,
415 |       "Data": "AAMAAAAU"
416 |     },
417 |     {
418 |       "VendorID": 25882,
419 |       "Subtype": 36,
420 |       "Data": "AAQAAAAU"
421 |     },
422 |     {
423 |       "VendorID": 25882,
424 |       "Subtype": 37,
425 |       "Data": "ACQ="
426 |     },
427 |     {
428 |       "VendorID": 25882,
429 |       "Subtype": 38,
430 |       "Data": "AAAAAA=="
431 |     },
432 |     {
433 |       "VendorID": 25882,
434 |       "Subtype": 39,
435 |       "Data": "AAA="
436 |     },
437 |     {
438 |       "VendorID": 25882,
439 |       "Subtype": 40,
440 |       "Data": "A/8ADgAAZRoAAAApAAED/wAOAABlGgAAAD8AAAP/AA4AAGUaAAAAQgAA"
441 |     },
442 |     {
443 |       "VendorID": 25882,
444 |       "Subtype": 60,
445 |       "Data": null
446 |     },
447 |     {
448 |       "VendorID": 25882,
449 |       "Subtype": 64,
450 |       "Data": "AAEAAAAAAAA="
451 |     },
452 |     {
453 |       "VendorID": 25882,
454 |       "Subtype": 64,
455 |       "Data": "AAIAAAAAAAA="
456 |     },
457 |     {
458 |       "VendorID": 25882,
459 |       "Subtype": 64,
460 |       "Data": "AAMAAAAAAAA="
461 |     },
462 |     {
463 |       "VendorID": 25882,
464 |       "Subtype": 64,
465 |       "Data": "AAQAAAAAAAA="
466 |     },
467 |     {
468 |       "VendorID": 25882,
469 |       "Subtype": 1524,
470 |       "Data": "A/8ADQAAZRoAAAYoAA=="
471 |     },
472 |     {
473 |       "VendorID": 25882,
474 |       "Subtype": 1538,
475 |       "Data": "AAEAAAAA"
476 |     },
477 |     {
478 |       "VendorID": 25882,
479 |       "Subtype": 1538,
480 |       "Data": "AAIAAAAA"
481 |     },
482 |     {
483 |       "VendorID": 25882,
484 |       "Subtype": 1538,
485 |       "Data": "AAMAAAAA"
486 |     },
487 |     {
488 |       "VendorID": 25882,
489 |       "Subtype": 1538,
490 |       "Data": "AAQAAAAA"
491 |     }
492 |   ]
493 | }
494 | 


--------------------------------------------------------------------------------
/examples/ImpinjStaticSuppress.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"ROSpecID": 1,
  3 | 	"Priority": 0,
  4 | 	"ROSpecCurrentState": 0,
  5 | 	"ROBoundarySpec": {
  6 | 		"StartTrigger": {
  7 | 			"Trigger": 1,
  8 | 			"PeriodicTrigger": null,
  9 | 			"GPITrigger": null
 10 | 		},
 11 | 		"StopTrigger": {
 12 | 			"Trigger": 0
 13 | 		}
 14 | 	},
 15 | 	"AISpecs": [
 16 | 		{
 17 | 			"AntennaIDs": [
 18 | 				2
 19 | 			],
 20 | 			"StopTrigger": {
 21 | 				"Trigger": 1,
 22 | 				"DurationTriggerValue": 10
 23 | 			},
 24 | 			"InventoryParameterSpecs": [
 25 | 				{
 26 | 					"InventoryParameterSpecID": 1,
 27 | 					"AirProtocolID": 1,
 28 | 					"AntennaConfigurations": [
 29 | 						{
 30 | 							"AntennaID": 2,
 31 | 							"RFTransmitter": {
 32 | 								"HopTableID": 1,
 33 | 								"TransmitPowerIndex": 81
 34 | 							},
 35 | 							"C1G2InventoryCommand": {
 36 | 								"Filters": [
 37 | 									{
 38 | 										"TagInventoryMask": {
 39 | 											"MemoryBank": 1,
 40 | 											"TagMaskNumBits": 96,
 41 | 											"TagMask": "AAAAAAAAAAAAAAAA"
 42 | 										},
 43 | 										"UnawareFilterAction": 4
 44 | 									}
 45 | 								],
 46 | 								"RFControl": {
 47 | 									"RFModeID": 0
 48 | 								},
 49 | 								"SingulationControl": {
 50 | 									"Session": 2,
 51 | 									"TagPopulation": 16,
 52 | 									"TagTransitTime": 10000
 53 | 								},
 54 | 								"Custom": [
 55 | 									{
 56 | 										"VendorID": 25882,
 57 | 										"Subtype": 23,
 58 | 										"Data": "AAU="
 59 | 									}
 60 | 								]
 61 | 							}
 62 | 						}
 63 | 					],
 64 | 					"Custom": null
 65 | 				}
 66 | 			],
 67 | 			"Custom": null
 68 | 		},
 69 | 		{
 70 | 			"AntennaIDs": [
 71 | 				2
 72 | 			],
 73 | 			"StopTrigger": {
 74 | 				"Trigger": 0
 75 | 			},
 76 | 			"InventoryParameterSpecs": [
 77 | 				{
 78 | 					"InventoryParameterSpecID": 1,
 79 | 					"AirProtocolID": 1,
 80 | 					"AntennaConfigurations": [
 81 | 						{
 82 | 							"AntennaID": 2,
 83 | 							"RFTransmitter": {
 84 | 								"HopTableID": 1,
 85 | 								"TransmitPowerIndex": 81
 86 | 							},
 87 | 							"C1G2InventoryCommand": {
 88 | 								"RFControl": {
 89 | 									"RFModeID": 0
 90 | 								},
 91 | 								"SingulationControl": {
 92 | 									"Session": 2,
 93 | 									"TagPopulation": 16,
 94 | 									"TagTransitTime": 10000
 95 | 								},
 96 | 								"Custom": [
 97 | 									{
 98 | 										"VendorID": 25882,
 99 | 										"Subtype": 23,
100 | 										"Data": "AAM="
101 | 									}
102 | 								]
103 | 							}
104 | 						}
105 | 					],
106 | 					"Custom": null
107 | 				}
108 | 			],
109 | 			"Custom": null
110 | 		}
111 | 	],
112 | 	"ROReportSpec": {
113 | 		"Trigger": 1,
114 | 		"N": 1,
115 | 		"TagReportContentSelector": {
116 | 			"EnableROSpecID": false,
117 | 			"EnableSpecIndex": false,
118 | 			"EnableInventoryParamSpecID": true,
119 | 			"EnableAntennaID": true,
120 | 			"EnableChannelIndex": true,
121 | 			"EnablePeakRSSI": true,
122 | 			"EnableFirstSeenTimestamp": true,
123 | 			"EnableLastSeenTimestamp": true,
124 | 			"EnableTagSeenCount": true,
125 | 			"EnableAccessSpecID": false,
126 | 			"C1G2EPCMemorySelectors": {
127 | 				"CRCEnabled": false,
128 | 				"PCBitsEnabled": false
129 | 			}
130 | 		},
131 | 		"Custom": [
132 | 			{
133 | 				"VendorID": 25882,
134 | 				"Subtype": 50,
135 | 				"Data": "A/8ADgAAZRoAAAA0AAE="
136 | 			}
137 | 		]
138 | 	}
139 | }
140 | 


--------------------------------------------------------------------------------
/examples/ROSpec.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ROSpecID": 1,
 3 | 	"Priority": 0,
 4 | 	"ROSpecCurrentState": 0,
 5 | 	"ROBoundarySpec": {
 6 | 		"StartTrigger": {
 7 | 			"Trigger": 1,
 8 | 			"PeriodicTrigger": null,
 9 | 			"GPITrigger": null
10 | 		},
11 | 		"StopTrigger": {
12 | 			"Trigger": 1,
13 | 			"DurationTriggerValue": 500,
14 | 			"GPITriggerValue": null
15 | 		}
16 | 	},
17 | 	"AISpecs": [
18 | 		{
19 | 			"AntennaIDs": [
20 | 				0
21 | 			],
22 | 			"StopTrigger": {
23 | 				"Trigger": 0,
24 | 				"DurationTriggerValue": 0,
25 | 				"GPITrigger": null,
26 | 				"TagObservationTrigger": null
27 | 			},
28 | 			"InventoryParameterSpecs": [
29 | 				{
30 | 					"InventoryParameterSpecID": 1,
31 | 					"AirProtocolID": 1,
32 | 					"AntennaConfigurations": null,
33 | 					"Custom": null
34 | 				}
35 | 			],
36 | 			"Custom": null
37 | 		}
38 | 	],
39 | 	"RFSurveySpecs": null,
40 | 	"Custom": null,
41 | 	"LoopSpec": null,
42 | 	"ROReportSpec": {
43 | 		"Trigger": 2,
44 | 		"N": 0,
45 | 		"TagReportContentSelector": {
46 | 			"EnableROSpecID": true,
47 | 			"EnableSpecIndex": true,
48 | 			"EnableInventoryParamSpecID": true,
49 | 			"EnableAntennaID": true,
50 | 			"EnableChannelIndex": true,
51 | 			"EnablePeakRSSI": true,
52 | 			"EnableFirstSeenTimestamp": true,
53 | 			"EnableLastSeenTimestamp": true,
54 | 			"EnableTagSeenCount": true,
55 | 			"EnableAccessSpecID": true,
56 | 			"C1G2EPCMemorySelectors": {
57 | 				"CRCEnabled": true,
58 | 				"PCBitsEnabled": true
59 | 			},
60 | 			"Custom": null
61 | 		},
62 | 		"Custom": null
63 | 	}
64 | }
65 | 


--------------------------------------------------------------------------------
/examples/ReaderConfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ResetToFactoryDefaults": false,
 3 | 	"ReaderEventNotificationSpec": {
 4 | 		"EventNotificationStates": [
 5 | 			{
 6 | 				"ReaderEventType": 4,
 7 | 				"NotificationEnabled": true
 8 | 			},
 9 | 			{
10 | 				"ReaderEventType": 3,
11 | 				"NotificationEnabled": true
12 | 			},
13 | 			{
14 | 				"ReaderEventType": 8,
15 | 				"NotificationEnabled": true
16 | 			}
17 | 		]
18 | 	},
19 | 	"AntennaProperties": null,
20 | 	"AntennaConfigurations": null,
21 | 	"ROReportSpec": null,
22 | 	"AccessReportSpec": null,
23 | 	"KeepAliveSpec": {
24 | 		"Trigger": 1,
25 | 		"Interval": 180000
26 | 	},
27 | 	"GPOWriteData": null,
28 | 	"GPIPortCurrentStates": null,
29 | 	"EventsAndReports": null,
30 | 	"Custom": null
31 | }
32 | 


--------------------------------------------------------------------------------
/examples/command.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | 
  3 | # command.sh - simple script to interact with EdgeX's core-command
  4 | #   to see and manipulate ROs, reader config, and reader capabilities.
  5 | #   Use --help to view usage.
  6 | 
  7 | set -euo pipefail
  8 | IFS=$'\n\t'
  9 | 
 10 | HOST=localhost
 11 | CMDS_PORT=59882
 12 | CURL_OPTS="-o-"
 13 | DEVICE=""
 14 | 
 15 | usage() {
 16 |     echo "usage:"
 17 |     echo "  $0 [OPTS] list LISTABLE"
 18 |     echo "  $0 [OPTS] get TARGET"
 19 |     echo "  $0 [OPTS] SET_ACTION TARGET FILEPATH"
 20 |     echo ""
 21 |     echo "LISTABLE:    devices commands"
 22 |     echo "SET_ACTIONS: set add enable start stop disable delete"
 23 |     echo "TARGETS:     ReaderConfig ReaderCapabilities ROSpec AccessSpec"
 24 |     echo ""
 25 |     echo "OPTS:"
 26 |     echo "    -d | --device NAME  specific device to use     default: all LLRP devices"
 27 |     echo "    -h | --host HOST    edgex-core-commands host   default: localhost"
 28 |     echo "    -p | --port PORT    edgex-core-commands port   default: 59882"
 29 |     echo "    -v | --verbose      use verbose curl output"
 30 |     echo "    -s | --silent       use silent curl output"
 31 |     echo ""
 32 |     echo "examples:"
 33 |     echo "      $0 list devices"
 34 |     echo "      $0 get ReaderCapabilities"
 35 |     echo "      $0 set ReaderConfig path/to/config.json"
 36 |     echo "      $0 add ROSpec path/to/ROSpec.json"
 37 |     echo "      $0 enable ROSpec 1"
 38 |     echo "      $0 delete ROSpec 0"
 39 | }
 40 | 
 41 | if [[ $# -lt 1 ]]; then
 42 |     usage; exit
 43 | fi
 44 | 
 45 | while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in
 46 |   -h | --host )
 47 |     shift; HOST=$1
 48 |     ;;
 49 |   -d | --device )
 50 |     shift; DEVICE=$1
 51 |     ;;
 52 |   -p | --core-cmds-port )
 53 |     shift; CMDS_PORT=$1
 54 |     ;;
 55 |   -v | --verbose )
 56 |     CURL_OPTS="-vvvvo-"
 57 |     ;;
 58 |   -s | --silent )
 59 |     CURL_OPTS='-so-'
 60 |     ;;
 61 |   --help )
 62 |     usage; exit
 63 |     ;;
 64 |   *)
 65 |     echo "unknown flag $1"
 66 |     usage; exit
 67 |     ;;
 68 | esac; shift; done
 69 | if [[ "$1" == '--' ]]; then shift; fi
 70 | 
 71 | devices() {
 72 |     if [[ -n "$DEVICE" ]]; then
 73 |         echo "$DEVICE"
 74 |     else
 75 |         curl ${CURL_OPTS} "$HOST:$CMDS_PORT/api/v2/device/all" | jq '[.deviceCoreCommands[]|select(.profileName | startswith("LLRP"))]'
 76 |     fi
 77 | }
 78 | 
 79 | put_file() {
 80 |     if [[ $# -ne 3 ]]; then
 81 |         usage; exit
 82 |     fi
 83 |     
 84 |     if [[ "$1" == "put" ]]; then
 85 |         CMD_NAME="${2}"
 86 |     else
 87 |         CMD_NAME="${2}"
 88 |     fi
 89 |     TYPE=${2}
 90 |     FILE_PATH="${3}"
 91 |     
 92 |     devices | jq '.[].coreCommands[]|select(.name=="'"$CMD_NAME"'")|.url+.path' | \
 93 |             sed -e "s/edgex-core-command/${HOST}/" | \
 94 |             xargs -L1 curl ${CURL_OPTS} -X PUT -H 'Content-Type: application/json' \
 95 |             --data '@'<(echo "{\"${TYPE}\":$(<"$FILE_PATH")}")
 96 | }
 97 | 
 98 | put() {
 99 |     set -x
100 | 
101 |     devices | jq '.[].coreCommands[]|select(.name=="'"${2}"'")|.url+.path' | \
102 |             sed -e "s/edgex-core-command/${HOST}/" | \
103 |             xargs -L1 curl ${CURL_OPTS} -X PUT -H 'Content-Type: application/json' \
104 |             --data "${3}" 
105 | }
106 | 
107 | put_num() {
108 |     if [[ $# -ne 3 ]]; then
109 |         usage; exit
110 |     fi
111 |     
112 |     CMD_NAME="${1}${2}"
113 |     TYPE="${2}ID"
114 |     NUM="${3}"
115 |     devices | jq '.[].coreCommands[]|select(.name=="'"$CMD_NAME"'")|.url+.path' | sed -e "s/edgex-core-command/${HOST}/" | \
116 |             xargs -L1 curl ${CURL_OPTS} -X PUT -H 'Content-Type: application/json' \
117 |             --data '{"'"$TYPE"'": "'"$NUM"'"}'
118 | }
119 | 
120 | get() {
121 |     if [[ $# -gt 2 ]]; then
122 |         usage; exit
123 |     fi
124 |     
125 |     if [[ "$1" == "pull" ]]; then
126 |         CMD_NAME="${2}"
127 |     else
128 |         CMD_NAME="${1}"
129 |     fi
130 |     
131 |     devices | jq '.[].coreCommands[]|select(.name=="'"$CMD_NAME"'") | .url+.path' | \
132 |             sed -e "s/edgex-core-command/${HOST}/" | \
133 |             xargs -L1  curl ${CURL_OPTS} | jq '.event.readings[].objectValue'
134 | }
135 | 
136 | list() {
137 |     if [[ $# -ne 1 ]]; then
138 |         echo "list takes one argument"
139 |         usage; exit
140 |     fi
141 |     
142 |     case "$1" in 
143 |     devices)
144 |         devices | jq '.[].deviceName' | tr -d '"'
145 |         ;;
146 |     commands)
147 |         devices | jq '.[].coreCommands[]' | \
148 |              jq -s '.|=.'
149 |         ;;
150 |     *)
151 |         echo "unknown list request: $1"
152 |         usage; exit
153 |         ;;
154 |     esac
155 | }
156 | 
157 | if [[ $# -lt 1 ]]; then
158 |     echo "missing command"
159 |     usage; exit
160 | fi
161 | 
162 | case "$1" in
163 |     list)
164 |         shift; list "$@"
165 |         ;;
166 |     get)
167 |         shift; get "$@"
168 |         ;;
169 |     pull)
170 |         get "$@"
171 |         ;;
172 |     set | add)
173 |         put_file "$@"
174 |         ;;
175 |     put)
176 |         put "$@"
177 |         ;;
178 |     enable | start | stop | disable | delete)
179 |         put_num "$@"
180 |         ;;
181 |     *)
182 |         echo "unknown ACTION: $1"
183 |         usage
184 |         ;;
185 | esac
186 | 
187 | 
188 | 


--------------------------------------------------------------------------------
/examples/data.sh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | # data.sh - simple script to interact with EdgeX's core-data
  3 | #   to view RO reports, tag data, and/or EPCs.
  4 | #   Use --help to view usage.
  5 | 
  6 | set -euo pipefail
  7 | IFS=$'\n\t'
  8 | 
  9 | HOST=localhost
 10 | DATA_PORT=59880
 11 | CURL_OPTS="-o-"
 12 | REMOVE_NULLS=0
 13 | 
 14 | usage() {
 15 |     echo "usage:"
 16 |     echo "  $0 --help"
 17 |     echo "     show this message and exit."
 18 |     echo "  $0 [OPTS] TARGET"
 19 |     echo "     show JSON-formatted data matching TARGET"
 20 |     echo ""
 21 |     echo "TARGET:"
 22 |     echo "    notifications       reader event notification"
 23 |     echo "    reports             full RO access reports"
 24 |     echo "    tags                just the tag data portion of reports"
 25 |     echo "    epcs                just the EPCs from tag data portions of reports"
 26 |     echo ""
 27 |     echo "OPTS:"
 28 |     echo "    -h | --host HOST    edgex-core-data host   default: localhost"
 29 |     echo "    -p | --port PORT    edgex-core-data port   default: 59880"
 30 |     echo "    -v | --verbose      use verbose curl output"
 31 |     echo "    -s | --silent       use silent curl output"
 32 |     echo "    -f | --filter-null  skip null values in reports and tags"
 33 | }
 34 | 
 35 | if [[ $# -lt 1 ]]; then
 36 |   usage; exit
 37 | fi
 38 | 
 39 | # read options
 40 | while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in
 41 |   -h | --host )
 42 |     shift; HOST=$1
 43 |     ;;
 44 |   -p | --core-cmds-port )
 45 |     shift; DATA_PORT=$1
 46 |     ;;
 47 |   -v | --verbose )
 48 |     CURL_OPTS="-vvvvo-"
 49 |     ;;
 50 |   -s | --silent )
 51 |     CURL_OPTS='-so-'
 52 |     ;;
 53 |   -f | --filter-null)
 54 |     REMOVE_NULLS=1
 55 |     ;;
 56 |   --help )
 57 |     usage; exit
 58 |     ;;
 59 |   *)
 60 |     echo "unknown flag $1"
 61 |     usage; exit
 62 |     ;;
 63 | esac; shift; done
 64 | if [[ "$1" == '--' ]]; then shift; fi
 65 | 
 66 | if [[ $# -lt 1 ]]; then
 67 |     echo "missing target"
 68 |     usage; exit
 69 | elif [[ $# -gt 1 ]]; then
 70 |     echo "extra args"
 71 |     usage; exit
 72 | fi
 73 | 
 74 | # get up to 1000 readings from EdgeX's core-data and return reading[].value as unquoted json
 75 | get() {
 76 |   TARGET=$1
 77 |   curl ${CURL_OPTS} "${HOST}":"${DATA_PORT}"/api/v2/reading/all?limit=50 | jq '.readings[].objectValue'
 78 | }
 79 | 
 80 | # based on the target, get some data and filter it
 81 | case "$1" in
 82 |     notifications)
 83 |         shift; get ReaderEventNotification
 84 |     ;;
 85 |     reports)
 86 |         if [[ $REMOVE_NULLS -eq 1 ]]; then
 87 |           # Strip nulls, remove empty reports, unwrap, and do a final filtering pass.
 88 |           shift; get ROAccessReport |
 89 |               jq 'with_entries(select(.value!=null))|select(any(.))|.[]|.[]|with_entries(select(.value!=null))'
 90 |         else
 91 |           shift; get ROAccessReport
 92 |         fi
 93 |     ;;
 94 |     tags)
 95 |         # LLRP distinguishes arbitrary data in the EPC memory bank vs bona fide EPC-96s,
 96 |         # but this filter destructure them into a common EPC field and removes the old ones.
 97 |         # A real client should probably keep them separate.
 98 |         if [[ $REMOVE_NULLS -eq 1 ]]; then
 99 |           shift; get ROAccessReport | \
100 |             jq '.TagReportData[]?|with_entries(select(.value!=null))|.+{EPC:(.EPCData.EPC//.EPC96.EPC)}|del(.EPCData)|del(.EPC96)'
101 |         else
102 |           shift; get ROAccessReport | \
103 |             jq '.TagReportData[]?|.+{EPC:(.EPCData.EPC//.EPC96.EPC)}|del(.EPCData)|del(.EPC96)'
104 |         fi
105 |     ;;
106 |     epcs)
107 |         # extract tags, decode from base64 to hex, then output how many times we saw each one.
108 |         shift; get ROAccessReport | jq '.TagReportData[]?|.EPC96.EPC//.EPCData.EPC' | \
109 |           tr -d '"' | base64 -d | od --endian=big -t x2 -An -w12 -v | sort | uniq -c
110 |     ;;
111 |     *)
112 |         echo "unknown target: $1"
113 |         usage
114 |     ;;
115 | esac
116 | 
117 | 
118 | 


--------------------------------------------------------------------------------
/examples/example.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | # example.sh - sends an ROSpec, enables it,
 3 | #   waits a bit, prints tag reads, disables/deletes the RO.
 4 | #
 5 | # This script is very simple and has basically no error checking.
 6 | # Use at your own risk.
 7 | #
 8 | # This script assumes you have the following tools available:
 9 | #   jq, sed, xargs, curl, base64, od
10 | # And it assumes the service/edgex is already running correctly.
11 | # The host & ports it will use are found in the variables below:
12 | 
13 | HOST=localhost
14 | DATA_PORT=59880
15 | META_PORT=59881
16 | CMDS_PORT=59882
17 | ROSPEC_LOCATION="ROSpec.json"
18 | 
19 | set -euo pipefail
20 | IFS=$'\n\t'
21 | 
22 | # Get the first device
23 | device=$(curl -so- ${HOST}:${META_PORT}/api/v2/device/all | jq '[.devices[]|select(.serviceName=="device-rfid-llrp" )]' | jq '.[0].name' | tr -d '"')
24 | dev_url=${HOST}:${CMDS_PORT}/api/v2/device/name/${device}
25 | 
26 | echo "Using ${dev_url}"
27 | 
28 | 
29 | # Add an ROSpec
30 | echo "Adding ROSpec ${ROSPEC_LOCATION}"
31 | curl -so- "${dev_url}" | jq '.deviceCoreCommand.coreCommands[]|select(.name=="ROSpec")|.url+.path' | sed -e "s/edgex-core-command/${HOST}/" | xargs -L1 \
32 |     curl -so- -X PUT -H 'Content-Type: application/json' --data '@'<(echo "{\"ROSpec\":$(<"$ROSPEC_LOCATION")}") 
33 | 
34 | # Get ROSpecs
35 | echo "Getting ROSpecs from Reader"
36 | curl -so- "${dev_url}" | jq '.deviceCoreCommand.coreCommands[]|select(.name=="ROSpec")|.url+.path' | sed -e "s/edgex-core-command/${HOST}/" | xargs -L1 \
37 |      curl -so- | jq '.event.readings[].objectValue.ROSpecs'
38 | ​
39 | # Enable ROSpec
40 | echo "Enabling ROSpec 1"
41 | curl -so- "${dev_url}" | jq '.deviceCoreCommand.coreCommands[]|select(.name=="enableROSpec")|.url+.path' | sed -e "s/edgex-core-command/${HOST}/" | xargs -L1 \
42 |     curl -so- -X PUT -H 'Content-Type: application/json' --data '{"ROSpecID": "1"}'
43 | ​
44 | # wait a bit
45 | for i in {10..1}; do
46 |     echo "Waiting ${i} more seconds..."
47 |     sleep 1
48 | done
49 | ​
50 | ​
51 | # Disable ROSpec
52 | echo "Disabling ROSpec 1"
53 | curl -so- "${dev_url}" | jq '.deviceCoreCommand.coreCommands[]|select(.name=="disableROSpec")|.url+.path' | sed -e "s/edgex-core-command/${HOST}/" | xargs -L1 \
54 |     curl -so- -X PUT -H 'Content-Type: application/json' --data '{"ROSpecID": "1"}'
55 | ​
56 | # Delete ROSpec
57 | echo "Deleting ROSpec 1"
58 | curl -so- "${dev_url}" | jq '.deviceCoreCommand.coreCommands[]|select(.name=="deleteROSpec")|.url+.path' | sed -e "s/edgex-core-command/${HOST}/" | xargs -L1 \
59 |     curl -so- -X PUT -H 'Content-Type: application/json' --data '{"ROSpecID": "1"}'
60 | ​
61 | # See collected EPCs (assuming EPC96)
62 | echo "Displaying EPCs"
63 | curl -so- ${HOST}:${DATA_PORT}/api/v2/reading/all?limit=1000 | \
64 |     jq '.readings[].objectValue.TagReportData[]?|.EPC96.EPC//.EPCData.EPC' | tr -d '"' | base64 -d | od --endian=big -t x2 -An -w12 -v | sort | uniq -c
65 | 


--------------------------------------------------------------------------------
/examples/impinjCustomConfReq.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ResetToFactoryDefaults": false,
 3 | 	"ReaderEventNotificationSpec": {
 4 | 		"EventNotificationStates": [
 5 | 			{
 6 | 				"ReaderEventType": 4,
 7 | 				"NotificationEnabled": true
 8 | 			},
 9 | 			{
10 | 				"ReaderEventType": 3,
11 | 				"NotificationEnabled": true
12 | 			},
13 | 			{
14 | 				"ReaderEventType": 8,
15 | 				"NotificationEnabled": true
16 | 			}
17 | 		]
18 | 	},
19 | 	"AntennaProperties": null,
20 | 	"AntennaConfigurations": null,
21 | 	"ROReportSpec": null,
22 | 	"AccessReportSpec": null,
23 | 	"KeepAliveSpec": {
24 | 		"Trigger": 1,
25 | 		"Interval": 180000
26 | 	},
27 | 	"GPOWriteData": null,
28 | 	"GPIPortCurrentStates": null,
29 | 	"EventsAndReports": null,
30 | 	"Custom": null
31 | }
32 | 


--------------------------------------------------------------------------------
/examples/readImpinjTID.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | # This example uses the standalone cmd/llrp executable
 4 | # to connect to an Impinj Reader, send it Custom messages,
 5 | # singulating for 5s, and reading the TID of each tag.
 6 | # It shows how the LLRP library can be used without EdgeX,
 7 | # but doing so requires launching new instances per Reader,
 8 | # implementing your own discovery and reconnection logic (if applicable),
 9 | # and collecting the output data to forward/process elsewhere.
10 | 
11 | READER_ADDR='192.168.86.88:5084'
12 | PROJ_DIR=$(dirname "$0")'/..' # assumes script is in {project root}/examples
13 | EXAMPLES="${PROJ_DIR}/examples"
14 | 
15 | # build the executable
16 | MOD_NAME=$(go list "${PROJ_DIR}")
17 | CMD_DIR="${PROJ_DIR}/cmd/llrp"
18 | go build -o "${CMD_DIR}/llrp" "${MOD_NAME}/cmd/llrp"
19 | 
20 | # The llrp executable has more options; run it with the -help flag to see them.
21 | "./${CMD_DIR}/llrp" -rfid=${READER_ADDR} \
22 |   -custom="${EXAMPLES}/ImpinjEnableCustomExt.json" \
23 |   -access="${EXAMPLES}/AccessSpec.json" \
24 |   -ro="${EXAMPLES}/ImpinjReadFast.json" \
25 |   -watch-for=5s
26 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
  1 | module github.com/edgexfoundry/device-rfid-llrp-go
  2 | 
  3 | go 1.23
  4 | 
  5 | require (
  6 | 	github.com/edgexfoundry/device-sdk-go/v4 v4.0.0
  7 | 	github.com/edgexfoundry/go-mod-core-contracts/v4 v4.0.1
  8 | 	github.com/stretchr/testify v1.10.0
  9 | )
 10 | 
 11 | require (
 12 | 	github.com/Microsoft/go-winio v0.6.2 // indirect
 13 | 	github.com/OneOfOne/xxhash v1.2.8 // indirect
 14 | 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
 15 | 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 16 | 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 17 | 	github.com/eclipse/paho.mqtt.golang v1.5.0 // indirect
 18 | 	github.com/edgexfoundry/go-mod-bootstrap/v4 v4.0.3 // indirect
 19 | 	github.com/edgexfoundry/go-mod-configuration/v4 v4.0.1 // indirect
 20 | 	github.com/edgexfoundry/go-mod-messaging/v4 v4.0.1 // indirect
 21 | 	github.com/edgexfoundry/go-mod-registry/v4 v4.0.1 // indirect
 22 | 	github.com/edgexfoundry/go-mod-secrets/v4 v4.0.1 // indirect
 23 | 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 24 | 	github.com/fullsailor/pkcs7 v0.0.0-20190404230743-d7302db945fa // indirect
 25 | 	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
 26 | 	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
 27 | 	github.com/go-jose/go-jose/v4 v4.0.5 // indirect
 28 | 	github.com/go-kit/log v0.2.1 // indirect
 29 | 	github.com/go-logfmt/logfmt v0.5.1 // indirect
 30 | 	github.com/go-logr/logr v1.4.2 // indirect
 31 | 	github.com/go-logr/stdr v1.2.2 // indirect
 32 | 	github.com/go-ole/go-ole v1.2.6 // indirect
 33 | 	github.com/go-openapi/analysis v0.23.0 // indirect
 34 | 	github.com/go-openapi/errors v0.22.0 // indirect
 35 | 	github.com/go-openapi/jsonpointer v0.21.0 // indirect
 36 | 	github.com/go-openapi/jsonreference v0.21.0 // indirect
 37 | 	github.com/go-openapi/loads v0.22.0 // indirect
 38 | 	github.com/go-openapi/runtime v0.28.0 // indirect
 39 | 	github.com/go-openapi/spec v0.21.0 // indirect
 40 | 	github.com/go-openapi/strfmt v0.23.0 // indirect
 41 | 	github.com/go-openapi/swag v0.23.0 // indirect
 42 | 	github.com/go-openapi/validate v0.24.0 // indirect
 43 | 	github.com/go-playground/locales v0.14.1 // indirect
 44 | 	github.com/go-playground/universal-translator v0.18.1 // indirect
 45 | 	github.com/go-playground/validator/v10 v10.25.0 // indirect
 46 | 	github.com/go-resty/resty/v2 v2.16.4 // indirect
 47 | 	github.com/golang-jwt/jwt/v5 v5.2.1 // indirect
 48 | 	github.com/google/uuid v1.6.0 // indirect
 49 | 	github.com/gorilla/mux v1.8.1 // indirect
 50 | 	github.com/gorilla/schema v1.4.1 // indirect
 51 | 	github.com/gorilla/securecookie v1.1.2 // indirect
 52 | 	github.com/gorilla/websocket v1.5.3 // indirect
 53 | 	github.com/hashicorp/errwrap v1.1.0 // indirect
 54 | 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 55 | 	github.com/josharian/intern v1.0.0 // indirect
 56 | 	github.com/kataras/go-events v0.0.3 // indirect
 57 | 	github.com/klauspost/compress v1.17.9 // indirect
 58 | 	github.com/labstack/echo/v4 v4.13.3 // indirect
 59 | 	github.com/labstack/gommon v0.4.2 // indirect
 60 | 	github.com/leodido/go-urn v1.4.0 // indirect
 61 | 	github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
 62 | 	github.com/mailru/easyjson v0.7.7 // indirect
 63 | 	github.com/mattn/go-colorable v0.1.14 // indirect
 64 | 	github.com/mattn/go-isatty v0.0.20 // indirect
 65 | 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 66 | 	github.com/michaelquigley/pfxlog v0.6.10 // indirect
 67 | 	github.com/miekg/pkcs11 v1.1.1 // indirect
 68 | 	github.com/mitchellh/copystructure v1.2.0 // indirect
 69 | 	github.com/mitchellh/go-ps v1.0.0 // indirect
 70 | 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 71 | 	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 72 | 	github.com/muhlemmer/gu v0.3.1 // indirect
 73 | 	github.com/nats-io/nats.go v1.39.1 // indirect
 74 | 	github.com/nats-io/nkeys v0.4.9 // indirect
 75 | 	github.com/nats-io/nuid v1.0.1 // indirect
 76 | 	github.com/oklog/ulid v1.3.1 // indirect
 77 | 	github.com/opentracing/opentracing-go v1.2.0 // indirect
 78 | 	github.com/openziti/channel/v3 v3.0.27 // indirect
 79 | 	github.com/openziti/edge-api v0.26.38 // indirect
 80 | 	github.com/openziti/foundation/v2 v2.0.56 // indirect
 81 | 	github.com/openziti/identity v1.0.94 // indirect
 82 | 	github.com/openziti/metrics v1.2.65 // indirect
 83 | 	github.com/openziti/sdk-golang v0.24.1 // indirect
 84 | 	github.com/openziti/secretstream v0.1.28 // indirect
 85 | 	github.com/openziti/transport/v2 v2.0.160 // indirect
 86 | 	github.com/orcaman/concurrent-map/v2 v2.0.1 // indirect
 87 | 	github.com/panjf2000/ants/v2 v2.11.2 // indirect
 88 | 	github.com/parallaxsecond/parsec-client-go v0.0.0-20221025095442-f0a77d263cf9 // indirect
 89 | 	github.com/pkg/errors v0.9.1 // indirect
 90 | 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 91 | 	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
 92 | 	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
 93 | 	github.com/shirou/gopsutil/v3 v3.24.5 // indirect
 94 | 	github.com/shoenig/go-m1cpu v0.1.6 // indirect
 95 | 	github.com/sirupsen/logrus v1.9.3 // indirect
 96 | 	github.com/speps/go-hashids v2.0.0+incompatible // indirect
 97 | 	github.com/spf13/cast v1.7.1 // indirect
 98 | 	github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect
 99 | 	github.com/stretchr/objx v0.5.2 // indirect
100 | 	github.com/tklauser/go-sysconf v0.3.12 // indirect
101 | 	github.com/tklauser/numcpus v0.6.1 // indirect
102 | 	github.com/valyala/bytebufferpool v1.0.0 // indirect
103 | 	github.com/valyala/fasttemplate v1.2.2 // indirect
104 | 	github.com/x448/float16 v0.8.4 // indirect
105 | 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
106 | 	github.com/zeebo/errs v1.4.0 // indirect
107 | 	github.com/zitadel/oidc/v2 v2.12.2 // indirect
108 | 	go.mongodb.org/mongo-driver v1.17.0 // indirect
109 | 	go.mozilla.org/pkcs7 v0.9.0 // indirect
110 | 	go.opentelemetry.io/otel v1.32.0 // indirect
111 | 	go.opentelemetry.io/otel/metric v1.32.0 // indirect
112 | 	go.opentelemetry.io/otel/trace v1.32.0 // indirect
113 | 	golang.org/x/crypto v0.33.0 // indirect
114 | 	golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63 // indirect
115 | 	golang.org/x/net v0.35.0 // indirect
116 | 	golang.org/x/oauth2 v0.25.0 // indirect
117 | 	golang.org/x/sync v0.11.0 // indirect
118 | 	golang.org/x/sys v0.30.0 // indirect
119 | 	golang.org/x/term v0.29.0 // indirect
120 | 	golang.org/x/text v0.22.0 // indirect
121 | 	golang.org/x/time v0.8.0 // indirect
122 | 	google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a // indirect
123 | 	google.golang.org/grpc v1.70.0 // indirect
124 | 	google.golang.org/protobuf v1.36.3 // indirect
125 | 	gopkg.in/go-jose/go-jose.v2 v2.6.3 // indirect
126 | 	gopkg.in/yaml.v3 v3.0.1 // indirect
127 | 	nhooyr.io/websocket v1.8.17 // indirect
128 | )
129 | 


--------------------------------------------------------------------------------
/images/delete_consul.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/images/delete_consul.png


--------------------------------------------------------------------------------
/internal/driver/config.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | package driver
 7 | 
 8 | // CustomConfig holds the values for the driver configuration
 9 | type CustomConfig struct {
10 | 	// DiscoverySubnets holds a comma separated list of CIDR subnets to scan for devices. This is kept as a string instead
11 | 	// of a string slice because when using EdgeX's Consul implementation, the data returned is a slice of 1 element
12 | 	// containing the entire string.
13 | 	DiscoverySubnets string
14 | 	// ProbeAsyncLimit specifies the maximum simultaneous network probes when performing a discovery
15 | 	ProbeAsyncLimit int
16 | 	// ProbeTimeoutSeconds specifies the maximum amount of seconds to wait for each IP probe before timing out
17 | 	ProbeTimeoutSeconds int
18 | 	// ScanPort is the port to scan for LLRP devices on
19 | 	ScanPort string
20 | 	// MaxDiscoverDurationSeconds is the maximum amount of seconds for a discovery to run. It is important
21 | 	// to have this configured in the case of larger subnets such as /16 and /8
22 | 	MaxDiscoverDurationSeconds int
23 | 
24 | 	// Location of Provision Watchers
25 | 	ProvisionWatcherDir string
26 | }
27 | 
28 | // ServiceConfig a struct that wraps CustomConfig which holds the values for driver configuration
29 | type ServiceConfig struct {
30 | 	AppCustom CustomConfig
31 | }
32 | 
33 | // UpdateFromRaw updates the service's full configuration from raw data received from
34 | // the Service Provider.
35 | func (c *ServiceConfig) UpdateFromRaw(rawConfig interface{}) bool {
36 | 	configuration, ok := rawConfig.(*ServiceConfig)
37 | 	if !ok {
38 | 		return false
39 | 	}
40 | 
41 | 	*c = *configuration
42 | 
43 | 	return true
44 | }
45 | 


--------------------------------------------------------------------------------
/internal/driver/config_test.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | package driver
 7 | 
 8 | import (
 9 | 	"testing"
10 | 
11 | 	"github.com/stretchr/testify/assert"
12 | )
13 | 
14 | func TestUpdateFromRaw(t *testing.T) {
15 | 	expectedConfig := &ServiceConfig{
16 | 		AppCustom: CustomConfig{
17 | 			DiscoverySubnets:           "127.0.0.1/32,127.0.1.1/32",
18 | 			ProbeAsyncLimit:            50,
19 | 			ProbeTimeoutSeconds:        1,
20 | 			ScanPort:                   "666",
21 | 			MaxDiscoverDurationSeconds: 5,
22 | 		},
23 | 	}
24 | 	testCases := []struct {
25 | 		Name      string
26 | 		rawConfig interface{}
27 | 		isValid   bool
28 | 	}{
29 | 		{
30 | 			Name:      "valid",
31 | 			isValid:   true,
32 | 			rawConfig: expectedConfig,
33 | 		},
34 | 		{
35 | 			Name:      "not valid",
36 | 			isValid:   false,
37 | 			rawConfig: expectedConfig.AppCustom,
38 | 		},
39 | 	}
40 | 
41 | 	for _, testCase := range testCases {
42 | 		t.Run(testCase.Name, func(t *testing.T) {
43 | 			actualConfig := ServiceConfig{}
44 | 
45 | 			ok := actualConfig.UpdateFromRaw(testCase.rawConfig)
46 | 
47 | 			assert.Equal(t, testCase.isValid, ok)
48 | 			if testCase.isValid {
49 | 				assert.Equal(t, expectedConfig, &actualConfig)
50 | 			}
51 | 		})
52 | 	}
53 | 
54 | }
55 | 


--------------------------------------------------------------------------------
/internal/driver/discover_test.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package driver
  7 | 
  8 | import (
  9 | 	"context"
 10 | 	"encoding/binary"
 11 | 	"fmt"
 12 | 	"net"
 13 | 	"os"
 14 | 	"strconv"
 15 | 	"sync"
 16 | 	"sync/atomic"
 17 | 	"testing"
 18 | 	"time"
 19 | 
 20 | 	"github.com/edgexfoundry/device-rfid-llrp-go/pkg/llrp"
 21 | 	"github.com/edgexfoundry/device-sdk-go/v4/pkg/interfaces/mocks"
 22 | 	"github.com/edgexfoundry/go-mod-core-contracts/v4/clients/logger"
 23 | 	"github.com/edgexfoundry/go-mod-core-contracts/v4/models"
 24 | 	"github.com/stretchr/testify/mock"
 25 | )
 26 | 
 27 | type inetTest struct {
 28 | 	inet  string
 29 | 	first string
 30 | 	last  string
 31 | 	size  uint32
 32 | 	err   bool
 33 | }
 34 | 
 35 | var (
 36 | 	svc = &mocks.DeviceServiceSDK{}
 37 | )
 38 | 
 39 | func TestMain(m *testing.M) {
 40 | 	_ = Instance()
 41 | 
 42 | 	driver.svc = svc
 43 | 	driver.lc = logger.NewClient("test", "DEBUG")
 44 | 
 45 | 	svc.On("Devices").Return([]models.Device{})
 46 | 
 47 | 	os.Exit(m.Run())
 48 | }
 49 | 
 50 | func makeParams() discoverParams {
 51 | 	return discoverParams{
 52 | 		subnets:    []string{"127.0.0.1/32"},
 53 | 		asyncLimit: 5000,
 54 | 		timeout:    1 * time.Second,
 55 | 		scanPort:   "59923",
 56 | 	}
 57 | }
 58 | 
 59 | // todo: add unit tests for re-discovering disabled devices, and device ip changes
 60 | 
 61 | // TestAutoDiscoverNaming tests the naming of discovered devices using various
 62 | // different known and unknown vendors and models. It also tests the difference between
 63 | // mac based and epc based identification.
 64 | func TestAutoDiscoverNaming(t *testing.T) {
 65 | 	params := makeParams()
 66 | 
 67 | 	tests := []struct {
 68 | 		name        string
 69 | 		description string
 70 | 		identity    llrp.Identification
 71 | 		caps        llrp.GeneralDeviceCapabilities
 72 | 	}{
 73 | 		{
 74 | 			name:        "SpeedwayR-19-C5-D6",
 75 | 			description: "Test standard Speedway R420",
 76 | 			identity: llrp.Identification{
 77 | 				IDType:   llrp.ID_MAC_EUI64,
 78 | 				ReaderID: []byte{0x00, 0x00, 0x00, 0x00, 0x19, 0xC5, 0xD6},
 79 | 			},
 80 | 			caps: llrp.GeneralDeviceCapabilities{
 81 | 				DeviceManufacturer: uint32(Impinj),
 82 | 				Model:              uint32(SpeedwayR420),
 83 | 				FirmwareVersion:    "5.14.0.240",
 84 | 			},
 85 | 		},
 86 | 		{
 87 | 			name:        "xArray-25-9C-D4",
 88 | 			description: "Test standard xArray",
 89 | 			identity: llrp.Identification{
 90 | 				IDType:   llrp.ID_MAC_EUI64,
 91 | 				ReaderID: []byte{0x00, 0x00, 0x00, 0x00, 0x25, 0x9C, 0xD4},
 92 | 			},
 93 | 			caps: llrp.GeneralDeviceCapabilities{
 94 | 				DeviceManufacturer: uint32(Impinj),
 95 | 				Model:              uint32(XArray),
 96 | 				FirmwareVersion:    "5.14.0.240",
 97 | 			},
 98 | 		},
 99 | 		{
100 | 			name:        "LLRP-D2-7F-A1",
101 | 			description: "Test unknown Impinj model with MAC_EUI64 ID type",
102 | 			identity: llrp.Identification{
103 | 				IDType:   llrp.ID_MAC_EUI64,
104 | 				ReaderID: []byte{0x00, 0x00, 0x00, 0x00, 0xD2, 0x7F, 0xA1},
105 | 			},
106 | 			caps: llrp.GeneralDeviceCapabilities{
107 | 				DeviceManufacturer: uint32(Impinj),
108 | 				Model:              uint32(0x32), // unknown model
109 | 				FirmwareVersion:    "7.0.0",
110 | 			},
111 | 		},
112 | 		{
113 | 			name:        "LLRP-302411f9c92d4f",
114 | 			description: "Test unknown Impinj model with EPC ID type",
115 | 			identity: llrp.Identification{
116 | 				IDType:   llrp.ID_EPC,
117 | 				ReaderID: []byte{0x30, 0x24, 0x11, 0xF9, 0xC9, 0x2D, 0x4F},
118 | 			},
119 | 			caps: llrp.GeneralDeviceCapabilities{
120 | 				DeviceManufacturer: uint32(Impinj),
121 | 				Model:              uint32(0x32), // unknown model
122 | 				FirmwareVersion:    "7.0.0",
123 | 			},
124 | 		},
125 | 		{
126 | 			name:        "LLRP-FC-4D-1A",
127 | 			description: "Test unknown vendor and unknown model with MAC_EUI64 ID type",
128 | 			identity: llrp.Identification{
129 | 				IDType:   llrp.ID_MAC_EUI64,
130 | 				ReaderID: []byte{0x00, 0x00, 0x00, 0x00, 0xFC, 0x4D, 0x1A},
131 | 			},
132 | 			caps: llrp.GeneralDeviceCapabilities{
133 | 				DeviceManufacturer: uint32(0x32), // unknown vendor
134 | 				Model:              uint32(0x32), // unknown model
135 | 				FirmwareVersion:    "1.0.0",
136 | 			},
137 | 		},
138 | 		{
139 | 			name:        "LLRP-001a004fd9ca2b",
140 | 			description: "Test unknown vendor and unknown model with EPC ID type",
141 | 			identity: llrp.Identification{
142 | 				IDType:   llrp.ID_EPC,                                      // test non-mac id types
143 | 				ReaderID: []byte{0x00, 0x1A, 0x00, 0x4F, 0xD9, 0xCA, 0x2B}, // will be used as-is, not parsed
144 | 			},
145 | 			caps: llrp.GeneralDeviceCapabilities{
146 | 				DeviceManufacturer: uint32(0x32), // unknown vendor
147 | 				Model:              uint32(0x32), // unknown model
148 | 				FirmwareVersion:    "1.0.0",
149 | 			},
150 | 		},
151 | 	}
152 | 
153 | 	// create a fake rx sensitivity table to produce a more valid GetReaderCapabilitiesResponse
154 | 	var i uint16
155 | 	sensitivities := make([]llrp.ReceiveSensitivityTableEntry, 11)
156 | 	for i = 1; i <= 11; i++ {
157 | 		sensitivities = append(sensitivities, llrp.ReceiveSensitivityTableEntry{
158 | 			Index:              i,
159 | 			ReceiveSensitivity: 10 + (4 * (i - 1)), // min 10, max 50
160 | 		})
161 | 	}
162 | 
163 | 	scanPort, err := strconv.Atoi(params.scanPort)
164 | 	if err != nil {
165 | 		t.Fatalf("Failed to parse driver.config.ScanPort, unable to run discovery tests. value = %v", params.scanPort)
166 | 	}
167 | 
168 | 	for _, test := range tests {
169 | 		test := test
170 | 		t.Run(test.name, func(t *testing.T) {
171 | 			svc.On("GetDeviceByName", mock.Anything).Return(models.Device{}, fmt.Errorf("error")).Once()
172 | 			emu := llrp.NewTestEmulator(!testing.Verbose())
173 | 			if err := emu.StartAsync(scanPort); err != nil {
174 | 				t.Fatalf("unable to start emulator: %+v", err)
175 | 			}
176 | 			defer func() {
177 | 				if err := emu.Shutdown(); err != nil {
178 | 					t.Errorf("error shutting down test emulator: %s", err.Error())
179 | 				}
180 | 			}()
181 | 
182 | 			readerConfig := llrp.GetReaderConfigResponse{
183 | 				Identification: &test.identity,
184 | 			}
185 | 			emu.SetResponse(llrp.MsgGetReaderConfig, &readerConfig)
186 | 
187 | 			test.caps.ReceiveSensitivities = sensitivities
188 | 			readerCaps := llrp.GetReaderCapabilitiesResponse{
189 | 				GeneralDeviceCapabilities: &test.caps,
190 | 			}
191 | 			emu.SetResponse(llrp.MsgGetReaderCapabilities, &readerCaps)
192 | 
193 | 			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
194 | 			defer cancel()
195 | 
196 | 			discovered := autoDiscover(ctx, params)
197 | 			if len(discovered) != 1 {
198 | 				t.Fatalf("expected 1 discovered device, however got: %d", len(discovered))
199 | 			}
200 | 
201 | 			if discovered[0].Name != test.name {
202 | 				t.Errorf("expected discovered device's name to be %s, but was: %s", test.name, discovered[0].Name)
203 | 			}
204 | 
205 | 			pen, ok := discovered[0].Protocols["metadata"]["vendorPEN"]
206 | 			if !ok {
207 | 				t.Fatalf("Missing vendorPEN field in metadata protocol. ProtocolMap: %+v", discovered[0].Protocols)
208 | 			}
209 | 			if pen != strconv.FormatUint(uint64(test.caps.DeviceManufacturer), 10) {
210 | 				t.Errorf("expected vendorPEN to be %v, but was: %s", test.caps.DeviceManufacturer, pen)
211 | 			}
212 | 
213 | 			fw, ok := discovered[0].Protocols["metadata"]["fwVersion"]
214 | 			if !ok {
215 | 				t.Fatalf("Missing fwVersion field in metadata protocol. ProtocolMap: %+v", discovered[0].Protocols)
216 | 			}
217 | 			if fw != test.caps.FirmwareVersion {
218 | 				t.Errorf("expected fwVersion to be %v, but was: %s", test.caps.FirmwareVersion, fw)
219 | 			}
220 | 		})
221 | 	}
222 | }
223 | 
224 | // TestAutoDiscover uses an emulator to fake discovery process on localhost.
225 | // It checks:
226 | // 1. That no devices are discovered when the emulator is not running
227 | // 2. It discovers the emulator ok when it is running
228 | // 3. It does not re-discover the emulator when it is already registered with EdgeX
229 | func TestAutoDiscover(t *testing.T) {
230 | 	params := makeParams()
231 | 
232 | 	// attempt to discover without emulator, expect none found
233 | 
234 | 	discovered := autoDiscover(context.Background(), params)
235 | 	if len(discovered) != 0 {
236 | 		t.Fatalf("expected 0 discovered devices, however got: %d", len(discovered))
237 | 	}
238 | 
239 | 	// attempt to discover WITH emulator, expect emulator to be found
240 | 	port, err := strconv.Atoi(params.scanPort)
241 | 	if err != nil {
242 | 		t.Fatalf("Failed to parse driver.config.ScanPort, unable to run discovery tests. value = %v", params.scanPort)
243 | 	}
244 | 	emu := llrp.NewTestEmulator(!testing.Verbose())
245 | 	if err := emu.StartAsync(port); err != nil {
246 | 		t.Fatalf("unable to start emulator: %+v", err)
247 | 	}
248 | 
249 | 	readerConfig := llrp.GetReaderConfigResponse{
250 | 		Identification: &llrp.Identification{
251 | 			IDType:   llrp.ID_MAC_EUI64,
252 | 			ReaderID: []byte{0x00, 0x00, 0x00, 0x00, 0x19, 0xC5, 0xD6},
253 | 		},
254 | 	}
255 | 	emu.SetResponse(llrp.MsgGetReaderConfig, &readerConfig)
256 | 
257 | 	readerCaps := llrp.GetReaderCapabilitiesResponse{
258 | 		GeneralDeviceCapabilities: &llrp.GeneralDeviceCapabilities{
259 | 			MaxSupportedAntennas:    4,
260 | 			CanSetAntennaProperties: false,
261 | 			HasUTCClock:             true,
262 | 			DeviceManufacturer:      uint32(Impinj),
263 | 			Model:                   uint32(SpeedwayR420),
264 | 			FirmwareVersion:         "5.14.0.240",
265 | 		},
266 | 	}
267 | 	emu.SetResponse(llrp.MsgGetReaderCapabilities, &readerCaps)
268 | 
269 | 	svc.On("GetDeviceByName", mock.Anything).Return(models.Device{}, fmt.Errorf("error")).Once()
270 | 	discovered = autoDiscover(context.Background(), params)
271 | 	if len(discovered) != 1 {
272 | 		t.Fatalf("expected 1 discovered device, however got: %d", len(discovered))
273 | 	}
274 | 
275 | 	// attempt to discover again WITH emulator, however expect emulator to be skipped
276 | 
277 | 	svc.On("GetDeviceByName", mock.Anything).Return(models.Device{Name: discovered[0].Name, Protocols: discovered[0].Protocols}, nil).Once()
278 | 
279 | 	discovered = autoDiscover(context.Background(), params)
280 | 	if len(discovered) != 0 {
281 | 		t.Fatalf("expected no devices to be discovered, but was %d", len(discovered))
282 | 	}
283 | 
284 | 	if err := emu.Shutdown(); err != nil {
285 | 		t.Errorf("error shutting down test emulator: %+v", err)
286 | 	}
287 | }
288 | 
289 | func mockIpWorker(ipCh <-chan uint32, result *inetTest) {
290 | 	ip := net.IP([]byte{0, 0, 0, 0})
291 | 	var last uint32
292 | 
293 | 	for a := range ipCh {
294 | 		atomic.AddUint32(&result.size, 1)
295 | 		atomic.StoreUint32(&last, a)
296 | 
297 | 		if result.first == "" {
298 | 			binary.BigEndian.PutUint32(ip, a)
299 | 			result.first = ip.String()
300 | 		}
301 | 		binary.BigEndian.PutUint32(ip, last)
302 | 		result.last = ip.String()
303 | 	}
304 | 
305 | }
306 | 
307 | func ipGeneratorTest(input inetTest) (result inetTest) {
308 | 	var wg sync.WaitGroup
309 | 	ipCh := make(chan uint32, input.size)
310 | 
311 | 	wg.Add(1)
312 | 	go func() {
313 | 		defer wg.Done()
314 | 		mockIpWorker(ipCh, &result)
315 | 	}()
316 | 
317 | 	_, inet, err := net.ParseCIDR(input.inet)
318 | 	if err != nil {
319 | 		result.err = true
320 | 		return result
321 | 	}
322 | 
323 | 	ipGenerator(context.Background(), inet, ipCh)
324 | 	close(ipCh)
325 | 	wg.Wait()
326 | 
327 | 	return result
328 | }
329 | 
330 | // TestIpGenerator calls the ip generator and validates that the first ip, last ip, and size
331 | // match the expected values.
332 | func TestIpGenerator(t *testing.T) {
333 | 	tests := []inetTest{
334 | 		{
335 | 			inet:  "192.168.1.110/24",
336 | 			first: "192.168.1.1",
337 | 			last:  "192.168.1.254",
338 | 			size:  computeNetSz(24),
339 | 		},
340 | 		{
341 | 			inet:  "192.168.1.110/32",
342 | 			first: "192.168.1.110",
343 | 			last:  "192.168.1.110",
344 | 			size:  computeNetSz(32),
345 | 		},
346 | 		{
347 | 			inet:  "192.168.1.20/31",
348 | 			first: "192.168.1.20",
349 | 			last:  "192.168.1.20",
350 | 			size:  computeNetSz(31),
351 | 		},
352 | 		{
353 | 			inet:  "192.168.99.20/16",
354 | 			first: "192.168.0.1",
355 | 			last:  "192.168.255.254",
356 | 			size:  computeNetSz(16),
357 | 		},
358 | 		{
359 | 			inet:  "10.10.10.10/8",
360 | 			first: "10.0.0.1",
361 | 			last:  "10.255.255.254",
362 | 			size:  computeNetSz(8),
363 | 		},
364 | 	}
365 | 	for _, input := range tests {
366 | 		input := input
367 | 		t.Run(input.inet, func(t *testing.T) {
368 | 			t.Parallel()
369 | 			result := ipGeneratorTest(input)
370 | 			if result.err && !input.err {
371 | 				t.Error("got unexpected error")
372 | 			} else if !result.err && input.err {
373 | 				t.Error("expected an error, but no error was returned")
374 | 			} else {
375 | 				if result.size != input.size {
376 | 					t.Errorf("expected %d ips, but got %d", input.size, result.size)
377 | 				}
378 | 				if result.first != input.first {
379 | 					t.Errorf("expected first ip in range to be %s, but got %s", input.first, result.first)
380 | 				}
381 | 				if result.last != input.last {
382 | 					t.Errorf("expected last ip in range to be %s, but got %s", input.last, result.last)
383 | 				}
384 | 			}
385 | 		})
386 | 	}
387 | }
388 | 
389 | // TestIpGeneratorSubnetSizes calls the ip generator for various subnet sizes and validates that
390 | // the correct amount of IP addresses are generated
391 | func TestIpGeneratorSubnetSizes(t *testing.T) {
392 | 	// stop at 10 because the time taken gets exponentially longer
393 | 	for i := 32; i >= 10; i-- {
394 | 		i := i
395 | 		t.Run(strconv.Itoa(i), func(t *testing.T) {
396 | 			t.Parallel()
397 | 			result := ipGeneratorTest(inetTest{size: uint32(i), inet: fmt.Sprintf("192.168.1.1/%d", i)})
398 | 			if result.size != computeNetSz(i) {
399 | 				t.Errorf("expected %d ips, but got %d", computeNetSz(i), result.size)
400 | 			}
401 | 		})
402 | 	}
403 | }
404 | 


--------------------------------------------------------------------------------
/internal/driver/driver_test.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package driver
  7 | 
  8 | import (
  9 | 	"encoding/base64"
 10 | 	"encoding/json"
 11 | 	"testing"
 12 | 	"time"
 13 | 
 14 | 	"github.com/edgexfoundry/device-rfid-llrp-go/pkg/llrp"
 15 | 	dsModels "github.com/edgexfoundry/device-sdk-go/v4/pkg/models"
 16 | 	"github.com/edgexfoundry/go-mod-core-contracts/v4/clients/logger"
 17 | 	"github.com/edgexfoundry/go-mod-core-contracts/v4/common"
 18 | 	"github.com/stretchr/testify/require"
 19 | )
 20 | 
 21 | func TestGetTCPAddr(t *testing.T) {
 22 | 	t.Run("valid", func(t *testing.T) {
 23 | 		t.Parallel()
 24 | 		for _, m := range []protocolMap{{
 25 | 			"tcp": {"host": "127.0.0.1", "port": "1234"},
 26 | 		}} {
 27 | 			addr, err := getAddr(m)
 28 | 			if err != nil {
 29 | 				t.Error(err)
 30 | 			}
 31 | 
 32 | 			expected := "127.0.0.1:1234"
 33 | 			if expected != addr.String() {
 34 | 				t.Errorf("expected %s; got %s", expected, addr.String())
 35 | 			}
 36 | 		}
 37 | 	})
 38 | 
 39 | 	t.Run("invalid", func(t *testing.T) {
 40 | 		t.Parallel()
 41 | 		for _, m := range []protocolMap{{
 42 | 			"tcp": {"host": "127.0.0.1", "port": "86492"},
 43 | 		}} {
 44 | 			if _, err := getAddr(m); err == nil {
 45 | 				t.Error("expected an error, but didn't get one")
 46 | 			}
 47 | 		}
 48 | 	})
 49 | }
 50 | 
 51 | func TestHandleRead(t *testing.T) {
 52 | 	// c := llrp.GetFunctionalClient(t, "192.168.86.88:5084")
 53 | 
 54 | 	rfid, err := llrp.NewTestDevice(llrp.Version1_0_1, llrp.Version1_1, time.Second*1, !testing.Verbose())
 55 | 	if err != nil {
 56 | 		t.Fatal(err)
 57 | 	}
 58 | 
 59 | 	rfid.SetResponse(llrp.MsgGetReaderCapabilities, &llrp.GetReaderCapabilitiesResponse{})
 60 | 	rfid.SetResponse(llrp.MsgGetReaderConfig, &llrp.GetReaderConfigResponse{})
 61 | 	rfid.SetResponse(llrp.MsgGetROSpecs, &llrp.GetROSpecsResponse{})
 62 | 	rfid.SetResponse(llrp.MsgGetAccessSpecs, &llrp.GetAccessSpecsResponse{})
 63 | 
 64 | 	go rfid.ImpersonateReader()
 65 | 	c := rfid.ConnectClient(t)
 66 | 
 67 | 	elog := getLogger()
 68 | 
 69 | 	d := &Driver{
 70 | 		lc:            elog,
 71 | 		activeDevices: make(map[string]*LLRPDevice),
 72 | 	}
 73 | 
 74 | 	// This is a bit dirty. The point of the LLRPDevice is largely for retry logic,
 75 | 	// but that's a real pain without abstracting around something like a net.Listener.
 76 | 	d.activeDevices["localReader"] = &LLRPDevice{
 77 | 		name:   "localReader",
 78 | 		client: c,
 79 | 		lc:     elog,
 80 | 	}
 81 | 
 82 | 	for _, testCase := range []struct {
 83 | 		name    string
 84 | 		target  llrp.Incoming
 85 | 		attribs map[string]interface{}
 86 | 	}{
 87 | 		{name: ResourceReaderCap, target: &llrp.GetReaderCapabilitiesResponse{}},
 88 | 		{name: ResourceReaderConfig, target: &llrp.GetReaderConfigResponse{}},
 89 | 		{name: ResourceROSpec, target: &llrp.GetROSpecsResponse{}},
 90 | 		{name: ResourceAccessSpec, target: &llrp.GetAccessSpecsResponse{}},
 91 | 	} {
 92 | 		testCase := testCase
 93 | 		t.Run(testCase.name, func(t *testing.T) {
 94 | 			cvs, err := d.HandleReadCommands("localReader", protocolMap{}, []dsModels.CommandRequest{{
 95 | 				DeviceResourceName: testCase.name,
 96 | 				Type:               common.ValueTypeObject,
 97 | 				Attributes:         testCase.attribs,
 98 | 			}})
 99 | 
100 | 			if err != nil {
101 | 				t.Fatal(err)
102 | 			}
103 | 
104 | 			if len(cvs) != 1 {
105 | 				t.Fatalf("expected exactly one command value; got %d", len(cvs))
106 | 			}
107 | 
108 | 			cv := cvs[0]
109 | 			if cv == nil {
110 | 				t.Fatal("command value is nil")
111 | 			}
112 | 
113 | 			if cv != nil && testCase.name != cv.DeviceResourceName {
114 | 				t.Errorf("expected %s; got %s", testCase.name, cv.DeviceResourceName)
115 | 			}
116 | 
117 | 			if common.ValueTypeObject != cv.Type {
118 | 				t.Errorf("expected %+v; got %+v", common.ValueTypeObject, cv.Type)
119 | 			}
120 | 
121 | 			s, err := json.Marshal(cv)
122 | 			if err != nil {
123 | 				t.Errorf("%+v", err)
124 | 			}
125 | 
126 | 			if err := json.Unmarshal([]byte(s), &testCase.target); err != nil {
127 | 				t.Errorf("%+v", err)
128 | 			}
129 | 		})
130 | 	}
131 | }
132 | 
133 | func TestHandleWrite(t *testing.T) {
134 | 	rfid, err := llrp.NewTestDevice(llrp.Version1_0_1, llrp.Version1_1, time.Second*1, !testing.Verbose())
135 | 	require.NoError(t, err)
136 | 
137 | 	rfid.SetResponse(llrp.MsgSetReaderConfig, &llrp.SetReaderConfigResponse{})
138 | 	rfid.SetResponse(llrp.MsgStartROSpec, &llrp.StartROSpecResponse{})
139 | 	rfid.SetResponse(llrp.MsgEnableAccessSpec, &llrp.EnableAccessSpecResponse{})
140 | 	rfid.SetResponse(llrp.MsgCustomMessage, &llrp.CustomMessage{
141 | 		VendorID:       1234,
142 | 		MessageSubtype: 22,
143 | 		Data:           []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
144 | 	})
145 | 
146 | 	go rfid.ImpersonateReader()
147 | 	c := rfid.ConnectClient(t)
148 | 
149 | 	elog := getLogger()
150 | 	d := &Driver{
151 | 		lc:            elog,
152 | 		activeDevices: make(map[string]*LLRPDevice),
153 | 	}
154 | 
155 | 	// This is a bit dirty. The point of the LLRPDevice is largely for retry logic,
156 | 	// but that's a real pain without abstracting around something like a net.Listener.
157 | 	d.activeDevices["localReader"] = &LLRPDevice{
158 | 		name:   "localReader",
159 | 		client: c,
160 | 		lc:     elog,
161 | 	}
162 | 
163 | 	roSpecID, err := dsModels.NewCommandValueWithOrigin(ResourceROSpecID, common.ValueTypeUint32, uint32(1), 0)
164 | 	require.NoError(t, err)
165 | 
166 | 	accessSpecID, err := dsModels.NewCommandValueWithOrigin(ResourceAccessSpecID, common.ValueTypeUint32, uint32(2), 0)
167 | 	require.NoError(t, err)
168 | 
169 | 	customData := base64.StdEncoding.EncodeToString([]byte{0, 0, 0, 0})
170 | 	t.Logf("%s", customData)
171 | 
172 | 	readerConfigCmdValue, err := dsModels.NewCommandValueWithOrigin(ResourceReaderConfig, common.ValueTypeObject, make(map[string]interface{}), 0)
173 | 	require.NoError(t, err)
174 | 
175 | 	roSpecCmdValue, err := dsModels.NewCommandValueWithOrigin(ResourceAction, common.ValueTypeString, ActionStart, 0)
176 | 	require.NoError(t, err)
177 | 
178 | 	accessSpecCmdValue, err := dsModels.NewCommandValueWithOrigin(ResourceAction, common.ValueTypeString, ActionEnable, 0)
179 | 	require.NoError(t, err)
180 | 
181 | 	customMessageCmdValue, err := dsModels.NewCommandValueWithOrigin("MyCustomMessage", common.ValueTypeString, customData, 0)
182 | 	require.NoError(t, err)
183 | 
184 | 	for _, testCase := range []struct {
185 | 		name    string
186 | 		reqs    []dsModels.CommandRequest
187 | 		param   []*dsModels.CommandValue
188 | 		attribs map[string]string
189 | 	}{
190 | 		{
191 | 			name: "SetReaderConfig",
192 | 			reqs: []dsModels.CommandRequest{{
193 | 				DeviceResourceName: ResourceReaderConfig,
194 | 				Type:               common.ValueTypeObject,
195 | 			}},
196 | 			param: []*dsModels.CommandValue{
197 | 				readerConfigCmdValue,
198 | 			},
199 | 		},
200 | 		{
201 | 			name: "StartROSpec1",
202 | 			reqs: []dsModels.CommandRequest{{
203 | 				DeviceResourceName: ResourceROSpecID,
204 | 				Type:               common.ValueTypeString,
205 | 			}, {
206 | 				DeviceResourceName: ResourceAction,
207 | 				Type:               common.ValueTypeString,
208 | 			}},
209 | 			param: []*dsModels.CommandValue{
210 | 				roSpecID,
211 | 				roSpecCmdValue,
212 | 			},
213 | 		},
214 | 		{
215 | 			name: "EnableAccessSpec2",
216 | 			reqs: []dsModels.CommandRequest{{
217 | 				DeviceResourceName: ResourceAccessSpecID,
218 | 				Type:               common.ValueTypeString,
219 | 			}, {
220 | 				DeviceResourceName: ResourceAction,
221 | 				Type:               common.ValueTypeString,
222 | 			}},
223 | 			param: []*dsModels.CommandValue{
224 | 				accessSpecID,
225 | 				accessSpecCmdValue,
226 | 			}},
227 | 		{
228 | 			name: "CustomMessage",
229 | 			reqs: []dsModels.CommandRequest{{
230 | 				DeviceResourceName: "MyCustomMessage",
231 | 				Type:               common.ValueTypeString,
232 | 				Attributes: map[string]interface{}{
233 | 					"vendor":  "25882",
234 | 					"subtype": "21",
235 | 				}},
236 | 			},
237 | 			param: []*dsModels.CommandValue{
238 | 				customMessageCmdValue,
239 | 			},
240 | 		},
241 | 	} {
242 | 		testCase := testCase
243 | 		t.Run(testCase.name, func(t *testing.T) {
244 | 			err := d.HandleWriteCommands(
245 | 				"localReader", protocolMap{},
246 | 				testCase.reqs, testCase.param,
247 | 			)
248 | 
249 | 			require.NoError(t, err)
250 | 		})
251 | 	}
252 | }
253 | 
254 | func getLogger() logger.LoggingClient {
255 | 	if testing.Verbose() {
256 | 		return logger.NewClient("unitTest", "DEBUG")
257 | 	} else {
258 | 		return logger.MockLogger{}
259 | 	}
260 | }
261 | 


--------------------------------------------------------------------------------
/internal/driver/logging.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | package driver
 7 | 
 8 | import (
 9 | 	"github.com/edgexfoundry/device-rfid-llrp-go/pkg/llrp"
10 | 	"github.com/edgexfoundry/go-mod-core-contracts/v4/clients/logger"
11 | )
12 | 
13 | // edgexLLRPClientLogger implements the llrp.ClientLogger interface
14 | // by forwarding messages to EdgeX's LoggingClient with the device name attached.
15 | type edgexLLRPClientLogger struct {
16 | 	devName string
17 | 	lc      logger.LoggingClient
18 | }
19 | 
20 | func (l *edgexLLRPClientLogger) SendingMsg(h llrp.Header) {
21 | 	switch h.Type() {
22 | 	case llrp.MsgKeepAliveAck:
23 | 		l.lc.Debug("Sending LLRP message", "type", h.Type().String(), "device", l.devName)
24 | 	default:
25 | 		l.lc.Info("Sending LLRP message", "type", h.Type().String(), "device", l.devName)
26 | 	}
27 | }
28 | 
29 | func (l *edgexLLRPClientLogger) ReceivedMsg(h llrp.Header, ver llrp.VersionNum) {
30 | 	switch h.Type() {
31 | 	case llrp.MsgKeepAlive, llrp.MsgROAccessReport:
32 | 		l.lc.Debug("Incoming LLRP message", "type", h.Type().String(), "device", l.devName)
33 | 	default:
34 | 		l.lc.Info("Incoming LLRP message", "type", h.Type().String(), "device", l.devName)
35 | 	}
36 | 
37 | 	if ver != h.Version() {
38 | 		l.lc.Warn("LLRP incoming message version mismatch",
39 | 			"message-version", h.Version().String(),
40 | 			"client-version", ver.String())
41 | 	}
42 | }
43 | 
44 | func (l *edgexLLRPClientLogger) MsgHandled(h llrp.Header) {
45 | 	l.lc.Debug("Handled LLRP message.", "type", h.Type().String(), "device", l.devName)
46 | }
47 | 
48 | func (l *edgexLLRPClientLogger) MsgUnhandled(h llrp.Header) {
49 | 	l.lc.Debug("Ignored LLRP message.", "type", h.Type().String(), "device", l.devName)
50 | }
51 | 
52 | func (l *edgexLLRPClientLogger) HandlerPanic(h llrp.Header, err error) {
53 | 	l.lc.Error("LLRP message handler panic'd (recovered).",
54 | 		"type", h.Type().String(), "device", l.devName, "error", err.Error())
55 | }
56 | 


--------------------------------------------------------------------------------
/internal/driver/types.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | //go:generate stringer -type=VendorIDType,ImpinjModelType -output types_string.go
 7 | 
 8 | package driver
 9 | 
10 | type VendorIDType uint32
11 | 
12 | const (
13 | 	Impinj = VendorIDType(25882)
14 | 	Alien  = VendorIDType(17996)
15 | 	Zebra  = VendorIDType(10642)
16 | )
17 | 
18 | type ImpinjModelType uint32
19 | 
20 | const (
21 | 	SpeedwayR220 = ImpinjModelType(2001001)
22 | 	SpeedwayR420 = ImpinjModelType(2001002)
23 | 	XPortal      = ImpinjModelType(2001003)
24 | 	XArrayWM     = ImpinjModelType(2001004)
25 | 	XArrayEAP    = ImpinjModelType(2001006)
26 | 	XArray       = ImpinjModelType(2001007)
27 | 	XSpan        = ImpinjModelType(2001008)
28 | 	SpeedwayR120 = ImpinjModelType(2001009)
29 | 	R700         = ImpinjModelType(2001052)
30 | )
31 | 
32 | // HostnamePrefix will return the default hostname prefix of known Impinj readers
33 | func (imt ImpinjModelType) HostnamePrefix() string {
34 | 	switch imt {
35 | 	case SpeedwayR120, SpeedwayR220, SpeedwayR420, R700, XPortal:
36 | 		return "SpeedwayR"
37 | 	case XSpan:
38 | 		return "xSpan"
39 | 	case XArray, XArrayEAP, XArrayWM:
40 | 		return "xArray"
41 | 	default:
42 | 		return defaultDevicePrefix
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/internal/driver/types_string.go:
--------------------------------------------------------------------------------
 1 | // Code generated by "stringer -type=VendorIDType,ImpinjModelType -output types_string.go"; DO NOT EDIT.
 2 | 
 3 | package driver
 4 | 
 5 | import "strconv"
 6 | 
 7 | func _() {
 8 | 	// An "invalid array index" compiler error signifies that the constant values have changed.
 9 | 	// Re-run the stringer command to generate them again.
10 | 	var x [1]struct{}
11 | 	_ = x[Impinj-25882]
12 | 	_ = x[Alien-17996]
13 | 	_ = x[Zebra-10642]
14 | }
15 | 
16 | const (
17 | 	_VendorIDType_name_0 = "Zebra"
18 | 	_VendorIDType_name_1 = "Alien"
19 | 	_VendorIDType_name_2 = "Impinj"
20 | )
21 | 
22 | func (i VendorIDType) String() string {
23 | 	switch {
24 | 	case i == 10642:
25 | 		return _VendorIDType_name_0
26 | 	case i == 17996:
27 | 		return _VendorIDType_name_1
28 | 	case i == 25882:
29 | 		return _VendorIDType_name_2
30 | 	default:
31 | 		return "VendorIDType(" + strconv.FormatInt(int64(i), 10) + ")"
32 | 	}
33 | }
34 | func _() {
35 | 	// An "invalid array index" compiler error signifies that the constant values have changed.
36 | 	// Re-run the stringer command to generate them again.
37 | 	var x [1]struct{}
38 | 	_ = x[SpeedwayR220-2001001]
39 | 	_ = x[SpeedwayR420-2001002]
40 | 	_ = x[XPortal-2001003]
41 | 	_ = x[XArrayWM-2001004]
42 | 	_ = x[XArrayEAP-2001006]
43 | 	_ = x[XArray-2001007]
44 | 	_ = x[XSpan-2001008]
45 | 	_ = x[SpeedwayR120-2001009]
46 | 	_ = x[R700-2001052]
47 | }
48 | 
49 | const (
50 | 	_ImpinjModelType_name_0 = "SpeedwayR220SpeedwayR420XPortalXArrayWM"
51 | 	_ImpinjModelType_name_1 = "XArrayEAPXArrayXSpanSpeedwayR120"
52 | 	_ImpinjModelType_name_2 = "R700"
53 | )
54 | 
55 | var (
56 | 	_ImpinjModelType_index_0 = [...]uint8{0, 12, 24, 31, 39}
57 | 	_ImpinjModelType_index_1 = [...]uint8{0, 9, 15, 20, 32}
58 | )
59 | 
60 | func (i ImpinjModelType) String() string {
61 | 	switch {
62 | 	case 2001001 <= i && i <= 2001004:
63 | 		i -= 2001001
64 | 		return _ImpinjModelType_name_0[_ImpinjModelType_index_0[i]:_ImpinjModelType_index_0[i+1]]
65 | 	case 2001006 <= i && i <= 2001009:
66 | 		i -= 2001006
67 | 		return _ImpinjModelType_name_1[_ImpinjModelType_index_1[i]:_ImpinjModelType_index_1[i+1]]
68 | 	case i == 2001052:
69 | 		return _ImpinjModelType_name_2
70 | 	default:
71 | 		return "ImpinjModelType(" + strconv.FormatInt(int64(i), 10) + ")"
72 | 	}
73 | }
74 | 


--------------------------------------------------------------------------------
/internal/retry/retry_test.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package retry
  7 | 
  8 | import (
  9 | 	"context"
 10 | 	"errors"
 11 | 	"fmt"
 12 | 	"testing"
 13 | 	"testing/quick"
 14 | 	"time"
 15 | )
 16 | 
 17 | var (
 18 | 	urerr  = fmt.Errorf("unrecoverable error")
 19 | 	recerr = fmt.Errorf("recoverable error")
 20 | )
 21 | 
 22 | func TestExpBackOff_Retry_noErr(t *testing.T) {
 23 | 	ebo := ExpBackOff{
 24 | 		BackOff: 1 * time.Nanosecond,
 25 | 		Max:     1 * time.Nanosecond,
 26 | 	}
 27 | 
 28 | 	if err := ebo.Retry(10, func() error { return nil }); err != nil {
 29 | 		t.Error(err)
 30 | 	}
 31 | }
 32 | 
 33 | func TestExpBackOff_Retry_errs(t *testing.T) {
 34 | 	ebo := ExpBackOff{
 35 | 		BackOff:  1 * time.Nanosecond,
 36 | 		Max:      1 * time.Nanosecond,
 37 | 		KeepErrs: 10,
 38 | 	}
 39 | 
 40 | 	// Retry expects all errors are recoverable.
 41 | 	recoverable := func() error { return recerr }
 42 | 
 43 | 	// Since the function reports it might recover,
 44 | 	// it's called as many times as Retries allows;
 45 | 	// the Latest error indicates RetriesExceeded.
 46 | 	checkRetry(t, ebo, recoverable, 1, ErrRetriesExceeded, 1)
 47 | 	checkRetry(t, ebo, recoverable, 2, ErrRetriesExceeded, 2)
 48 | 	checkRetry(t, ebo, recoverable, 3, ErrRetriesExceeded, 3)
 49 | 
 50 | 	// Even though this retries 15 times,
 51 | 	// the EBO's setting tells Retry to only keep the last 10 errors.
 52 | 	checkRetry(t, ebo, recoverable, 15, ErrRetriesExceeded, 10)
 53 | }
 54 | 
 55 | func TestExpBackOff_RetrySome(t *testing.T) {
 56 | 	ebo := ExpBackOff{
 57 | 		BackOff:  1 * time.Nanosecond,
 58 | 		Max:      1 * time.Nanosecond,
 59 | 		KeepErrs: 5,
 60 | 	}
 61 | 
 62 | 	recoverable := func() (bool, error) { return true, recerr }
 63 | 	unrecoverable := func() (bool, error) { return false, urerr }
 64 | 
 65 | 	checkRetrySome(t, ebo, recoverable, 1, ErrRetriesExceeded, 1)
 66 | 	checkRetrySome(t, ebo, recoverable, 2, ErrRetriesExceeded, 2)
 67 | 	checkRetrySome(t, ebo, recoverable, 3, ErrRetriesExceeded, 3)
 68 | 	checkRetrySome(t, ebo, recoverable, 15, ErrRetriesExceeded, 5)
 69 | 	checkRetrySome(t, ebo, unrecoverable, 1, urerr, 1)
 70 | 	checkRetrySome(t, ebo, unrecoverable, 2, urerr, 1)
 71 | 	checkRetrySome(t, ebo, unrecoverable, 3, urerr, 1)
 72 | 
 73 | 	// Always return an error, but only return "true" the first few times.
 74 | 	c := 0
 75 | 	f := func() (bool, error) {
 76 | 		c++
 77 | 		if c > 3 {
 78 | 			return false, urerr
 79 | 		}
 80 | 		return true, recerr
 81 | 	}
 82 | 
 83 | 	checkRetrySome(t, ebo, f, 5, urerr, 3)
 84 | }
 85 | 
 86 | type errType struct {
 87 | 	e string
 88 | }
 89 | 
 90 | func (et *errType) Error() string {
 91 | 	return et.e
 92 | }
 93 | 
 94 | func TestFError(t *testing.T) {
 95 | 	ebo := ExpBackOff{KeepErrs: 5}
 96 | 
 97 | 	et := &errType{e: "some error"}
 98 | 	f := func() error { return et }
 99 | 	err := ebo.Retry(2, f)
100 | 
101 | 	if err == nil {
102 | 		t.Fatal("expected an error, but got nil")
103 | 	}
104 | 
105 | 	if s := err.Error(); s == "" {
106 | 		t.Error("expected an error string, but got nothing")
107 | 	}
108 | 
109 | 	// Unwrap returns the MainError, which should be ErrRetriesExceeded.
110 | 	if e2 := errors.Unwrap(err); e2 != ErrRetriesExceeded {
111 | 		t.Errorf("expected errors.Unwrap to be ErrRetriesExceeded, but got %+v", e2)
112 | 	}
113 | 
114 | 	// The MainError is ErrRetriesExceeded.
115 | 	if !errors.Is(err, ErrRetriesExceeded) {
116 | 		t.Error("expected errors.Is(ErrRetriesExceeded) to succeed")
117 | 	}
118 | 
119 | 	// All sub-errors are et.
120 | 	if !errors.Is(err, et) {
121 | 		t.Error("expected errors.Is(et) to succeed")
122 | 	}
123 | 
124 | 	et2 := fmt.Errorf("yet another: %w", fmt.Errorf("another error: %w", et))
125 | 
126 | 	// Not all sub-errors are et2.
127 | 	if errors.Is(err, et2) {
128 | 		t.Error("expected errors.Is(et) to fail")
129 | 	}
130 | 
131 | 	// It's not an empty FError.
132 | 	fe := &FError{}
133 | 	if errors.Is(err, fe) {
134 | 		t.Error("expected errors.Is(*FError) to fail")
135 | 	}
136 | 
137 | 	// Now the FError partially matches, but has a different len for sub-errors.
138 | 	fe = &FError{
139 | 		MainErr: ErrRetriesExceeded,
140 | 		Others:  []error{et},
141 | 	}
142 | 	if errors.Is(err, fe) {
143 | 		t.Error("expected errors.Is(*FError) to fail")
144 | 	}
145 | 
146 | 	// Now the lengths are equal, but not all the sub-errors match.
147 | 	fe.Others = append(fe.Others, et2)
148 | 	if errors.Is(err, fe) {
149 | 		t.Error("expected errors.Is(*FError) to fail")
150 | 	}
151 | 
152 | 	// Now the main error and sub-errors should all match.
153 | 	fe.Others[1] = et
154 | 	if !errors.Is(err, fe) {
155 | 		t.Error("expected errors.Is(*FError) to succeed")
156 | 	}
157 | }
158 | 
159 | func TestExpBackOff_RetryWithCtx(t *testing.T) {
160 | 	const tests, callsPerTest = 20, 10
161 | 	ebo := ExpBackOff{}
162 | 
163 | 	for i := 0; i < tests; i++ {
164 | 		// f fails the first i times, but passes after that.
165 | 		f, count := untilCount(i)
166 | 		err := ebo.RetryWithCtx(context.Background(), callsPerTest, f)
167 | 
168 | 		if i >= callsPerTest {
169 | 			if err == nil {
170 | 				t.Errorf("expected an error, but got nil")
171 | 			}
172 | 
173 | 			if callsPerTest != *count {
174 | 				t.Errorf("expected %d failed attempts, but got %d", callsPerTest, *count)
175 | 			}
176 | 			continue
177 | 		}
178 | 
179 | 		if err != nil {
180 | 			t.Errorf("unexpected error: %+v", err)
181 | 		} else if i != *count {
182 | 			t.Errorf("expected count to be %d; got %d", i, *count)
183 | 		}
184 | 	}
185 | }
186 | 
187 | func TestExpBackOff_RetryWithCtx_expiredCtx(t *testing.T) {
188 | 	ebo := ExpBackOff{}
189 | 
190 | 	ctx, cancel := context.WithCancel(context.Background())
191 | 
192 | 	f, _ := untilCount(100)
193 | 
194 | 	if err := ebo.RetryWithCtx(ctx, 10, f); err == nil {
195 | 		t.Errorf("expected an error, but didn't get one")
196 | 	} else if fe, ok := err.(*FError); !ok || fe == nil {
197 | 		t.Errorf("expected an FError, but got %+v", err)
198 | 	} else if fe.MainErr != ErrRetriesExceeded {
199 | 		t.Errorf("expected latest error to be %+v, but got %+v", ErrRetriesExceeded, fe.MainErr)
200 | 	}
201 | 
202 | 	cancel()
203 | 
204 | 	// Retry shouldn't even call f once.
205 | 	if err := ebo.RetryWithCtx(ctx, 10, func(_ context.Context) (bool, error) {
206 | 		t.Fatal("unexpected call to f")
207 | 		return true, nil
208 | 	}); err == nil {
209 | 		t.Error("expected an error, but didn't get one")
210 | 	} else if fe, ok := err.(*FError); !ok || fe == nil {
211 | 		t.Errorf("expected an FError, but got %+v", err)
212 | 	} else if fe.MainErr != ctx.Err() {
213 | 		t.Errorf("expected latest error to be %+v, but got %+v", ctx.Err(), fe.MainErr)
214 | 	} else if len(fe.Others) != 0 {
215 | 		t.Errorf("expected 0 other errors, but got %+v", fe.Others)
216 | 	}
217 | }
218 | 
219 | func TestExpBackOff_RetryWithCtx_cancel(t *testing.T) {
220 | 	ebo := ExpBackOff{
221 | 		BackOff: time.Minute,
222 | 		Max:     time.Hour,
223 | 	}
224 | 
225 | 	fCalled := make(chan struct{})
226 | 	f := func(_ context.Context) (bool, error) {
227 | 		close(fCalled)
228 | 		return true, recerr
229 | 	}
230 | 
231 | 	ctx, cancel := context.WithCancel(context.Background())
232 | 	defer cancel()
233 | 
234 | 	errs := make(chan error, 1)
235 | 	go func() {
236 | 		errs <- ebo.RetryWithCtx(ctx, 10, f)
237 | 		close(errs)
238 | 	}()
239 | 
240 | 	<-fCalled
241 | 	cancel()
242 | 
243 | 	err := <-errs
244 | 	if !errors.Is(err, context.Canceled) {
245 | 		t.Errorf("expected %v; got %v", context.Canceled, err)
246 | 	}
247 | }
248 | 
249 | func TestExpBackOff_RetryWithCtx_deadline(t *testing.T) {
250 | 	ebo := ExpBackOff{
251 | 		BackOff: time.Minute,
252 | 		Max:     time.Hour,
253 | 	}
254 | 
255 | 	fCalled := make(chan struct{})
256 | 	f := func(_ context.Context) (bool, error) {
257 | 		close(fCalled)
258 | 		return true, recerr
259 | 	}
260 | 
261 | 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Millisecond)
262 | 	defer cancel()
263 | 
264 | 	errs := make(chan error, 1)
265 | 	go func() {
266 | 		errs <- ebo.RetryWithCtx(ctx, 10, f)
267 | 		close(errs)
268 | 	}()
269 | 
270 | 	<-fCalled
271 | 
272 | 	err := <-errs
273 | 	if !(errors.Is(err, context.DeadlineExceeded) || errors.Is(err, ErrWaitExceedsDeadline)) {
274 | 		t.Errorf("expected %v or %v; got %v",
275 | 			context.DeadlineExceeded, ErrWaitExceedsDeadline, err)
276 | 	}
277 | }
278 | 
279 | func checkEBO(t *testing.T, jitter bool, attempt, bko, max, exp int) (ok bool) {
280 | 	t.Helper()
281 | 	ebo := ExpBackOff{
282 | 		BackOff: time.Duration(bko),
283 | 		Max:     time.Duration(max),
284 | 		Jitter:  jitter,
285 | 	}
286 | 
287 | 	w := ebo.nextWait(attempt)
288 | 	ok = true
289 | 
290 | 	if w < 0 {
291 | 		t.Errorf("ebo %+v: got negative duration: %d", ebo, w)
292 | 		ok = false
293 | 	}
294 | 
295 | 	if attempt == 0 && w != 0 {
296 | 		t.Errorf("ebo %+v: expected 0, got %d", ebo, w)
297 | 		ok = false
298 | 	}
299 | 
300 | 	if jitter {
301 | 		if time.Duration(exp) < w/2 {
302 | 			t.Errorf("ebo %+v: expected <= %d, got %d", ebo, exp, w/2)
303 | 			ok = false
304 | 		}
305 | 	} else if time.Duration(exp) != w {
306 | 		t.Errorf("ebo %+v: expected %d, got %d", ebo, exp, w)
307 | 		ok = false
308 | 	}
309 | 
310 | 	return ok
311 | }
312 | 
313 | func TestExpBackOff_nextWait(t *testing.T) {
314 | 	for _, tc := range []struct{ attempt, bko, max, exp int }{
315 | 		{-1, 1, 50, 0},
316 | 		{-2, 1, 50, 0},
317 | 		{0, 1, 50, 0},
318 | 		{1, 1, 50, 1},
319 | 		{2, 1, 50, 2},
320 | 		{3, 1, 50, 4},
321 | 		{4, 1, 50, 8},
322 | 		{5, 1, 50, 16},
323 | 		{6, 1, 50, 32},
324 | 		{7, 1, 50, 50},
325 | 		{8, 1, 50, 50},
326 | 		{61, 1, 50, 50},
327 | 		{62, 1, 50, 50},
328 | 		{63, 1, 50, 50},
329 | 		{64, 1, 50, 50},
330 | 		{65, 1, 50, 50},
331 | 
332 | 		// backoff of 3
333 | 		{-1, 3, 50, 0},
334 | 		{-2, 3, 50, 0},
335 | 		{0, 3, 50, 0},
336 | 		{1, 3, 50, 3},
337 | 		{2, 3, 50, 6},
338 | 		{3, 3, 50, 12},
339 | 		{4, 3, 50, 24},
340 | 		{5, 3, 50, 48},
341 | 		{6, 3, 50, 50},
342 | 
343 | 		// backoff of 0 always gives 0 or max
344 | 		{-1, 0, 100, 0},
345 | 		{-2, 0, 100, 0},
346 | 		{0, 0, 100, 0},
347 | 		{1, 0, 100, 100},
348 | 		{2, 0, 100, 100},
349 | 		{3, 0, 100, 100},
350 | 		{4, 0, 100, 100},
351 | 		{61, 0, 100, 100},
352 | 		{63, 0, 100, 100},
353 | 		{66, 0, 100, 100},
354 | 
355 | 		// if max is 0, then so should be all results
356 | 		{-1, 0, 0, 0},
357 | 		{-2, 3, 0, 0},
358 | 		{0, 10, 0, 0},
359 | 		{1, 20, 0, 0},
360 | 		{2, 30, 0, 0},
361 | 		{32, 30, 0, 0},
362 | 		{64, 130, 0, 0},
363 | 
364 | 		// backoff huge
365 | 		{-1, (1 << 63) - 1, 50, 0},
366 | 		{-2, (1 << 63) - 1, 50, 0},
367 | 		{0, (1 << 63) - 1, 50, 0},
368 | 		{1, (1 << 63) - 1, 50, 50},
369 | 		{2, (1 << 63) - 1, 50, 50},
370 | 		{3, (1 << 63) - 1, 50, 50},
371 | 	} {
372 | 		if !checkEBO(t, false, tc.attempt, tc.bko, tc.max, tc.exp) {
373 | 			t.Logf("	%v", tc)
374 | 		}
375 | 		if !checkEBO(t, true, tc.attempt, tc.bko, tc.max, tc.exp) {
376 | 			t.Logf("	%v", tc)
377 | 		}
378 | 	}
379 | 
380 | 	if err := quick.Check(func(backoff, max int) bool {
381 | 		backoff &= 0x7fff_ffff_ffff_ffff
382 | 		max &= 0x7fff_ffff_ffff_ffff
383 | 		exp := max & 0x7fff_ffff_ffff_ffff
384 | 		t1 := checkEBO(t, false, 100, backoff, max, exp)
385 | 		t2 := checkEBO(t, true, 100, backoff, max, exp)
386 | 		return t1 && t2
387 | 	}, nil); err != nil {
388 | 		t.Error(err)
389 | 	}
390 | }
391 | 
392 | // untilCount returns a function f and an int pointer c.
393 | // The first n times that f is called,
394 | // it increments c and returns a "recoverable" error.
395 | // Once c reaches max, f simply returns nil.
396 | func untilCount(max int) (Func, *int) {
397 | 	c := 0
398 | 	return func(_ context.Context) (bool, error) {
399 | 		if c < max {
400 | 			c++
401 | 			return true, recerr
402 | 		}
403 | 
404 | 		return false, nil
405 | 	}, &c
406 | }
407 | 
408 | // checkRetry is a helper that calls Retry, expecting a particular error.
409 | func checkRetry(t *testing.T, ebo ExpBackOff, f func() error, retries int, latest error, expOtherErrs int) {
410 | 	t.Helper()
411 | 	if err := ebo.Retry(retries, f); err == nil {
412 | 		t.Errorf("expected an error, but got nil")
413 | 	} else if fe, ok := err.(*FError); !ok || fe == nil {
414 | 		t.Errorf("expected an FError, but got %+v", err)
415 | 	} else if fe.MainErr != latest {
416 | 		t.Errorf("expected latest error to be %+v, but got %+v", latest, fe.MainErr)
417 | 	} else if len(fe.Others) != expOtherErrs {
418 | 		t.Errorf("expected %d other errors, but got %+v", expOtherErrs, fe.Others)
419 | 	}
420 | }
421 | 
422 | // checkRetrySome is a helper that calls RetrySome, expecting a particular error.
423 | func checkRetrySome(t *testing.T, ebo ExpBackOff, f func() (bool, error), retries int, latest error, expOtherErrs int) {
424 | 	t.Helper()
425 | 	if err := ebo.RetrySome(retries, f); err == nil {
426 | 		t.Errorf("expected an error, but got nil")
427 | 	} else if fe, ok := err.(*FError); !ok || fe == nil {
428 | 		t.Errorf("expected an FError, but got %+v", err)
429 | 	} else if !fe.Is(latest) {
430 | 		t.Errorf("expected error to be %+v, but got %+v", latest, fe)
431 | 	} else if len(fe.Others) != expOtherErrs {
432 | 		t.Errorf("expected %d other errors, but got %+v", expOtherErrs, fe.Others)
433 | 	}
434 | }
435 | 


--------------------------------------------------------------------------------
/pkg/llrp/LLRPMsgStructure.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/LLRPMsgStructure.pdf


--------------------------------------------------------------------------------
/pkg/llrp/msg_builder.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | package llrp
 7 | 
 8 | import (
 9 | 	"fmt"
10 | 	"io"
11 | 	"sync"
12 | )
13 | 
14 | type fieldEncoder interface {
15 | 	EncodeFields(w io.Writer) error
16 | }
17 | 
18 | type paramHeader struct {
19 | 	ParamType
20 | 	sz   uint16
21 | 	data fieldEncoder
22 | 	subs []paramHeader
23 | }
24 | 
25 | func encodeParams(w io.Writer, headers ...paramHeader) error {
26 | 	for _, h := range headers {
27 | 		if h.ParamType.IsTV() {
28 | 			if n, err := w.Write([]byte{byte(h.ParamType | 0x80)}); err != nil {
29 | 				return fmt.Errorf("failed to write TV header for %v: %w", h.ParamType, err)
30 | 			} else if n < 1 {
31 | 				return fmt.Errorf("short write for %v: %d < 1", h.ParamType, n)
32 | 			}
33 | 		} else {
34 | 			if n, err := w.Write([]byte{
35 | 				byte(h.ParamType >> 8), byte(h.ParamType & 0xff),
36 | 				byte(h.sz >> 8), byte(h.sz & 0xff),
37 | 			}); err != nil {
38 | 				return fmt.Errorf("failed to write parameter header: %w", err)
39 | 			} else if n < 4 {
40 | 				return fmt.Errorf("short write: %d < 4", n)
41 | 			}
42 | 		}
43 | 
44 | 		if err := h.data.EncodeFields(w); err != nil {
45 | 			return err
46 | 		}
47 | 
48 | 		if err := encodeParams(w, h.subs...); err != nil {
49 | 			return err
50 | 		}
51 | 	}
52 | 
53 | 	return nil
54 | }
55 | 
56 | // msgWriter isn't for general use at the moment,
57 | // but is handy for certain basic tests.
58 | type msgWriter struct {
59 | 	w      io.Writer // target output
60 | 	header Header
61 | 	mu     sync.Mutex
62 | }
63 | 
64 | func newMsgWriter(w io.Writer, version VersionNum) *msgWriter {
65 | 	return &msgWriter{
66 | 		w: w,
67 | 		header: Header{
68 | 			version: version,
69 | 		},
70 | 	}
71 | }
72 | 
73 | func (mw *msgWriter) Write(mid messageID, out Outgoing) error {
74 | 	mw.mu.Lock()
75 | 	defer mw.mu.Unlock()
76 | 
77 | 	data, err := out.MarshalBinary()
78 | 	if err != nil {
79 | 		return err
80 | 	}
81 | 
82 | 	if uint32(len(data)) > maxPayloadSz {
83 | 		return fmt.Errorf("outgoing payload size (%d) "+
84 | 			"is larger than that permitted by LLRP", len(data))
85 | 	}
86 | 
87 | 	mw.header.payloadLen = uint32(len(data))
88 | 	mw.header.typ = out.Type()
89 | 	mw.header.id = mid
90 | 	if _, err := mw.header.WriteTo(mw.w); err != nil {
91 | 		return err
92 | 	}
93 | 
94 | 	if _, err = mw.w.Write(data); err != nil {
95 | 		return fmt.Errorf("failed to write payload %v: %w", mw.header, err)
96 | 	}
97 | 	return nil
98 | }
99 | 


--------------------------------------------------------------------------------
/pkg/llrp/params_test.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package llrp
  7 | 
  8 | import (
  9 | 	"encoding/binary"
 10 | 	"testing"
 11 | )
 12 | 
 13 | func TestMsgReader_readerEventNotification(t *testing.T) {
 14 | 	pConnAttempt := []byte{
 15 | 		0x1, 0x0, // ConnectionAttemptEvent
 16 | 		0x0, 0x6, // size; 4 byte header + 2 byte field
 17 | 		0x0, 0x4, // 4 == anotherConnAttempted
 18 | 	}
 19 | 
 20 | 	pTimestamp := []byte{
 21 | 		0x0, 128, // UTCTimestamp
 22 | 		0x0, 12, // header + 8 bytes of microseconds
 23 | 		0x00, 0x02, 0x4b, 0xd4, 0xc0, 0x03, 0x1a, 0x00, // June 25, 1990, 11:18AM EST
 24 | 	}
 25 | 
 26 | 	eventData := append(pTimestamp, pConnAttempt...)
 27 | 	pReaderEvent := append([]byte{
 28 | 		0x0, 246, // ReaderEventNotificationParameter
 29 | 		0x0, 0x0, // length (set below)
 30 | 	}, eventData...)
 31 | 	binary.BigEndian.PutUint16(pReaderEvent[2:4], uint16(len(pReaderEvent)))
 32 | 
 33 | 	ren := ReaderEventNotification{}
 34 | 	if err := ren.UnmarshalBinary(pReaderEvent); err != nil {
 35 | 		t.Fatalf("%+v", err)
 36 | 	}
 37 | 
 38 | 	nd := ren.ReaderEventNotificationData
 39 | 	expTS := UTCTimestamp(646327080000000)
 40 | 	if nd.UTCTimestamp != expTS {
 41 | 		t.Errorf("utc timestamp mismatch: %+v != %+v", nd.UTCTimestamp, expTS)
 42 | 	}
 43 | 	if nd.ConnectionAttemptEvent == nil ||
 44 | 		ConnectionAttemptEventType(*nd.ConnectionAttemptEvent) != ConnAttemptedAgain {
 45 | 		t.Errorf("expected ConnAttemptedAgain, but got %+v", nd.ConnectionAttemptEvent)
 46 | 	}
 47 | }
 48 | 
 49 | func BenchmarkReaderEventNotification_UnmarshalBinary(b *testing.B) {
 50 | 	data := []byte{
 51 | 		0x0, 246, // ReaderEventNotificationParameter
 52 | 		0x0, 22, // length
 53 | 
 54 | 		0x0, 128, // UTCTimestamp
 55 | 		0x0, 12, // header + 8 bytes of microseconds
 56 | 		0x00, 0x02, 0x4b, 0xd4, 0xc0, 0x03, 0x1a, 0x00, // June 25, 1990, 11:18AM EST
 57 | 
 58 | 		0x1, 0x0, // ConnectionAttemptEvent
 59 | 		0x0, 0x6, // size; 4 byte header + 2 byte field
 60 | 		0x0, 0x3, // failedReasonUnknown
 61 | 	}
 62 | 
 63 | 	b.ReportAllocs()
 64 | 	b.ResetTimer()
 65 | 	ren := ReaderEventNotification{}
 66 | 	for i := 0; i < b.N; i++ {
 67 | 		if err := ren.UnmarshalBinary(data); err != nil {
 68 | 			b.Fatalf("%+v", err)
 69 | 		}
 70 | 	}
 71 | }
 72 | 
 73 | func TestReaderEventNotification_UnmarshalBinary(t *testing.T) {
 74 | 	data := []byte{
 75 | 		0x0, 246, // ReaderEventNotificationParameter
 76 | 		0x0, 22, // length
 77 | 
 78 | 		0x0, 128, // UTCTimestamp
 79 | 		0x0, 12, // header + 8 bytes of microseconds
 80 | 		0x00, 0x02, 0x4b, 0xd4, 0xc0, 0x03, 0x1a, 0x00, // June 25, 1990, 11:18AM EST
 81 | 
 82 | 		0x1, 0x0, // ConnectionAttemptEvent
 83 | 		0x0, 0x6, // size; 4 byte header + 2 byte field
 84 | 		0x0, 0x3, // failedReasonUnknown
 85 | 	}
 86 | 
 87 | 	ren := ReaderEventNotification{}
 88 | 	if err := ren.UnmarshalBinary(data); err != nil {
 89 | 		t.Fatalf("%+v", err)
 90 | 	}
 91 | 
 92 | 	cae := ConnectionAttemptEvent(ConnFailedReasonUnknown)
 93 | 	exp := ReaderEventNotification{
 94 | 		ReaderEventNotificationData: ReaderEventNotificationData{
 95 | 			UTCTimestamp:           UTCTimestamp(0x00024bd4c0031a00),
 96 | 			ConnectionAttemptEvent: &cae,
 97 | 		},
 98 | 	}
 99 | 
100 | 	if exp.ReaderEventNotificationData.UTCTimestamp != ren.ReaderEventNotificationData.UTCTimestamp {
101 | 		t.Fatalf("expected timestamp %+v; got %+v",
102 | 			exp.ReaderEventNotificationData.UTCTimestamp,
103 | 			ren.ReaderEventNotificationData.UTCTimestamp)
104 | 	}
105 | 
106 | 	if nil == ren.ReaderEventNotificationData.ConnectionAttemptEvent {
107 | 		t.Fatalf("expected non-nil timestamp and connection attempt; got %+v", ren.ReaderEventNotificationData.ConnectionAttemptEvent)
108 | 	}
109 | 
110 | 	if ConnFailedReasonUnknown != ConnectionAttemptEventType(*ren.ReaderEventNotificationData.ConnectionAttemptEvent) {
111 | 		t.Fatalf("expected ConnFailedReasonUnknown; got %+v", ren.ReaderEventNotificationData.ConnectionAttemptEvent)
112 | 	}
113 | }
114 | 


--------------------------------------------------------------------------------
/pkg/llrp/reader_data_test.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package llrp
  7 | 
  8 | import (
  9 | 	"bytes"
 10 | 	"encoding/json"
 11 | 	"fmt"
 12 | 	"os"
 13 | 	"path/filepath"
 14 | 	"reflect"
 15 | 	"strconv"
 16 | 	"strings"
 17 | 	"testing"
 18 | )
 19 | 
 20 | func TestClient_withRecordedData(t *testing.T) {
 21 | 	testRecordedData(t, "testdata")
 22 | 	if *roDirectory != "" {
 23 | 		testRecordedData(t, filepath.Join("testdata", *roDirectory))
 24 | 	}
 25 | }
 26 | 
 27 | func BenchmarkUnmarshalRO(b *testing.B) {
 28 | 	for _, nTags := range []int{
 29 | 		100, 200, 300, 400,
 30 | 	} {
 31 | 		nTags := nTags
 32 | 		b.Run(strconv.Itoa(nTags)+"Tags", func(b *testing.B) {
 33 | 			ro := &ROAccessReport{}
 34 | 
 35 | 			for i := 0; i < nTags; i++ {
 36 | 				ro.TagReportData = append(ro.TagReportData, TagReportData{
 37 | 					EPC96: EPC96{
 38 | 						EPC: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
 39 | 					},
 40 | 					C1G2PC: &C1G2PC{
 41 | 						EPCMemoryLength: 12,
 42 | 						HasUserMemory:   false,
 43 | 						HasXPC:          false,
 44 | 						IsISO15961:      false,
 45 | 						AttributesOrAFI: 0x21,
 46 | 					},
 47 | 				})
 48 | 			}
 49 | 
 50 | 			data, err := ro.MarshalBinary()
 51 | 			if err != nil {
 52 | 				b.Fatal(err)
 53 | 			}
 54 | 
 55 | 			b.ReportAllocs()
 56 | 			b.ResetTimer()
 57 | 			for i := 0; i < b.N; i++ {
 58 | 				target := &ROAccessReport{}
 59 | 				if err := target.UnmarshalBinary(data); err != nil {
 60 | 					b.Error(err)
 61 | 				}
 62 | 			}
 63 | 		})
 64 | 	}
 65 | }
 66 | 
 67 | func testRecordedData(t *testing.T, dir string) {
 68 | 	files, err := os.ReadDir(dir)
 69 | 	if err != nil {
 70 | 		t.Fatal(err)
 71 | 	}
 72 | 
 73 | 	for _, f := range files {
 74 | 		if !strings.HasSuffix(f.Name(), ".json") {
 75 | 			continue
 76 | 		}
 77 | 
 78 | 		prefix := f.Name()[:len(f.Name())-len(".json")]
 79 | 		parts := strings.SplitN(f.Name(), "-", 2)
 80 | 		if len(parts) != 2 {
 81 | 			continue
 82 | 		}
 83 | 		msg := parts[0]
 84 | 		t.Run(prefix, compareMessages(msg, filepath.Join(dir, prefix)))
 85 | 	}
 86 | }
 87 | 
 88 | func compareMessages(msgName, prefix string) func(t *testing.T) {
 89 | 	type binRoundTrip interface {
 90 | 		UnmarshalBinary(data []byte) error
 91 | 		MarshalBinary() ([]byte, error)
 92 | 	}
 93 | 	var v binRoundTrip
 94 | 	switch "Msg" + msgName {
 95 | 	case MsgGetReaderCapabilitiesResponse.String():
 96 | 		v = &GetReaderCapabilitiesResponse{}
 97 | 	case MsgGetReaderConfigResponse.String():
 98 | 		v = &GetReaderConfigResponse{}
 99 | 	case MsgGetAccessSpecsResponse.String():
100 | 		v = &GetAccessSpecsResponse{}
101 | 	case MsgGetROSpecsResponse.String():
102 | 		v = &GetROSpecsResponse{}
103 | 	case MsgCloseConnectionResponse.String():
104 | 		v = &CloseConnectionResponse{}
105 | 	case MsgReaderEventNotification.String():
106 | 		v = &ReaderEventNotification{}
107 | 	case MsgROAccessReport.String():
108 | 		v = &ROAccessReport{}
109 | 		// note no default needed: the first couple lines of the test check for `nil`.
110 | 	}
111 | 
112 | 	// This tests the following two conversions using data captured from a reader:
113 | 	//   JSON -> Go -> binary & check it matches original binary
114 | 	// binary -> Go -> JSON   & check it matches original JSON
115 | 	return func(t *testing.T) {
116 | 		if v == nil {
117 | 			t.Fatalf("unknown message type: %s; "+
118 | 				"did you add a new one but forget to add it to the switch?", msgName)
119 | 		}
120 | 
121 | 		var originalJSON, originalBin, marshaledBin, marshaledJSON []byte
122 | 		var err error
123 | 
124 | 		// load data files
125 | 		originalJSON, err = os.ReadFile(prefix + ".json")
126 | 		if err != nil {
127 | 			t.Fatalf("can't read .json file: %v", err)
128 | 		}
129 | 
130 | 		originalBin, err = os.ReadFile(prefix + ".bytes")
131 | 		if err != nil {
132 | 			t.Fatalf("can't read .bytes file: %v", err)
133 | 		}
134 | 
135 | 		// unmarshal original JSON form
136 | 		if err = json.Unmarshal(originalJSON, v); err != nil {
137 | 			t.Error(err)
138 | 		}
139 | 
140 | 		// marshal resulting struct to binary
141 | 		if marshaledBin, err = v.MarshalBinary(); err != nil {
142 | 			t.Error(err)
143 | 		}
144 | 
145 | 		// get a new v (so we're not duplicating list items)
146 | 		v = reflect.New(reflect.TypeOf(v).Elem()).Interface().(binRoundTrip)
147 | 
148 | 		// unmarshal original binary form to struct
149 | 		if err = v.UnmarshalBinary(originalBin); err != nil {
150 | 			t.Error(err)
151 | 		}
152 | 
153 | 		// marshal struct back to JSON
154 | 		marshaledJSON, err = json.MarshalIndent(v, "", "\t")
155 | 		if err != nil {
156 | 			t.Error(err)
157 | 		}
158 | 
159 | 		// Check the JSON first, since it'll be easier to eyeball differences.
160 | 		// If names change, unmarshaling is likely to leave many zero values,
161 | 		// which will make the binary mismatched.
162 | 		// The name differences should be pretty obvious when viewing the JSON.
163 | 		checkJSONEq(t, originalJSON, marshaledJSON)
164 | 
165 | 		// Finally, confirm binary the matches.
166 | 		checkBytesEq(t, originalBin, marshaledBin)
167 | 	}
168 | }
169 | 
170 | // checkJSONEq checks that two json data byte arrays are equal line-by-line,
171 | // ignoring leading and trailing whitespace within each line,
172 | // as well as any remaining whitespace at the end of the data.
173 | //
174 | // If not, it prints a side-by-side diff around the first line difference.
175 | //
176 | // Returns true if the two arrays are equal; false otherwise.
177 | func checkJSONEq(t *testing.T, original, marshaled []byte) (matched bool) {
178 | 	t.Helper()
179 | 
180 | 	lines1, lines2 := bytes.Split(original, []byte("\n")), bytes.Split(marshaled, []byte("\n"))
181 | 
182 | 	larger, smaller := lines1, lines2
183 | 	if len(lines1) < len(lines2) {
184 | 		larger, smaller = lines2, lines1
185 | 	}
186 | 
187 | 	matched = true
188 | 	firstDiff := 0
189 | 	for ; matched && firstDiff < len(smaller); firstDiff++ {
190 | 		matched = bytes.Equal(
191 | 			bytes.TrimSpace(lines1[firstDiff]),
192 | 			bytes.TrimSpace(lines2[firstDiff]))
193 | 	}
194 | 	firstDiff--
195 | 
196 | 	// the larger of the two may only have blank lines
197 | 	for i := firstDiff + 1; matched && i < len(larger); i++ {
198 | 		matched = len(bytes.TrimSpace(larger[i])) == 0
199 | 	}
200 | 
201 | 	if matched {
202 | 		return
203 | 	}
204 | 
205 | 	const contextAbove = 4
206 | 	start := firstDiff - contextAbove
207 | 	if start < 0 {
208 | 		start = 0
209 | 	}
210 | 
211 | 	const contextTotal = 16
212 | 	end := start + contextTotal
213 | 	if end > len(lines1)-1 {
214 | 		end = len(lines1) - 1
215 | 	}
216 | 
217 | 	if end > len(lines2)-1 {
218 | 		end = len(lines2) - 1
219 | 	}
220 | 
221 | 	longest := 1
222 | 	for i := start; i < end; i++ {
223 | 		lines1[i] = bytes.ReplaceAll(lines1[i], []byte("\t"), []byte("  "))
224 | 		lines2[i] = bytes.ReplaceAll(lines2[i], []byte("\t"), []byte("  "))
225 | 		if len(lines1[i]) > longest {
226 | 			longest = len(lines1[i])
227 | 		}
228 | 		if len(lines2[i]) > longest {
229 | 			longest = len(lines2[i])
230 | 		}
231 | 	}
232 | 
233 | 	diff := bytes.Buffer{}
234 | 	fmt.Fprintf(&diff, "%-[1]*s  |  %s\n", longest,
235 | 		"    --Original JSON Data--", "    --Marshaled Result--")
236 | 	for i := start; i < end; i++ {
237 | 		if i == firstDiff {
238 | 			msg := "--first diff below this line--"
239 | 			fmt.Fprintf(&diff, "%[1]*s\n", longest+3+len(msg)/2, msg)
240 | 		}
241 | 		fmt.Fprintf(&diff, "%-[1]*s  |  %s\n", longest, lines1[i], lines2[i])
242 | 	}
243 | 
244 | 	t.Errorf("JSON data mismatched; first difference around line %d:\n%s",
245 | 		firstDiff, diff.String())
246 | 	return matched
247 | }
248 | 
249 | func checkBytesEq(t *testing.T, original, marshaled []byte) (matched bool) {
250 | 	t.Helper()
251 | 
252 | 	matched = len(original) == len(marshaled)
253 | 	smaller := len(marshaled)
254 | 	if len(original) < len(marshaled) {
255 | 		smaller = len(original)
256 | 		matched = false
257 | 	}
258 | 
259 | 	firstDiff := 0
260 | 	for ; firstDiff < smaller; firstDiff++ {
261 | 		if original[firstDiff] != marshaled[firstDiff] {
262 | 			matched = false
263 | 			break
264 | 		}
265 | 	}
266 | 
267 | 	if matched {
268 | 		return
269 | 	}
270 | 
271 | 	if len(original) == 0 || len(marshaled) == 0 {
272 | 		t.Errorf("byte data mismatched: one is empty: \n"+
273 | 			" original: %# 02x\n"+
274 | 			"marshaled: %# 02x", original, marshaled)
275 | 		return
276 | 	}
277 | 
278 | 	// these constants control how much context to show
279 | 	const bpl = 8    // bytes per line (per byte array, so really, 2x this)
280 | 	const before = 2 // lines before first diff
281 | 	const after = 4  // lines after first diff
282 | 
283 | 	start := ((firstDiff / bpl) - before) * bpl
284 | 	if start < 0 {
285 | 		start = 0
286 | 	}
287 | 	end := start + bpl*(before+after)
288 | 
289 | 	ob := original[start:]
290 | 	mb := marshaled[start:]
291 | 
292 | 	format := fmt.Sprintf("%%04d-%%04d > %%#- %d.%dx |  %%# .%dx\n", bpl*5, bpl, bpl)
293 | 
294 | 	buff := bytes.Buffer{}
295 | 	for i := start; i < end && (len(ob) > 0 || len(mb) > 0); i += bpl {
296 | 		if i <= firstDiff && firstDiff < i+bpl {
297 | 			buff.Write(bytes.Repeat([]byte(" "), 5*(firstDiff-i)+12))
298 | 			buff.WriteString(expand((bpl+1)*5+4, "-", "v", "first diff", "v\n"))
299 | 		}
300 | 
301 | 		fmt.Fprintf(&buff, format, i, i+bpl, ob, mb)
302 | 
303 | 		if len(ob) > bpl {
304 | 			ob = ob[bpl:]
305 | 		} else {
306 | 			ob = nil
307 | 		}
308 | 
309 | 		if len(mb) > bpl {
310 | 			mb = mb[bpl:]
311 | 		} else {
312 | 			mb = nil
313 | 		}
314 | 	}
315 | 
316 | 	t.Errorf("byte data mismatched starting at byte %d\n"+
317 | 		"  index   > %[2]*s |  marshaled binary\n%s",
318 | 		firstDiff, bpl*5, "original binary", buff.String())
319 | 
320 | 	return matched
321 | }
322 | 
323 | // expand returns a string that centers s between l and r
324 | // by inserting fill as many times as need
325 | // so that the final string has at least the given width.
326 | //
327 | // If width <= len(l+s+r), this return l+s+r,
328 | // even if that would be larger than width.
329 | // Otherwise, it inserts the minimum number of fill values
330 | // so that the len the returned value >= width.
331 | // If len(fill) == 1, it'll insert just to width.
332 | // If it's larger, the return might exceed width by as much.
333 | // If it's an empty string, this'll panic.
334 | func expand(width int, fill, l, s, r string) string {
335 | 	width -= len(s) + len(l) + len(r)
336 | 	nFills := atLeastZero(width / len(fill))
337 | 	rFill := atLeastZero(nFills / 2)
338 | 	lFill := atLeastZero(nFills - rFill)
339 | 	return l + strings.Repeat(fill, rFill) + s + strings.Repeat(fill, lFill) + r
340 | }
341 | 
342 | func atLeastZero(i int) int {
343 | 	if i < 0 {
344 | 		return 0
345 | 	}
346 | 	return i
347 | }
348 | 


--------------------------------------------------------------------------------
/pkg/llrp/reader_functional_test.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package llrp
  7 | 
  8 | import (
  9 | 	"context"
 10 | 	"encoding"
 11 | 	"encoding/json"
 12 | 	"errors"
 13 | 	"flag"
 14 | 	"fmt"
 15 | 	"net"
 16 | 	"os"
 17 | 	"path/filepath"
 18 | 	"testing"
 19 | 	"time"
 20 | )
 21 | 
 22 | // ex: go test -reader="192.0.2.1:5084"
 23 | // if using Goland, put that in the 'program arguments' part of the test config
 24 | var readerAddr = flag.String("reader", "", "address of an LLRP reader; enables functional tests")
 25 | var update = flag.Bool("update", false, "rather than testing, record messages to the testdata directory")
 26 | var roDirectory = flag.String("ro-access-dir", "roAccessReports", "subdirectory of testdata for storing RO Access Reports")
 27 | 
 28 | func TestClientFunctional(t *testing.T) {
 29 | 	addr := *readerAddr
 30 | 	if addr == "" {
 31 | 		t.Skip("no reader set for functional tests; use -test.reader=\"host:port\" to run")
 32 | 	}
 33 | 
 34 | 	if *update {
 35 | 		if err := os.MkdirAll("testdata", 0755); err != nil {
 36 | 			t.Fatal(err)
 37 | 		}
 38 | 
 39 | 		t.Run("collectData", func(t *testing.T) {
 40 | 			if err := collectData(); err != nil && !errors.Is(err, ErrClientClosed) {
 41 | 				t.Fatal(err)
 42 | 			}
 43 | 		})
 44 | 
 45 | 		t.Run("gatherTagReads", testGatherTagReads)
 46 | 
 47 | 		t.Skip("collected data instead of running tests")
 48 | 		return
 49 | 	}
 50 | 
 51 | 	for _, testConfig := range []struct {
 52 | 		Outgoing
 53 | 		Incoming
 54 | 	}{
 55 | 		{&GetReaderConfig{}, &GetReaderConfigResponse{}},
 56 | 		{&GetReaderCapabilities{}, &GetReaderCapabilitiesResponse{}},
 57 | 		{&GetROSpecs{}, &GetROSpecsResponse{}},
 58 | 	} {
 59 | 		testConfig := testConfig
 60 | 
 61 | 		t.Run(testConfig.Incoming.Type().String(), func(t *testing.T) {
 62 | 			r := GetFunctionalClient(t, *readerAddr)
 63 | 			sendAndCheck(t, r, testConfig.Outgoing, testConfig.Incoming)
 64 | 		})
 65 | 	}
 66 | 
 67 | 	t.Run("gatherTagReads", testGatherTagReads)
 68 | }
 69 | 
 70 | // collectData populates the testdata directory for use in future tests.
 71 | func collectData() error {
 72 | 	conn, err := net.Dial("tcp", *readerAddr)
 73 | 	if err != nil {
 74 | 		return err
 75 | 	}
 76 | 
 77 | 	if err := conn.SetDeadline(time.Now().Add(120 * time.Second)); err != nil {
 78 | 		return err
 79 | 	}
 80 | 
 81 | 	r := NewClient()
 82 | 	defer r.Close()
 83 | 
 84 | 	connErrs := make(chan error, 1)
 85 | 	go func() {
 86 | 		defer close(connErrs)
 87 | 		connErrs <- r.Connect(conn)
 88 | 	}()
 89 | 
 90 | 	if r.version > Version1_0_1 {
 91 | 		if err := getAndWrite(r, MsgGetSupportedVersion, nil, &GetSupportedVersionResponse{}); err != nil {
 92 | 			return err
 93 | 		}
 94 | 	}
 95 | 
 96 | 	var errs []error
 97 | 	for _, toSend := range []struct {
 98 | 		mt  MessageType
 99 | 		out encoding.BinaryMarshaler
100 | 		in  encoding.BinaryUnmarshaler
101 | 	}{
102 | 		{MsgGetReaderConfig, &GetReaderConfig{}, &GetReaderConfigResponse{}},
103 | 		{MsgGetReaderCapabilities, &GetReaderCapabilities{}, &GetReaderCapabilitiesResponse{}},
104 | 		{MsgGetROSpecs, nil, &GetROSpecsResponse{}},
105 | 		{MsgGetAccessSpecs, nil, &GetAccessSpecsResponse{}},
106 | 		{MsgGetReport, nil, &ROAccessReport{}},
107 | 		{MsgCloseConnection, nil, &CloseConnectionResponse{}},
108 | 	} {
109 | 		if err := getAndWrite(r, toSend.mt, toSend.out, toSend.in); err != nil {
110 | 			if errors.Is(err, context.DeadlineExceeded) {
111 | 				errs = append(errs, fmt.Errorf("failed to get response for %v: %v", toSend.mt, err))
112 | 			} else {
113 | 				return err
114 | 			}
115 | 		}
116 | 	}
117 | 
118 | 	// We skip Shutdown because we directly sent CloseConnection.
119 | 	if err := r.Close(); err != nil {
120 | 		errs = append(errs, err)
121 | 	}
122 | 
123 | 	if err := <-connErrs; err != nil {
124 | 		errs = append(errs, err)
125 | 	}
126 | 
127 | 	{
128 | 		var errMsg string
129 | 		for _, e := range errs {
130 | 			errMsg += e.Error() + "\n"
131 | 		}
132 | 		if errMsg != "" {
133 | 			return errors.New(errMsg)
134 | 		}
135 | 	}
136 | 
137 | 	return <-connErrs
138 | }
139 | 
140 | // getAndWrite
141 | func getAndWrite(r *Client, mt MessageType, payload encoding.BinaryMarshaler, resultValue encoding.BinaryUnmarshaler) error {
142 | 	var data []byte
143 | 	if payload != nil {
144 | 		var err error
145 | 		data, err = payload.MarshalBinary()
146 | 		if err != nil {
147 | 			return err
148 | 		}
149 | 	}
150 | 
151 | 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
152 | 	defer cancel()
153 | 
154 | 	resultT, result, err := r.SendMessage(ctx, mt, data)
155 | 	if err != nil {
156 | 		return err
157 | 	}
158 | 
159 | 	expR, ok := mt.Converse()
160 | 	if ok && expR != resultT {
161 | 		return fmt.Errorf("expected %v; got %v", expR, mt)
162 | 	}
163 | 
164 | 	return writeCapture("testdata", 0, result, resultT, resultValue)
165 | }
166 | 
167 | func writeCapture(dir string, idx uint32, result []byte, typ MessageType, decoder encoding.BinaryUnmarshaler) error {
168 | 	baseName := fmt.Sprintf("%v-%03d", typ.String()[len("Msg"):], idx)
169 | 	bfn := filepath.Join(dir, baseName+".bytes")
170 | 	jfn := filepath.Join(dir, baseName+".json")
171 | 
172 | 	//nolint: gosec //G306: Expect WriteFile permissions to be 0600 or less
173 | 	if err := os.WriteFile(bfn, result, 0644); err != nil {
174 | 		return err
175 | 	}
176 | 
177 | 	if err := decoder.UnmarshalBinary(result); err != nil {
178 | 		return err
179 | 	}
180 | 
181 | 	j, err := json.MarshalIndent(decoder, "", "\t")
182 | 	if err != nil {
183 | 		return err
184 | 	}
185 | 
186 | 	//nolint: gosec //G306: Expect WriteFile permissions to be 0600 or less
187 | 	if err := os.WriteFile(jfn, j, 0644); err != nil {
188 | 		return err
189 | 	}
190 | 
191 | 	return nil
192 | }
193 | 
194 | func testGatherTagReads(t *testing.T) {
195 | 	if testing.Short() {
196 | 		t.Skip("-short flag: skipping gather tag reads, since it takes 10s")
197 | 	}
198 | 	r := GetFunctionalClient(t, *readerAddr)
199 | 
200 | 	spec := &ROSpec{
201 | 		ROSpecID:           1,
202 | 		Priority:           0,
203 | 		ROSpecCurrentState: ROSpecStateDisabled,
204 | 		ROBoundarySpec: ROBoundarySpec{
205 | 			StartTrigger: ROSpecStartTrigger{
206 | 				Trigger: ROStartTriggerImmediate,
207 | 			},
208 | 			StopTrigger: ROSpecStopTrigger{
209 | 				Trigger:              ROStopTriggerDuration,
210 | 				DurationTriggerValue: 10,
211 | 			},
212 | 		},
213 | 		AISpecs: []AISpec{{
214 | 			AntennaIDs: []AntennaID{0},
215 | 			StopTrigger: AISpecStopTrigger{
216 | 				Trigger: AIStopTriggerNone,
217 | 			},
218 | 			InventoryParameterSpecs: []InventoryParameterSpec{{
219 | 				InventoryParameterSpecID: 1,
220 | 				AirProtocolID:            AirProtoEPCGlobalClass1Gen2,
221 | 			}},
222 | 		}},
223 | 		ROReportSpec: &ROReportSpec{
224 | 			Trigger: NTagsOrROEnd,
225 | 			N:       5,
226 | 			TagReportContentSelector: TagReportContentSelector{
227 | 				EnablePeakRSSI: true,
228 | 			},
229 | 		},
230 | 	}
231 | 
232 | 	sendAndCheck(t, r, &AddROSpec{*spec}, &AddROSpecResponse{})
233 | 	sendAndCheck(t, r, &EnableROSpec{ROSpecID: spec.ROSpecID}, &EnableROSpecResponse{})
234 | 	time.Sleep(10 * time.Second)
235 | 	sendAndCheck(t, r, &DisableROSpec{ROSpecID: spec.ROSpecID}, &DisableROSpecResponse{})
236 | 	sendAndCheck(t, r, &DeleteROSpec{ROSpecID: spec.ROSpecID}, &DeleteROSpecResponse{})
237 | }
238 | 
239 | func prettyPrint(t *testing.T, v interface{}) {
240 | 	t.Helper()
241 | 	if pretty, err := json.MarshalIndent(v, "", "\t"); err != nil {
242 | 		t.Errorf("can't pretty print %+v: %+v", v, err)
243 | 	} else {
244 | 		t.Logf("%s", pretty)
245 | 	}
246 | }
247 | 
248 | func sendAndCheck(t *testing.T, c *Client, out Outgoing, in Incoming) {
249 | 	t.Helper()
250 | 
251 | 	if testing.Verbose() {
252 | 		prettyPrint(t, out)
253 | 	}
254 | 
255 | 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
256 | 	defer cancel()
257 | 
258 | 	var sendErr error
259 | 	if in != nil {
260 | 		sendErr = c.SendFor(ctx, out, in)
261 | 	} else {
262 | 		outData, err := out.MarshalBinary()
263 | 		if err != nil {
264 | 			t.Errorf("%+v", err)
265 | 			return
266 | 		}
267 | 
268 | 		msg, err := NewByteMessage(out.Type(), outData)
269 | 		if err != nil {
270 | 			t.Errorf("%+v", err)
271 | 			return
272 | 		}
273 | 
274 | 		sendErr = c.SendNoWait(ctx, msg)
275 | 	}
276 | 
277 | 	if sendErr != nil {
278 | 		t.Errorf("%+v", sendErr)
279 | 	}
280 | 
281 | 	if in != nil && testing.Verbose() {
282 | 		prettyPrint(t, in)
283 | 	}
284 | }
285 | 


--------------------------------------------------------------------------------
/pkg/llrp/test_emulator.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package llrp
  7 | 
  8 | import (
  9 | 	"net"
 10 | 	"strconv"
 11 | 	"sync"
 12 | 	"sync/atomic"
 13 | )
 14 | 
 15 | // TestEmulator acts like an LLRP server. It accepts connections on a configurable network port,
 16 | // and when an LLRP client dials this TestEmulator, a new TestDevice is created which manages only
 17 | // the "reader" side of the connection.
 18 | //
 19 | // Functions exist to allow developer to provide "canned" responses to messages, and change them on the fly
 20 | // to allow changing
 21 | //
 22 | // NOTE: Unlike an actual LLRP server/reader, more than one simultaneous client are allowed to connect to it,
 23 | //
 24 | //	however each client will receive the same canned responses.
 25 | type TestEmulator struct {
 26 | 	silent bool
 27 | 
 28 | 	listener net.Listener
 29 | 	done     uint32
 30 | 
 31 | 	// keep track of canned responses
 32 | 	responses   map[MessageType]Outgoing
 33 | 	responsesMu sync.Mutex
 34 | 
 35 | 	// active connections/devices
 36 | 	devices   map[*TestDevice]bool
 37 | 	devicesMu sync.Mutex
 38 | }
 39 | 
 40 | func NewTestEmulator(silent bool) *TestEmulator {
 41 | 	return &TestEmulator{
 42 | 		silent:    silent,
 43 | 		responses: make(map[MessageType]Outgoing),
 44 | 		devices:   make(map[*TestDevice]bool),
 45 | 	}
 46 | }
 47 | 
 48 | // StartAsync starts listening on a specific port until emu.Shutdown() is called
 49 | func (emu *TestEmulator) StartAsync(port int) error {
 50 | 	var err error
 51 | 
 52 | 	emu.listener, err = net.Listen("tcp4", ":"+strconv.Itoa(port))
 53 | 	if err != nil {
 54 | 		return err
 55 | 	}
 56 | 
 57 | 	go emu.listenUntilCancelled()
 58 | 	return nil
 59 | }
 60 | 
 61 | // Shutdown attempts to cleanly shutdown the emulator
 62 | func (emu *TestEmulator) Shutdown() error {
 63 | 	atomic.StoreUint32(&emu.done, 1)
 64 | 	if err := emu.listener.Close(); err != nil {
 65 | 		return err
 66 | 	}
 67 | 
 68 | 	emu.devicesMu.Lock()
 69 | 	defer emu.devicesMu.Unlock()
 70 | 
 71 | 	for dev := range emu.devices {
 72 | 		if err := dev.Close(); err != nil {
 73 | 			return err
 74 | 		}
 75 | 	}
 76 | 
 77 | 	return nil
 78 | }
 79 | 
 80 | // listenUntilCancelled listens forever on the net.Listener until emu.Shutdown() is called
 81 | func (emu *TestEmulator) listenUntilCancelled() {
 82 | 	for {
 83 | 		conn, err := emu.listener.Accept()
 84 | 		if atomic.LoadUint32(&emu.done) == 1 {
 85 | 			return
 86 | 		} else if err != nil {
 87 | 			panic("listener accept failed: " + err.Error())
 88 | 		}
 89 | 
 90 | 		go emu.handleNewConn(conn)
 91 | 	}
 92 | }
 93 | 
 94 | // handleNewConn handles a new incoming connection the net.Listener (should be spawned async)
 95 | func (emu *TestEmulator) handleNewConn(conn net.Conn) {
 96 | 	td, err := NewReaderOnlyTestDevice(conn, emu.silent)
 97 | 	if err != nil {
 98 | 		panic("unable to create a new ReaderOnly TestDevice: " + err.Error())
 99 | 	}
100 | 
101 | 	emu.responsesMu.Lock()
102 | 	for mt, out := range emu.responses {
103 | 		td.SetResponse(mt, out)
104 | 	}
105 | 	emu.responsesMu.Unlock()
106 | 	td.reader.handlers[MsgCloseConnection] = emu.createCloseHandler(td)
107 | 
108 | 	emu.devicesMu.Lock()
109 | 	emu.devices[td] = true
110 | 	emu.devicesMu.Unlock()
111 | 
112 | 	td.ImpersonateReader()
113 | }
114 | 
115 | // SetResponse adds a canned response to all future clients. Optionally,
116 | // if `applyExisting` is true, this will affect all currently active clients.
117 | //
118 | // NOTE 1: This will OVERRIDE existing response for given message type
119 | //
120 | // NOTE 2: Setting the response for MsgCloseConnection is NOT SUPPORTED and will be overridden by internal handler.
121 | func (emu *TestEmulator) SetResponse(mt MessageType, out Outgoing) {
122 | 	emu.responsesMu.Lock()
123 | 	emu.responses[mt] = out
124 | 	emu.responsesMu.Unlock()
125 | }
126 | 
127 | // createCloseHandler handles a client request to close the connection.
128 | func (emu *TestEmulator) createCloseHandler(td *TestDevice) MessageHandlerFunc {
129 | 	return func(_ *Client, msg Message) {
130 | 		if td.wrongVersion(msg) {
131 | 			return
132 | 		}
133 | 
134 | 		td.write(msg.id, &CloseConnectionResponse{})
135 | 
136 | 		_ = td.reader.Close()
137 | 		_ = td.rConn.Close()
138 | 
139 | 		emu.devicesMu.Lock()
140 | 		// remove it from the set of active connections
141 | 		delete(emu.devices, td)
142 | 		emu.devicesMu.Unlock()
143 | 	}
144 | }
145 | 


--------------------------------------------------------------------------------
/pkg/llrp/test_helpers.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | package llrp
  7 | 
  8 | import (
  9 | 	"context"
 10 | 	"errors"
 11 | 	"fmt"
 12 | 	"net"
 13 | 	"sync"
 14 | 	"sync/atomic"
 15 | 	"testing"
 16 | 	"time"
 17 | )
 18 | 
 19 | // GetFunctionalClient attempts to dial and connect to an LLRP Reader at the given address.
 20 | //
 21 | // If it's unable to connect to the address, it fails the test immediately.
 22 | // It registers a Cleanup function to close the connection and checks for errors,
 23 | // and will run automatically when the test completes.
 24 | func GetFunctionalClient(t *testing.T, readerAddr string) (r *Client) {
 25 | 	conn, err := net.Dial("tcp", readerAddr)
 26 | 	if err != nil {
 27 | 		t.Fatal(err)
 28 | 	}
 29 | 
 30 | 	opts := []ClientOpt{WithTimeout(300 * time.Second)}
 31 | 	if testing.Short() {
 32 | 		opts[0] = WithTimeout(10 * time.Second)
 33 | 	}
 34 | 	if testing.Verbose() {
 35 | 		opts = append(opts, WithStdLogger("test"))
 36 | 	}
 37 | 
 38 | 	r = NewClient(opts...)
 39 | 
 40 | 	errs := make(chan error)
 41 | 	go func() {
 42 | 		defer close(errs)
 43 | 		errs <- r.Connect(conn)
 44 | 	}()
 45 | 
 46 | 	t.Cleanup(func() {
 47 | 		ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
 48 | 		defer cancel()
 49 | 		if err := r.Shutdown(ctx); err != nil {
 50 | 			if err := r.Close(); err != nil {
 51 | 				if !errors.Is(err, ErrClientClosed) {
 52 | 					t.Errorf("%+v", err)
 53 | 				}
 54 | 			}
 55 | 
 56 | 			if !errors.Is(err, ErrClientClosed) {
 57 | 				t.Errorf("%+v", err)
 58 | 			}
 59 | 		}
 60 | 
 61 | 		for err := range errs {
 62 | 			if !errors.Is(err, ErrClientClosed) {
 63 | 				t.Errorf("%+v", err)
 64 | 			}
 65 | 		}
 66 | 	})
 67 | 
 68 | 	return r
 69 | }
 70 | 
 71 | // TestDevice is a useful mock of an LLRP device.
 72 | //
 73 | // Create one view NewTestDevice,
 74 | // then start it with ImpersonateReader,
 75 | type TestDevice struct {
 76 | 	Client, reader *Client
 77 | 	cConn, rConn   net.Conn
 78 | 
 79 | 	ReaderLogs ClientLogger
 80 | 	w          *msgWriter
 81 | 	maxVer     VersionNum
 82 | 	mid        messageID
 83 | 
 84 | 	errsMu sync.Mutex
 85 | 	errors []error
 86 | }
 87 | 
 88 | // NewTestDevice returns a TestDevice with a client ready to connect.
 89 | func NewTestDevice(maxReaderVer, maxClientVer VersionNum, timeout time.Duration, silent bool) (*TestDevice, error) {
 90 | 	cConn, rConn := net.Pipe()
 91 | 
 92 | 	logOpt := WithStdLogger("test")
 93 | 	if silent {
 94 | 		logOpt = WithLogger(nil)
 95 | 	}
 96 | 
 97 | 	client := NewClient(WithVersion(maxClientVer), WithTimeout(timeout), logOpt)
 98 | 	reader := NewClient(WithVersion(Version1_0_1), logOpt)
 99 | 	reader.conn = rConn
100 | 
101 | 	td := TestDevice{
102 | 		Client: client,
103 | 		cConn:  cConn,
104 | 		rConn:  rConn,
105 | 		reader: reader,
106 | 		maxVer: maxReaderVer,
107 | 		w:      newMsgWriter(rConn, Version1_0_1),
108 | 	}
109 | 
110 | 	td.setupInitialHandlers()
111 | 
112 | 	return &td, nil
113 | }
114 | 
115 | // NewReaderOnlyTestDevice returns a TestDevice which only manages the Reader (aka Server)
116 | // portion of the communication, attaching to an existing net.Conn
117 | func NewReaderOnlyTestDevice(conn net.Conn, silent bool) (*TestDevice, error) {
118 | 	logOpt := WithStdLogger("test")
119 | 	if silent {
120 | 		logOpt = WithLogger(nil)
121 | 	}
122 | 
123 | 	reader := NewClient(WithVersion(Version1_0_1), logOpt)
124 | 	reader.conn = conn
125 | 
126 | 	td := TestDevice{
127 | 		rConn:  conn,
128 | 		reader: reader,
129 | 		maxVer: VersionMax,
130 | 		w:      newMsgWriter(conn, Version1_0_1),
131 | 	}
132 | 
133 | 	td.setupInitialHandlers()
134 | 
135 | 	return &td, nil
136 | }
137 | 
138 | func (td *TestDevice) setupInitialHandlers() {
139 | 	td.reader.handlers[MsgGetSupportedVersion] = MessageHandlerFunc(td.getSupportedVersion)
140 | 	td.reader.handlers[MsgSetProtocolVersion] = MessageHandlerFunc(td.setVersion)
141 | 	td.reader.handlers[MsgCloseConnection] = MessageHandlerFunc(td.closeConnection)
142 | 	td.reader.defaultHandler = MessageHandlerFunc(td.handleUnknownMessage)
143 | }
144 | 
145 | func (td *TestDevice) SetResponse(mt MessageType, out Outgoing) {
146 | 	td.reader.handlers[mt] = MessageHandlerFunc(func(_ *Client, msg Message) {
147 | 		if td.wrongVersion(msg) {
148 | 			return
149 | 		}
150 | 		td.write(msg.id, out)
151 | 	})
152 | }
153 | 
154 | // Errors returns accumulated errors.
155 | // It should only be called after the TestDevice is closed.
156 | func (td *TestDevice) Errors() []error {
157 | 	return td.errors
158 | }
159 | 
160 | func (td *TestDevice) Version() VersionNum {
161 | 	return td.w.header.version
162 | }
163 | 
164 | // errCheck appends non-nil errors to its errors list and returns true.
165 | // If err is nil, it simply returns false.
166 | // It is safe for concurrent use.
167 | func (td *TestDevice) errCheck(err error) bool {
168 | 	if err != nil {
169 | 		td.errsMu.Lock()
170 | 		td.errors = append(td.errors, err)
171 | 		td.errsMu.Unlock()
172 | 	}
173 | 	return err != nil
174 | }
175 | 
176 | // wrongVersion checks if a message has a version different from the TestDevice.
177 | // If so, it writes an LLRPStatus with the correct error and returns true.
178 | // Otherwise, it returns false.
179 | // Use it to quickly check the input and bail on any mismatched versions.
180 | func (td *TestDevice) wrongVersion(msg Message) bool {
181 | 	if td.Version() == msg.version {
182 | 		return false
183 | 	}
184 | 
185 | 	_ = td.errCheck(td.w.Write(msg.id, &ErrorMessage{LLRPStatus: LLRPStatus{
186 | 		Status:           StatusMsgVerUnsupported,
187 | 		ErrorDescription: StatusMsgVerUnsupported.defaultText(),
188 | 	}}))
189 | 	return true
190 | }
191 | 
192 | // getSupportedVersion responds to the GetSupportedVersion message.
193 | func (td *TestDevice) getSupportedVersion(_ *Client, msg Message) {
194 | 	if td.wrongVersion(msg) {
195 | 		return
196 | 	}
197 | 
198 | 	rsp := &GetSupportedVersionResponse{
199 | 		CurrentVersion:      td.Version(),
200 | 		MaxSupportedVersion: td.maxVer,
201 | 	}
202 | 
203 | 	// LLRP requires this message sent with the header's Version set to 1.1
204 | 	oldV := td.Version()
205 | 	defer func() { td.w.header.version = oldV }()
206 | 
207 | 	td.w.header.version = Version1_1
208 | 	_ = td.errCheck(td.w.Write(msg.id, rsp))
209 | }
210 | 
211 | // setVersion responds to the SetProtocolVersion message.
212 | func (td *TestDevice) setVersion(_ *Client, msg Message) {
213 | 	if td.Version() == Version1_0_1 {
214 | 		_ = td.wrongVersion(msg)
215 | 		return
216 | 	}
217 | 
218 | 	spv := SetProtocolVersion{}
219 | 	if td.errCheck(msg.UnmarshalTo(&spv)) {
220 | 		return
221 | 	}
222 | 
223 | 	if spv.TargetVersion > td.maxVer {
224 | 		_ = td.errCheck(td.w.Write(msg.id, &ErrorMessage{LLRPStatus: LLRPStatus{
225 | 			Status:           StatusMsgVerUnsupported,
226 | 			ErrorDescription: fmt.Sprintf("max supported is %d", td.maxVer),
227 | 		}}))
228 | 		return
229 | 	}
230 | 
231 | 	if spv.TargetVersion < VersionMin {
232 | 		_ = td.errCheck(td.w.Write(msg.id, &ErrorMessage{LLRPStatus: LLRPStatus{
233 | 			Status:           StatusMsgVerUnsupported,
234 | 			ErrorDescription: fmt.Sprintf("min supported is %d", VersionMin),
235 | 		}}))
236 | 		return
237 | 	}
238 | 
239 | 	td.w.header.version = spv.TargetVersion
240 | 	// Setting the "reader" Client version races with the incoming message handler,
241 | 	// but it's only purpose here is to quite a warning log message.
242 | 	td.reader.version = spv.TargetVersion
243 | 	td.write(msg.id, &SetProtocolVersionResponse{})
244 | }
245 | 
246 | // write a given Outgoing message with the given id.
247 | func (td *TestDevice) write(mid messageID, out Outgoing) {
248 | 	_ = td.errCheck(td.w.Write(mid, out))
249 | }
250 | 
251 | // handleUnknownMessage responds with the correct LLRPStatus for unknown messages.
252 | func (td *TestDevice) handleUnknownMessage(_ *Client, msg Message) {
253 | 	if td.wrongVersion(msg) {
254 | 		return
255 | 	}
256 | 
257 | 	td.write(msg.id, &ErrorMessage{LLRPStatus: LLRPStatus{
258 | 		Status:           StatusMsgMsgUnexpected,
259 | 		ErrorDescription: StatusMsgMsgUnsupported.defaultText(),
260 | 	}})
261 | }
262 | 
263 | // ImpersonateReader prepares the TestDevice to impersonate an LLRP reader,
264 | // as if a Client had correctly dialed it, but before version negotiation begins.
265 | func (td *TestDevice) ImpersonateReader() {
266 | 	td.write(
267 | 		messageID(atomic.AddUint32((*uint32)(&td.mid), 1)),
268 | 		NewConnectMessage(ConnSuccess))
269 | 	close(td.reader.ready)
270 | 	// This is notably simpler than actually correctly managing the message queues.
271 | 	// All outgoing messages must be sent via the TestDevice's writer,
272 | 	// which IS NOT safe for concurrent use.
273 | 	td.errCheck(td.reader.handleIncoming())
274 | }
275 | 
276 | // Close the Reader (RFID device) by attempting to send CloseMessage,
277 | // then close net.Conn, returning any error from it.
278 | // This is an abnormal close condition in LLRP.
279 | func (td *TestDevice) Close() (err error) {
280 | 	defer func() {
281 | 		closeErr := td.reader.Close()
282 | 		if err == nil {
283 | 			err = closeErr
284 | 		}
285 | 		_ = td.rConn.Close()
286 | 	}()
287 | 
288 | 	err = td.w.Write(
289 | 		messageID(atomic.AddUint32((*uint32)(&td.mid), 1)),
290 | 		NewCloseMessage())
291 | 	return
292 | }
293 | 
294 | // closeConnection handles a client request to close the connection.
295 | func (td *TestDevice) closeConnection(_ *Client, msg Message) {
296 | 	if td.wrongVersion(msg) {
297 | 		return
298 | 	}
299 | 
300 | 	td.write(msg.id, &CloseConnectionResponse{})
301 | 	_ = td.reader.Close()
302 | 	_ = td.rConn.Close()
303 | }
304 | 
305 | // ConnectClient correctly connects the Client to the TestDevice and returns it.
306 | // It registers a Cleanup function to Shutdown the Client and report errors
307 | // once the test is completed, so it is not necessary to do so yourself.
308 | func (td *TestDevice) ConnectClient(t *testing.T) (c *Client) {
309 | 	c = td.Client
310 | 
311 | 	connErrs := make(chan error)
312 | 	go func() {
313 | 		defer close(connErrs)
314 | 		connErrs <- c.Connect(td.cConn)
315 | 	}()
316 | 
317 | 	t.Cleanup(func() {
318 | 		defer td.rConn.Close()
319 | 
320 | 		ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
321 | 		defer cancel()
322 | 		if err := td.Client.Shutdown(ctx); err != nil {
323 | 			if err := td.Client.Close(); err != nil && !errors.Is(err, ErrClientClosed) {
324 | 				t.Errorf("%+v", err)
325 | 			}
326 | 			t.Errorf("%+v", err)
327 | 		}
328 | 
329 | 		for err := range connErrs {
330 | 			if !errors.Is(err, ErrClientClosed) {
331 | 				t.Errorf("%+v", err)
332 | 			}
333 | 		}
334 | 	})
335 | 
336 | 	return c
337 | }
338 | 
339 | func NewConnectMessage(eventType ConnectionAttemptEventType) *ReaderEventNotification {
340 | 	c := ConnectionAttemptEvent(eventType)
341 | 	return &ReaderEventNotification{
342 | 		ReaderEventNotificationData: ReaderEventNotificationData{
343 | 			UTCTimestamp:           UTCTimestamp(time.Now().UnixNano() / 1000),
344 | 			ConnectionAttemptEvent: &c,
345 | 		}}
346 | }
347 | 
348 | func NewCloseMessage() *ReaderEventNotification {
349 | 	return &ReaderEventNotification{
350 | 		ReaderEventNotificationData: ReaderEventNotificationData{
351 | 			UTCTimestamp:         UTCTimestamp(time.Now().UnixNano() / 1000),
352 | 			ConnectionCloseEvent: &ConnectionCloseEvent{},
353 | 		}}
354 | }
355 | 


--------------------------------------------------------------------------------
/pkg/llrp/testdata/CloseConnectionResponse-000.bytes:
--------------------------------------------------------------------------------
1 | 



--------------------------------------------------------------------------------
/pkg/llrp/testdata/CloseConnectionResponse-000.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"LLRPStatus": {
3 | 		"Status": 0,
4 | 		"ErrorDescription": "",
5 | 		"FieldError": null,
6 | 		"ParameterError": null
7 | 	}
8 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetAccessSpecsResponse-000.bytes:
--------------------------------------------------------------------------------
1 | 



--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetAccessSpecsResponse-000.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"LLRPStatus": {
3 | 		"Status": 0,
4 | 		"ErrorDescription": "",
5 | 		"FieldError": null,
6 | 		"ParameterError": null
7 | 	},
8 | 	"AccessSpecs": null
9 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetROSpecsResponse-000.bytes:
--------------------------------------------------------------------------------
1 | 



--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetROSpecsResponse-000.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"LLRPStatus": {
3 | 		"Status": 0,
4 | 		"ErrorDescription": "",
5 | 		"FieldError": null,
6 | 		"ParameterError": null
7 | 	},
8 | 	"ROSpecs": null
9 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetReaderCapabilitiesResponse-000.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/GetReaderCapabilitiesResponse-000.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetReaderConfigResponse-000.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/GetReaderConfigResponse-000.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/GetReaderConfigResponse-000.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"LLRPStatus": {
  3 | 		"Status": 0,
  4 | 		"ErrorDescription": "",
  5 | 		"FieldError": null,
  6 | 		"ParameterError": null
  7 | 	},
  8 | 	"Identification": {
  9 | 		"IDType": 0,
 10 | 		"ReaderID": "ABYl//8RJdY="
 11 | 	},
 12 | 	"AntennaProperties": [
 13 | 		{
 14 | 			"AntennaConnected": true,
 15 | 			"AntennaID": 1,
 16 | 			"AntennaGain": 0
 17 | 		},
 18 | 		{
 19 | 			"AntennaConnected": false,
 20 | 			"AntennaID": 2,
 21 | 			"AntennaGain": 0
 22 | 		},
 23 | 		{
 24 | 			"AntennaConnected": false,
 25 | 			"AntennaID": 3,
 26 | 			"AntennaGain": 0
 27 | 		},
 28 | 		{
 29 | 			"AntennaConnected": false,
 30 | 			"AntennaID": 4,
 31 | 			"AntennaGain": 0
 32 | 		}
 33 | 	],
 34 | 	"AntennaConfigurations": [
 35 | 		{
 36 | 			"AntennaID": 1,
 37 | 			"RFReceiver": 1,
 38 | 			"RFTransmitter": {
 39 | 				"HopTableID": 1,
 40 | 				"ChannelIndex": 0,
 41 | 				"TransmitPowerIndex": 81
 42 | 			},
 43 | 			"C1G2InventoryCommand": {
 44 | 				"TagInventoryStateAware": false,
 45 | 				"Filters": null,
 46 | 				"RFControl": {
 47 | 					"RFModeID": 1000,
 48 | 					"Tari": 0
 49 | 				},
 50 | 				"SingulationControl": {
 51 | 					"Session": 1,
 52 | 					"TagPopulation": 32,
 53 | 					"TagTransitTime": 0,
 54 | 					"InvAwareAction": null
 55 | 				},
 56 | 				"Custom": null
 57 | 			},
 58 | 			"Custom": null
 59 | 		},
 60 | 		{
 61 | 			"AntennaID": 2,
 62 | 			"RFReceiver": 1,
 63 | 			"RFTransmitter": {
 64 | 				"HopTableID": 1,
 65 | 				"ChannelIndex": 0,
 66 | 				"TransmitPowerIndex": 81
 67 | 			},
 68 | 			"C1G2InventoryCommand": {
 69 | 				"TagInventoryStateAware": false,
 70 | 				"Filters": null,
 71 | 				"RFControl": {
 72 | 					"RFModeID": 1000,
 73 | 					"Tari": 0
 74 | 				},
 75 | 				"SingulationControl": {
 76 | 					"Session": 1,
 77 | 					"TagPopulation": 32,
 78 | 					"TagTransitTime": 0,
 79 | 					"InvAwareAction": null
 80 | 				},
 81 | 				"Custom": null
 82 | 			},
 83 | 			"Custom": null
 84 | 		},
 85 | 		{
 86 | 			"AntennaID": 3,
 87 | 			"RFReceiver": 1,
 88 | 			"RFTransmitter": {
 89 | 				"HopTableID": 1,
 90 | 				"ChannelIndex": 0,
 91 | 				"TransmitPowerIndex": 81
 92 | 			},
 93 | 			"C1G2InventoryCommand": {
 94 | 				"TagInventoryStateAware": false,
 95 | 				"Filters": null,
 96 | 				"RFControl": {
 97 | 					"RFModeID": 1000,
 98 | 					"Tari": 0
 99 | 				},
100 | 				"SingulationControl": {
101 | 					"Session": 1,
102 | 					"TagPopulation": 32,
103 | 					"TagTransitTime": 0,
104 | 					"InvAwareAction": null
105 | 				},
106 | 				"Custom": null
107 | 			},
108 | 			"Custom": null
109 | 		},
110 | 		{
111 | 			"AntennaID": 4,
112 | 			"RFReceiver": 1,
113 | 			"RFTransmitter": {
114 | 				"HopTableID": 1,
115 | 				"ChannelIndex": 0,
116 | 				"TransmitPowerIndex": 81
117 | 			},
118 | 			"C1G2InventoryCommand": {
119 | 				"TagInventoryStateAware": false,
120 | 				"Filters": null,
121 | 				"RFControl": {
122 | 					"RFModeID": 1000,
123 | 					"Tari": 0
124 | 				},
125 | 				"SingulationControl": {
126 | 					"Session": 1,
127 | 					"TagPopulation": 32,
128 | 					"TagTransitTime": 0,
129 | 					"InvAwareAction": null
130 | 				},
131 | 				"Custom": null
132 | 			},
133 | 			"Custom": null
134 | 		}
135 | 	],
136 | 	"ReaderEventNotificationSpec": {
137 | 		"EventNotificationStates": [
138 | 			{
139 | 				"ReaderEventType": 0,
140 | 				"NotificationEnabled": false
141 | 			},
142 | 			{
143 | 				"ReaderEventType": 1,
144 | 				"NotificationEnabled": false
145 | 			},
146 | 			{
147 | 				"ReaderEventType": 2,
148 | 				"NotificationEnabled": false
149 | 			},
150 | 			{
151 | 				"ReaderEventType": 3,
152 | 				"NotificationEnabled": false
153 | 			},
154 | 			{
155 | 				"ReaderEventType": 4,
156 | 				"NotificationEnabled": true
157 | 			},
158 | 			{
159 | 				"ReaderEventType": 5,
160 | 				"NotificationEnabled": false
161 | 			},
162 | 			{
163 | 				"ReaderEventType": 6,
164 | 				"NotificationEnabled": false
165 | 			},
166 | 			{
167 | 				"ReaderEventType": 7,
168 | 				"NotificationEnabled": false
169 | 			},
170 | 			{
171 | 				"ReaderEventType": 8,
172 | 				"NotificationEnabled": true
173 | 			}
174 | 		]
175 | 	},
176 | 	"ROReportSpec": {
177 | 		"Trigger": 2,
178 | 		"N": 1,
179 | 		"TagReportContentSelector": {
180 | 			"EnableROSpecID": false,
181 | 			"EnableSpecIndex": false,
182 | 			"EnableInventoryParamSpecID": false,
183 | 			"EnableAntennaID": true,
184 | 			"EnableChannelIndex": false,
185 | 			"EnablePeakRSSI": true,
186 | 			"EnableFirstSeenTimestamp": true,
187 | 			"EnableLastSeenTimestamp": false,
188 | 			"EnableTagSeenCount": false,
189 | 			"EnableAccessSpecID": false,
190 | 			"C1G2EPCMemorySelector": {
191 | 				"CRCEnabled": false,
192 | 				"PCBitsEnabled": false,
193 | 				"XPCBitsEnabled": false
194 | 			},
195 | 			"Custom": null
196 | 		},
197 | 		"Custom": null
198 | 	},
199 | 	"AccessReportSpec": 1,
200 | 	"LLRPConfigurationStateValue": 2057940966,
201 | 	"KeepAliveSpec": {
202 | 		"Trigger": 0,
203 | 		"Interval": 0
204 | 	},
205 | 	"GPIPortCurrentStates": [
206 | 		{
207 | 			"Port": 1,
208 | 			"Enabled": false,
209 | 			"State": 0
210 | 		},
211 | 		{
212 | 			"Port": 2,
213 | 			"Enabled": false,
214 | 			"State": 0
215 | 		},
216 | 		{
217 | 			"Port": 3,
218 | 			"Enabled": false,
219 | 			"State": 0
220 | 		},
221 | 		{
222 | 			"Port": 4,
223 | 			"Enabled": false,
224 | 			"State": 0
225 | 		}
226 | 	],
227 | 	"GPOWriteData": [
228 | 		{
229 | 			"Port": 1,
230 | 			"Data": false
231 | 		},
232 | 		{
233 | 			"Port": 2,
234 | 			"Data": false
235 | 		},
236 | 		{
237 | 			"Port": 3,
238 | 			"Data": false
239 | 		},
240 | 		{
241 | 			"Port": 4,
242 | 			"Data": false
243 | 		}
244 | 	],
245 | 	"EventsAndReports": false,
246 | 	"Custom": null
247 | }
248 | 


--------------------------------------------------------------------------------
/pkg/llrp/testdata/ReaderEventNotification-000.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/ReaderEventNotification-000.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/ReaderEventNotification-000.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ReaderEventNotificationData": {
 3 | 		"UTCTimestamp": 1596721689842138,
 4 | 		"Uptime": 0,
 5 | 		"HoppingEvent": null,
 6 | 		"GPIEvent": null,
 7 | 		"ROSpecEvent": null,
 8 | 		"ReportBufferLevelWarningEvent": null,
 9 | 		"ReportBufferOverflowErrorEvent": null,
10 | 		"ReaderExceptionEvent": null,
11 | 		"RFSurveyEvent": null,
12 | 		"AISpecEvent": null,
13 | 		"AntennaEvent": null,
14 | 		"ConnectionAttemptEvent": null,
15 | 		"ConnectionCloseEvent": {},
16 | 		"SpecLoopEvent": null,
17 | 		"Custom": null
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-001.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-001.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-001.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MACrze8AAAAAAAAD"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -48,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805140192,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-002.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-002.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-002.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MACrze8AAAAAAAAF"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -47,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805145268,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-003.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-003.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-003.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MBQwpVwKwwAAAAAJ"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -54,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805147920,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-004.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-004.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-004.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MBQwpVwKxAAAAAAA"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -68,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805151008,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-005.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-005.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-005.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MACrze8AAAAAAAAC"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -52,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805153264,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-006.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-006.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-006.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MACrze8AAAAAAAAB"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -45,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805156897,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-007.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-007.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-007.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MBQwpVwKwwAAAAAF"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -53,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805159594,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-008.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-008.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-008.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MBQwpVwKwwAAAAAG"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -56,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805163334,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-009.bytes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/edgexfoundry/device-rfid-llrp-go/88895a8148252c944c275b3aff72a7787449f366/pkg/llrp/testdata/roAccessReports/ROAccessReport-009.bytes


--------------------------------------------------------------------------------
/pkg/llrp/testdata/roAccessReports/ROAccessReport-009.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"TagReportData": [
 3 | 		{
 4 | 			"EPCData": {
 5 | 				"EPCNumBits": 0,
 6 | 				"EPC": null
 7 | 			},
 8 | 			"EPC96": {
 9 | 				"EPC": "MACrze8AAAAAAAAE"
10 | 			},
11 | 			"ROSpecID": null,
12 | 			"SpecIndex": null,
13 | 			"InventoryParameterSpecID": null,
14 | 			"AntennaID": 1,
15 | 			"PeakRSSI": -50,
16 | 			"ChannelIndex": null,
17 | 			"FirstSeenUTC": 1594174805166053,
18 | 			"FirstSeenUptime": null,
19 | 			"LastSeenUTC": null,
20 | 			"LastSeenUptime": null,
21 | 			"TagSeenCount": null,
22 | 			"C1G2PC": null,
23 | 			"C1G2XPCW1": null,
24 | 			"C1G2XPCW2": null,
25 | 			"C1G2CRC": null,
26 | 			"AccessSpecID": null,
27 | 			"C1G2ReadOpSpecResult": null,
28 | 			"C1G2WriteOpSpecResult": null,
29 | 			"C1G2KillOpSpecResult": null,
30 | 			"C1G2LockOpSpecResult": null,
31 | 			"C1G2BlockEraseOpSpecResult": null,
32 | 			"C1G2BlockWriteOpSpecResult": null,
33 | 			"C1G2RecommissionOpSpecResult": null,
34 | 			"C1G2BlockPermalockOpSpecResult": null,
35 | 			"C1G2GetBlockPermalockStatusOpSpecResult": null,
36 | 			"ClientRequestOpSpecResult": null,
37 | 			"Custom": null
38 | 		}
39 | 	],
40 | 	"RFSurveyReportData": null,
41 | 	"Custom": null
42 | }


--------------------------------------------------------------------------------
/pkg/llrp/versionnum_string.go:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (C) 2020 Intel Corporation
  3 | //
  4 | // SPDX-License-Identifier: Apache-2.0
  5 | 
  6 | // Code generated by "stringer -type=VersionNum,MessageType"; DO NOT EDIT.
  7 | 
  8 | package llrp
  9 | 
 10 | import "strconv"
 11 | 
 12 | func _() {
 13 | 	// An "invalid array index" compiler error signifies that the constant values have changed.
 14 | 	// Re-run the stringer command to generate them again.
 15 | 	var x [1]struct{}
 16 | 	_ = x[versionUnknown-0]
 17 | 	_ = x[Version1_0_1-1]
 18 | 	_ = x[Version1_1-2]
 19 | }
 20 | 
 21 | const _VersionNum_name = "versionUnknownVersion1_0_1Version1_1"
 22 | 
 23 | var _VersionNum_index = [...]uint8{0, 14, 26, 36}
 24 | 
 25 | func (i VersionNum) String() string {
 26 | 	if i >= VersionNum(len(_VersionNum_index)-1) {
 27 | 		return "VersionNum(" + strconv.FormatInt(int64(i), 10) + ")"
 28 | 	}
 29 | 	return _VersionNum_name[_VersionNum_index[i]:_VersionNum_index[i+1]]
 30 | }
 31 | func _() {
 32 | 	// An "invalid array index" compiler error signifies that the constant values have changed.
 33 | 	// Re-run the stringer command to generate them again.
 34 | 	var x [1]struct{}
 35 | 	_ = x[MsgGetSupportedVersion-46]
 36 | 	_ = x[MsgGetSupportedVersionResponse-56]
 37 | 	_ = x[MsgSetProtocolVersion-47]
 38 | 	_ = x[MsgSetProtocolVersionResponse-57]
 39 | 	_ = x[MsgGetReaderCapabilities-1]
 40 | 	_ = x[MsgGetReaderCapabilitiesResponse-11]
 41 | 	_ = x[MsgAddROSpec-20]
 42 | 	_ = x[MsgAddROSpecResponse-30]
 43 | 	_ = x[MsgDeleteROSpec-21]
 44 | 	_ = x[MsgDeleteROSpecResponse-31]
 45 | 	_ = x[MsgStartROSpec-22]
 46 | 	_ = x[MsgStartROSpecResponse-32]
 47 | 	_ = x[MsgStopROSpec-23]
 48 | 	_ = x[MsgStopROSpecResponse-33]
 49 | 	_ = x[MsgEnableROSpec-24]
 50 | 	_ = x[MsgEnableROSpecResponse-34]
 51 | 	_ = x[MsgDisableROSpec-25]
 52 | 	_ = x[MsgDisableROSpecResponse-35]
 53 | 	_ = x[MsgGetROSpecs-26]
 54 | 	_ = x[MsgGetROSpecsResponse-36]
 55 | 	_ = x[MsgAddAccessSpec-40]
 56 | 	_ = x[MsgAddAccessSpecResponse-50]
 57 | 	_ = x[MsgDeleteAccessSpec-41]
 58 | 	_ = x[MsgDeleteAccessSpecResponse-51]
 59 | 	_ = x[MsgEnableAccessSpec-42]
 60 | 	_ = x[MsgEnableAccessSpecResponse-52]
 61 | 	_ = x[MsgDisableAccessSpec-43]
 62 | 	_ = x[MsgDisableAccessSpecResponse-53]
 63 | 	_ = x[MsgGetAccessSpecs-44]
 64 | 	_ = x[MsgGetAccessSpecsResponse-54]
 65 | 	_ = x[MsgClientRequestOp-45]
 66 | 	_ = x[MsgClientRequestOpResponse-55]
 67 | 	_ = x[MsgGetReport-60]
 68 | 	_ = x[MsgROAccessReport-61]
 69 | 	_ = x[MsgKeepAlive-62]
 70 | 	_ = x[MsgKeepAliveAck-72]
 71 | 	_ = x[MsgReaderEventNotification-63]
 72 | 	_ = x[MsgEnableEventsAndReports-64]
 73 | 	_ = x[MsgErrorMessage-100]
 74 | 	_ = x[MsgGetReaderConfig-2]
 75 | 	_ = x[MsgGetReaderConfigResponse-12]
 76 | 	_ = x[MsgSetReaderConfig-3]
 77 | 	_ = x[MsgSetReaderConfigResponse-13]
 78 | 	_ = x[MsgCloseConnection-14]
 79 | 	_ = x[MsgCloseConnectionResponse-4]
 80 | 	_ = x[MsgCustomMessage-1023]
 81 | 	_ = x[msgResvStart-900]
 82 | 	_ = x[msgResvEnd-999]
 83 | 	_ = x[msgTypeInvalid-0]
 84 | }
 85 | 
 86 | const _MessageType_name = "msgTypeInvalidMsgGetReaderCapabilitiesMsgGetReaderConfigMsgSetReaderConfigMsgCloseConnectionResponseMsgGetReaderCapabilitiesResponseMsgGetReaderConfigResponseMsgSetReaderConfigResponseMsgCloseConnectionMsgAddROSpecMsgDeleteROSpecMsgStartROSpecMsgStopROSpecMsgEnableROSpecMsgDisableROSpecMsgGetROSpecsMsgAddROSpecResponseMsgDeleteROSpecResponseMsgStartROSpecResponseMsgStopROSpecResponseMsgEnableROSpecResponseMsgDisableROSpecResponseMsgGetROSpecsResponseMsgAddAccessSpecMsgDeleteAccessSpecMsgEnableAccessSpecMsgDisableAccessSpecMsgGetAccessSpecsMsgClientRequestOpMsgGetSupportedVersionMsgSetProtocolVersionMsgAddAccessSpecResponseMsgDeleteAccessSpecResponseMsgEnableAccessSpecResponseMsgDisableAccessSpecResponseMsgGetAccessSpecsResponseMsgClientRequestOpResponseMsgGetSupportedVersionResponseMsgSetProtocolVersionResponseMsgGetReportMsgROAccessReportMsgKeepAliveMsgReaderEventNotificationMsgEnableEventsAndReportsMsgKeepAliveAckMsgErrorMessagemsgResvStartmsgResvEndMsgCustomMessage"
 87 | 
 88 | var _MessageType_map = map[MessageType]string{
 89 | 	0:    _MessageType_name[0:14],
 90 | 	1:    _MessageType_name[14:38],
 91 | 	2:    _MessageType_name[38:56],
 92 | 	3:    _MessageType_name[56:74],
 93 | 	4:    _MessageType_name[74:100],
 94 | 	11:   _MessageType_name[100:132],
 95 | 	12:   _MessageType_name[132:158],
 96 | 	13:   _MessageType_name[158:184],
 97 | 	14:   _MessageType_name[184:202],
 98 | 	20:   _MessageType_name[202:214],
 99 | 	21:   _MessageType_name[214:229],
100 | 	22:   _MessageType_name[229:243],
101 | 	23:   _MessageType_name[243:256],
102 | 	24:   _MessageType_name[256:271],
103 | 	25:   _MessageType_name[271:287],
104 | 	26:   _MessageType_name[287:300],
105 | 	30:   _MessageType_name[300:320],
106 | 	31:   _MessageType_name[320:343],
107 | 	32:   _MessageType_name[343:365],
108 | 	33:   _MessageType_name[365:386],
109 | 	34:   _MessageType_name[386:409],
110 | 	35:   _MessageType_name[409:433],
111 | 	36:   _MessageType_name[433:454],
112 | 	40:   _MessageType_name[454:470],
113 | 	41:   _MessageType_name[470:489],
114 | 	42:   _MessageType_name[489:508],
115 | 	43:   _MessageType_name[508:528],
116 | 	44:   _MessageType_name[528:545],
117 | 	45:   _MessageType_name[545:563],
118 | 	46:   _MessageType_name[563:585],
119 | 	47:   _MessageType_name[585:606],
120 | 	50:   _MessageType_name[606:630],
121 | 	51:   _MessageType_name[630:657],
122 | 	52:   _MessageType_name[657:684],
123 | 	53:   _MessageType_name[684:712],
124 | 	54:   _MessageType_name[712:737],
125 | 	55:   _MessageType_name[737:763],
126 | 	56:   _MessageType_name[763:793],
127 | 	57:   _MessageType_name[793:822],
128 | 	60:   _MessageType_name[822:834],
129 | 	61:   _MessageType_name[834:851],
130 | 	62:   _MessageType_name[851:863],
131 | 	63:   _MessageType_name[863:889],
132 | 	64:   _MessageType_name[889:914],
133 | 	72:   _MessageType_name[914:929],
134 | 	100:  _MessageType_name[929:944],
135 | 	900:  _MessageType_name[944:956],
136 | 	999:  _MessageType_name[956:966],
137 | 	1023: _MessageType_name[966:982],
138 | }
139 | 
140 | func (i MessageType) String() string {
141 | 	if str, ok := _MessageType_map[i]; ok {
142 | 		return str
143 | 	}
144 | 	return "MessageType(" + strconv.FormatInt(int64(i), 10) + ")"
145 | }
146 | 


--------------------------------------------------------------------------------
/version.go:
--------------------------------------------------------------------------------
 1 | //
 2 | // Copyright (C) 2020 Intel Corporation
 3 | //
 4 | // SPDX-License-Identifier: Apache-2.0
 5 | 
 6 | package device_llrp
 7 | 
 8 | // Global version for device-sdk-go
 9 | var Version string = "to be replaced by makefile"
10 | 


--------------------------------------------------------------------------------