Add read/write for felica

felica types refactor

pn532/src/driver.rs

@@ -3,8 +3,8 @@
 use crate::commands::*;
 use crate::error::Error;
 use crate::interface::Interface;
-
-pub(crate) const PACKET_BUFFER_SIZE: usize = 64;
+use crate::StatusCode;
+use core::time::Duration;
 
 /// A card UID read by [`Pn532::read_passive_target_id`].
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -46,35 +46,20 @@ pub enum TargetInitStatus {
     Failed,
 }
 
-/// Result of a successful FeliCa polling request.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct FelicaPollingResponse {
-    /// The card's IDm (NFCID2).
-    pub idm: [u8; 8],
-    /// The card's PMm (PAD).
-    pub pmm: [u8; 8],
-    /// The card's system code, when returned.
-    pub system_code_response: Option<u16>,
-}
-
 /// Driver for the NXP PN532 NFC controller.
-pub struct Pn532<B: Interface> {
+pub struct Pn532<B: Interface, const N: usize = 64> {
     pub(crate) interface: B,
     pub(crate) in_listed_tag: u8,
-    pub(crate) felica_idm: [u8; 8],
-    pub(crate) felica_pmm: [u8; 8],
-    pub(crate) buffer: [u8; PACKET_BUFFER_SIZE],
+    pub(crate) buffer: [u8; N],
 }
 
-impl<B: Interface> Pn532<B> {
+impl<B: Interface, const N: usize> Pn532<B, N> {
     /// Create a driver over the given transport interface.
     pub fn new(interface: B) -> Self {
         Self {
             interface,
             in_listed_tag: 0,
-            felica_idm: [0; 8],
-            felica_pmm: [0; 8],
-            buffer: [0; PACKET_BUFFER_SIZE],
+            buffer: [0; N],
         }
     }
 
@@ -103,8 +88,8 @@ impl<B: Interface> Pn532<B> {
         self.interface.read_response(&mut self.buffer, 1000)
     }
 
-    pub(crate) fn read_timeout(&mut self, timeout_ms: u16) -> Result<usize, Error<B::TransportError>> {
-        self.interface.read_response(&mut self.buffer, timeout_ms)
+    pub(crate) fn read_timeout(&mut self, timeout: Duration) -> Result<usize, Error<B::TransportError>> {
+        self.interface.read_response(&mut self.buffer, timeout.as_millis() as u16)
     }
 
     // -- generic PN532 functions -------------------------------------------
@@ -210,4 +195,26 @@ impl<B: Interface> Pn532<B> {
         self.read()?;
         Ok(())
     }
+    
+    /// return error if current buffer contains an error code
+    pub(crate) fn validate_buffer(&self, len: usize) -> Result<(), Error<B::TransportError>> {
+        if len == 0 || (self.buffer[0] & 0x3F) != 0 {
+            Err(Error::Status(StatusCode::from_repr(self.buffer[0] & 0x3F).unwrap()))
+        } else {
+            Ok(())
+        }
+    }
+
+
+
+    /// Release the card.
+    pub fn release(&mut self) -> Result<(), Error<B::TransportError>> {
+        self.buffer[0] = PN532_COMMAND_INRELEASE;
+        self.buffer[1] = 0x00;
+        self.send(2)?;
+
+        let len = self.read_timeout(Duration::from_secs(1))?;
+        self.validate_buffer(len)?;
+        Ok(())
+    }
 }