Update to embedded-storage 0.2.0

Author: jonas-schievink

examples/nvmc-demo/Cargo.toml

@@ -10,7 +10,7 @@ publish = false
 [dependencies]
 cortex-m = "0.7.3"
 cortex-m-rt = "0.7.0"
-embedded-storage = "0.1.0"
+embedded-storage = "0.2.0"
 rtt-target = {version = "0.2.0", features = ["cortex-m"] }
 
 [dependencies.embedded-hal]

examples/nvmc-demo/src/main.rs

@@ -28,11 +28,11 @@ fn main() -> ! {
     #[cfg(feature = "52840")]
     let mut nvmc = Nvmc::new(p.NVMC, unsafe { &mut CONFIG });
 
-    assert!(nvmc.try_erase(0, CONFIG_SIZE as u32 * 4).is_ok());
+    assert!(nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
     let write_buf: [u8; 4] = [1, 2, 3, 4];
-    assert!(nvmc.try_write(0, &write_buf).is_ok());
+    assert!(nvmc.write(0, &write_buf).is_ok());
     let mut read_buf = [0u8; 2];
-    assert!(nvmc.try_read(0, &mut read_buf).is_ok());
+    assert!(nvmc.read(0, &mut read_buf).is_ok());
     assert_eq!(read_buf, write_buf[0..2]);
 
     rprintln!("What was written to flash was read!");

nrf-hal-common/Cargo.toml

@@ -26,7 +26,7 @@ fixed = "1.0.0"
 rand_core = "0.6.3"
 cfg-if = "1.0.0"
 embedded-dma = "0.1.1"
-embedded-storage = "0.1.0"
+embedded-storage = "0.2.0"
 
 [dependencies.void]
 default-features = false

nrf-hal-common/src/nvmc.rs

@@ -99,7 +99,7 @@ where
 
     const READ_SIZE: usize = 4;
 
-    fn try_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
+    fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
         let offset = offset as usize;
         let bytes_len = bytes.len();
         let read_len = bytes_len + (Self::READ_SIZE - (bytes_len % Self::READ_SIZE));
@@ -151,7 +151,7 @@ where
 
     const ERASE_SIZE: usize = 4 * 1024;
 
-    fn try_erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
+    fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
         if from as usize % Self::ERASE_SIZE == 0 && to as usize % Self::ERASE_SIZE == 0 {
             self.enable_erase();
             for offset in (from..to).step_by(Self::ERASE_SIZE) {
@@ -164,7 +164,7 @@ where
         }
     }
 
-    fn try_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
+    fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
         let offset = offset as usize;
         if offset % Self::WRITE_SIZE == 0 && bytes.len() % Self::WRITE_SIZE == 0 {
             self.enable_write();

nrf52840-hal-tests/Cargo.toml

@@ -34,7 +34,7 @@ cortex-m-rt = { version = "0.6.14", features = ["device"] }
 defmt = "0.2.0"
 defmt-rtt = "0.2.0"
 defmt-test = "0.2.0"
-embedded-storage = "0.1.0"
+embedded-storage = "0.2.0"
 nrf52840-hal = { path = "../nrf52840-hal" }
 panic-probe = { version = "0.2.0", features = ["print-defmt"] }
 

nrf52840-hal-tests/tests/nvmc.rs

@@ -41,60 +41,60 @@ mod tests {
     #[test]
     fn read_unaligned(state: &mut State) {
         let mut buf = [0u8; 1];
-        assert!(state.nvmc.try_read(1, &mut buf).is_err());
+        assert!(state.nvmc.read(1, &mut buf).is_err());
     }
 
     #[test]
     fn read_beyond_buffer(state: &mut State) {
         let mut buf = [0u8; CONFIG_SIZE * 4 + 1];
-        assert!(state.nvmc.try_read(0, &mut buf).is_err());
+        assert!(state.nvmc.read(0, &mut buf).is_err());
     }
 
     #[test]
     fn erase_unaligned_from(state: &mut State) {
-        assert!(state.nvmc.try_erase(1, 4096).is_err());
+        assert!(state.nvmc.erase(1, 4096).is_err());
     }
 
     #[test]
     fn erase_unaligned_to(state: &mut State) {
-        assert!(state.nvmc.try_erase(0, 4097).is_err());
+        assert!(state.nvmc.erase(0, 4097).is_err());
     }
 
     #[test]
     fn write_unaligned(state: &mut State) {
         let buf = [0u8; 1];
-        assert!(state.nvmc.try_write(1, &buf).is_err());
+        assert!(state.nvmc.write(1, &buf).is_err());
     }
 
     #[test]
     fn read_write_and_then_read(state: &mut State) {
-        assert!(state.nvmc.try_erase(0, CONFIG_SIZE as u32 * 4).is_ok());
+        assert!(state.nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
         let mut read_buf = [0u8; 1];
-        assert!(state.nvmc.try_read(0, &mut read_buf).is_ok());
+        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
         assert_eq!(read_buf[0], 0xff);
         let write_buf = [1u8; 4];
-        assert!(state.nvmc.try_write(0, &write_buf).is_ok());
-        assert!(state.nvmc.try_read(0, &mut read_buf).is_ok());
+        assert!(state.nvmc.write(0, &write_buf).is_ok());
+        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
         assert_eq!(read_buf[0], 0x1);
     }
 
     #[test]
     fn read_what_is_written(state: &mut State) {
-        assert!(state.nvmc.try_erase(0, CONFIG_SIZE as u32 * 4).is_ok());
+        assert!(state.nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
         let write_buf: [u8; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
-        assert!(state.nvmc.try_write(0, &write_buf).is_ok());
+        assert!(state.nvmc.write(0, &write_buf).is_ok());
         let mut read_buf = [0u8; 8];
-        assert!(state.nvmc.try_read(0, &mut read_buf).is_ok());
+        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
         assert_eq!(read_buf, write_buf);
     }
 
     #[test]
     fn partially_read_what_is_written(state: &mut State) {
-        assert!(state.nvmc.try_erase(0, CONFIG_SIZE as u32 * 4).is_ok());
+        assert!(state.nvmc.erase(0, CONFIG_SIZE as u32 * 4).is_ok());
         let write_buf: [u8; 4] = [1, 2, 3, 4];
-        assert!(state.nvmc.try_write(0, &write_buf).is_ok());
+        assert!(state.nvmc.write(0, &write_buf).is_ok());
         let mut read_buf = [0u8; 2];
-        assert!(state.nvmc.try_read(0, &mut read_buf).is_ok());
+        assert!(state.nvmc.read(0, &mut read_buf).is_ok());
         assert_eq!(read_buf, write_buf[0..2]);
     }
 }