diff --git a/src/lib.rs b/src/lib.rs
index 0eb832b..cc316e3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,17 +10,81 @@ const DEVICE_R: u8 = 0b00000001;
 
 struct MB85RC<T: I2c<SevenBitAddress>> {
     i2c: T,
+    address: SevenBitAddress,
 }
 
-enum i2c_frequency {
-    standard_mode = 100_000,
-    fast_mode = 400_000,
-    fast_mode_plus = 1_000_000,
+#[derive(Debug)]
+pub enum MyI2cError<> {
+    DeviceNotFound,
+    InvalidData,
+}
+
+enum I2CFrequency {
+    StandardMode = 100_000,
+    FastMode = 400_000,
+    FastModePlus = 1_000_000,
 }
 
 impl<T: I2c> MB85RC<T> {
-    pub fn new(i2c: T) -> Self {
-        MB85RC { i2c }
+    pub fn new(i2c: T, address: SevenBitAddress) -> Self {
+        MB85RC { i2c, address }
+    }
+
+    /// The Device ID command reads fixed Device ID. The size of Device ID is 3 bytes and consists of manufacturer
+    /// ID and product ID.
+    ///  # Arguments
+    /// * `self` - A mutable reference to the MB85RC instance.
+    /// # Returns
+    /// * `Result<[u8; 3], Infallible>` -
+    fn get_device_id(&mut self) -> Result<[u8; 3], Infallible> {
+        let id: [u8; 3] = [1, 2, 3];
+
+        Ok(id)
+    }
+
+    /// Write bit on the specified memory address
+    /// # Arguments
+    /// * `self` - A mutable reference to the MB85RC instance.
+    /// * `memory_address` - The memory address to write to.
+    /// * `data` - The data byte to write.
+    fn byte_write(&mut self, memory_address: [u8; 2], data: u8) -> Result<u8, T::Error> {
+        let payload = [memory_address[0], memory_address[1], data];
+        self.i2c.write(self.address, &payload)?;
+        Ok(data)
+    }
+
+    /// If additional 8 bits are continuously sent after the same command (except stop condition) as Byte Write, a
+    /// page write is performed. The memory address rolls over to first memory address (0000H) at the end of the
+    /// address. Therefore, if more than 32 Kbytes are sent, the data is overwritten in order starting from the start
+    /// of the memory address that was written first. Because FRAM performs the high-speed write operations, the
+    /// data will be written to FRAM right after the ACK response finished.
+    /// array 32KB
+    fn write_page(memory_address: [u8; 2], buf: &mut [u8]) -> Result<(), Infallible> {
+        // Implement the logic to write a page of data
+        Ok(())
+    }
+
+    /// The one byte of data from the memory address saved in the memory address buffer can be read out
+    /// synchronously
+    /// # Arguments
+    /// * `memory_address` - The memory address to read from.
+    /// # Returns
+    /// * `Result<u8, Infallible>` - The byte read from the specified
+    fn random_read(&mut self, memory_address: &mut [u8; 2]) -> Result<u8, MyI2cError> {
+        let mut buffer: [u8; 1] = [0];
+        self.i2c.write_read(self.address, memory_address, &mut buffer).map_err(|_| MyI2cError::InvalidData)?;
+        Ok(buffer[0])
+    }
+    /// Performs a sequential read operation starting from the specified memory address,
+    /// reading data continuously into the provided buffer. After specifying the address,
+    /// data can be received continuously following the device address word with a read
+    /// command. If the end of the memory address space is reached, the internal read
+    /// address automatically rolls over to the first memory address (0x0000) and continues
+    /// reading.
+    fn sequential_read(memory_address: [u8; 2], buf: &mut [u8]) -> Result<usize, Infallible> {
+        let read_bytes: usize = 0;
+
+        Ok(read_bytes)
     }
 }
 
@@ -33,17 +97,3 @@ impl<T: I2c> Read for MB85RC<T> {
         todo!()
     }
 }
-fn get_device_id() -> [u8; 3] { 
- let mut id: [u8; 3] =  [1, 2, 3];
-
- id
-}
-
-
-fn byte_write(write_address: u8, data: u8) -> u8 {
-
-    let mut read_byte: u8 = 0x00;
-
-    read_byte
-
-}