uhf-rfid 0.1.2

Driver for M5Stack UHF RFID reader with support for multiple transport backends
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

[![Build](https://github.com/awalland/uhf-rfid/actions/workflows/rust.yml/badge.svg)](https://github.com/awalland/uhf-rfid/actions/workflows/rust.yml)
[![codecov](https://codecov.io/github/awalland/uhf-rfid/graph/badge.svg?token=FSE4ZYPOIE)](https://codecov.io/github/awalland/uhf-rfid)

# uhf-rfid

A Rust driver for M5Stack UHF RFID readers with support for multiple transport backends.

## Features

- **ESP32 UART support** - Native UART transport for ESP32 using `esp-idf-hal`
- **Desktop serial support** - Serial port transport using the `serialport` crate
- **Full EPC Gen2 support** - Tag polling, reading, writing, locking, and killing
- **Advanced configuration** - Region settings, RF link profiles, frequency hopping, and more
- **Vendor extensions** - NXP UCODE and Impinj Monza specific commands

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
uhf-rfid = "0.1"
```

Enable the appropriate feature for your platform:

```toml
# For desktop/Linux serial port
uhf-rfid = { version = "0.1", features = ["serial"] }

# For ESP32
uhf-rfid = { version = "0.1", features = ["uart-esp32"] }
```

## Usage

### Desktop (Serial Port)

```rust
use uhf_rfid::{UhfRfid, SerialTransport};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let transport = SerialTransport::new("/dev/ttyUSB0", 115200)?;
    let mut rfid = UhfRfid::new(transport);

    // Get firmware version
    let version = rfid.get_firmware_version()?;
    println!("Firmware: {}", version);

    // Poll for a single tag
    if let Some(tag) = rfid.single_poll()? {
        println!("Found tag: {} (RSSI: {})", tag.epc, tag.rssi);
    }

    // Poll for multiple tags
    let tags = rfid.multiple_poll(100)?;
    for tag in tags {
        println!("Tag: {}", tag.epc);
    }

    // Poll with callback for real-time processing
    let count = rfid.multiple_poll_with_callback(100, |tag| {
        println!("Discovered tag: {} (RSSI: {})", tag.epc, tag.rssi);
    })?;
    println!("Total tags found: {}", count);

    Ok(())
}
```

### ESP32 (UART)

```rust
use esp_idf_svc::hal::peripherals::Peripherals;
use uhf_rfid::{UhfRfid, UartTransport};

fn main() -> anyhow::Result<()> {
    esp_idf_svc::sys::link_patches();

    let peripherals = Peripherals::take()?;

    let transport = UartTransport::new(
        peripherals.uart1,
        peripherals.pins.gpio17, // TX
        peripherals.pins.gpio16, // RX
        115200,
    )?;

    let mut rfid = UhfRfid::new(transport);

    // Get firmware version
    let version = rfid.get_firmware_version()?;
    println!("Firmware: {}", version);

    // Poll for tags
    if let Some(tag) = rfid.single_poll()? {
        println!("Found tag: {} (RSSI: {})", tag.epc, tag.rssi);
    }

    Ok(())
}
```

## Supported Operations

- **Polling**: Single and multiple tag inventory
- **Memory access**: Read/write tag memory banks (EPC, TID, User, Reserved)
- **Security**: Lock and kill tags
- **Configuration**: TX power, region, channel, frequency hopping, baud rate
- **Advanced**: Select filtering, query parameters, RF link profiles
- **Vendor-specific**: NXP EAS, read protect; Impinj Monza QT

## License

Licensed under either of:

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.