From 7b483a6b758d63bac2e27c1a5799f3ca20723717 Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 08:52:06 -0800 Subject: [PATCH 1/9] Fixed length to show sizze rather than highest index --- adafruit_fram.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) mode change 100644 => 100755 adafruit_fram.py diff --git a/adafruit_fram.py b/adafruit_fram.py old mode 100644 new mode 100755 index fc39347..5df6289 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -106,7 +106,7 @@ def write_protected(self): return self._wp if self._wp_pin is None else self._wp_pin.value def __len__(self): - """ The maximum size of the current FRAM chip. This is the highest + """ The size of the current FRAM chip. This is one more than the highest register location that can be read or written to. .. code-block:: python @@ -119,7 +119,7 @@ def __len__(self): # can be used with range for i in range(0, len(fram)) """ - return self._max_size + return self._max_size + 1 def __getitem__(self, key): @@ -360,4 +360,4 @@ def write_protected(self, value): with self._spi as spi: spi.write(write_buffer) if self._wp_pin is not None: - self._wp_pin.value = value + self._wp_pin.value = value \ No newline at end of file From 6eaae80df17e13b22b62b514752819057cdccb86 Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 09:35:11 -0800 Subject: [PATCH 2/9] Changed max_size to actual max size. Updated all messages and examples. --- adafruit_fram.py | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index 5df6289..07556e9 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -51,8 +51,8 @@ __version__ = "0.0.0-auto.0" __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_FRAM.git" -_MAX_SIZE_I2C = const(32767) -_MAX_SIZE_SPI = const(8191) +_MAX_SIZE_I2C = const(32768) +_MAX_SIZE_SPI = const(8192) _I2C_MANF_ID = const(0x0A) _I2C_PROD_ID = const(0x510) @@ -80,7 +80,7 @@ def __init__(self, max_size, write_protect=False, wp_pin=None): @property def write_wraparound(self): """ Determines if sequential writes will wrapaound highest memory address - (``len(FRAM)``) address. If ``False``, and a requested write will + (``len(FRAM) - 1``) address. If ``False``, and a requested write will extend beyond the maximum size, an exception is raised. """ return self._wraparound @@ -113,13 +113,13 @@ def __len__(self): fram = adafruit_fram.FRAM_xxx() # xxx = 'I2C' or 'SPI' - # maximum size returned by len() + # size returned by len() len(fram) # can be used with range - for i in range(0, len(fram)) + for i in range(0, len(fram) - 1) """ - return self._max_size + 1 + return self._max_size def __getitem__(self, key): @@ -134,9 +134,9 @@ def __getitem__(self, key): fram[0:9] """ if isinstance(key, int): - if key > self._max_size: - raise ValueError("Register '{0}' greater than maximum FRAM size." - " ({1})".format(key, self._max_size)) + if key > self._max_size - 1: + raise ValueError("Register '{0}' greater than maximum FRAM register." + " ({1})".format(key, self._max_size - 1)) buffer = bytearray(1) read_buffer = self._read_register(key, buffer) elif isinstance(key, slice): @@ -146,8 +146,8 @@ def __getitem__(self, key): registers = list(range(key.start if key.start is not None else 0, key.stop if key.stop is not None else self._max_size)) if (registers[0] + len(registers)) > self._max_size: - raise ValueError("Register + Length greater than maximum FRAM size." - " ({0})".format(self._max_size)) + raise ValueError("Register + Length greater than maximum FRAM register." + " ({0})".format(self._max_size - 1)) buffer = bytearray(len(registers)) read_buffer = self._read_register(registers[0], buffer) @@ -172,10 +172,10 @@ def __setitem__(self, key, value): if not isinstance(value, (int, bytearray, list, tuple)): raise ValueError("Data must be a single integer, or a bytearray," " list, or tuple.") - if key > self._max_size: + if key > self._max_size - 1: raise ValueError("Requested register '{0}' greater than maximum" - " FRAM size. ({1})".format(key, - self._max_size)) + " FRAM register. ({1})".format(key, + self._max_size - 1)) self._write(key, value, self._wraparound) @@ -237,21 +237,21 @@ def _write(self, start_register, data, wraparound=False): else: data_length = 1 data = [data] - if (start_register + data_length) - 1 > self._max_size: + if (start_register + data_length) > self._max_size: if wraparound: pass else: raise ValueError("Starting register + data length extends beyond" - " FRAM maximum size. Use ``write_wraparound`` to" + " FRAM maximum register. Use ``write_wraparound`` to" " override this warning.") with self._i2c as i2c: for i in range(0, data_length): - if not (start_register + i) > self._max_size: + if not (start_register + i) > self._max_size - 1: buffer[0] = (start_register + i) >> 8 buffer[1] = (start_register + i) & 0xFF else: - buffer[0] = ((start_register + i) - self._max_size) >> 8 - buffer[1] = ((start_register + i) - self._max_size) & 0xFF + buffer[0] = ((start_register + i) - self._max_size + 1) >> 8 + buffer[1] = ((start_register + i) - self._max_size + 1) & 0xFF buffer[2] = data[i] i2c.write(buffer) @@ -324,12 +324,12 @@ def _write(self, start_register, data, wraparound=False): else: data_length = 1 data = [data] - if (start_register + data_length) - 1 > self._max_size: + if (start_register + data_length) > self._max_size: if wraparound: pass else: raise ValueError("Starting register + data length extends beyond" - " FRAM maximum size. Use 'wraparound=True' to" + " FRAM maximum register. Use 'wraparound=True' to" " override this warning.") with self._spi as spi: spi.write(bytearray([_SPI_OPCODE_WREN])) @@ -360,4 +360,4 @@ def write_protected(self, value): with self._spi as spi: spi.write(write_buffer) if self._wp_pin is not None: - self._wp_pin.value = value \ No newline at end of file + self._wp_pin.value = value From 238bfe343d1b3de900ff6a44f99cfbbf68faf4ec Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 09:37:06 -0800 Subject: [PATCH 3/9] Changed max_size to actual max size. Updated all messages and examples. --- adafruit_fram.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index 07556e9..44dd43d 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -134,7 +134,7 @@ def __getitem__(self, key): fram[0:9] """ if isinstance(key, int): - if key > self._max_size - 1: + if key >= self._max_size: raise ValueError("Register '{0}' greater than maximum FRAM register." " ({1})".format(key, self._max_size - 1)) buffer = bytearray(1) @@ -172,7 +172,7 @@ def __setitem__(self, key, value): if not isinstance(value, (int, bytearray, list, tuple)): raise ValueError("Data must be a single integer, or a bytearray," " list, or tuple.") - if key > self._max_size - 1: + if key >= self._max_size: raise ValueError("Requested register '{0}' greater than maximum" " FRAM register. ({1})".format(key, self._max_size - 1)) From 9b9e2f0e84f29784f248e1c26d1b316d3bc4749c Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 09:39:57 -0800 Subject: [PATCH 4/9] Fixed Travis Error --- adafruit_fram.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index 44dd43d..be59116 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -174,8 +174,7 @@ def __setitem__(self, key, value): " list, or tuple.") if key >= self._max_size: raise ValueError("Requested register '{0}' greater than maximum" - " FRAM register. ({1})".format(key, - self._max_size - 1)) + " FRAM register. ({1})".format(key, self._max_size - 1)) self._write(key, value, self._wraparound) From 2c06cbc4fb69fbb97c21066338eba2aa8e999ae2 Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 12:08:19 -0800 Subject: [PATCH 5/9] Added suggestions by @danh. Fixed off by one error on slicing. --- adafruit_fram.py | 45 +++++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index be59116..37b0c8d 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -117,12 +117,12 @@ def __len__(self): len(fram) # can be used with range - for i in range(0, len(fram) - 1) + for i in range(0, len(fram)) """ return self._max_size - def __getitem__(self, key): + def __getitem__(self, address): """ Read the value at the given index, or values in a slice. .. code-block:: python @@ -133,28 +133,29 @@ def __getitem__(self, key): # read values 0 thru 9 with a slice fram[0:9] """ - if isinstance(key, int): - if key >= self._max_size: - raise ValueError("Register '{0}' greater than maximum FRAM register." - " ({1})".format(key, self._max_size - 1)) + if isinstance(address, int): + if not (0 < address < self._max_size): + raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." + .format(address, self._max_size)) buffer = bytearray(1) - read_buffer = self._read_register(key, buffer) - elif isinstance(key, slice): - if key.step is not None: + read_buffer = self._read_register(address, buffer) + elif isinstance(address, slice): + if address.step is not None: raise ValueError("Slice stepping is not currently available.") - registers = list(range(key.start if key.start is not None else 0, - key.stop if key.stop is not None else self._max_size)) - if (registers[0] + len(registers)) > self._max_size: - raise ValueError("Register + Length greater than maximum FRAM register." - " ({0})".format(self._max_size - 1)) + registers = list(range(address.start if address.start is not None else 0, + address.stop + 1 if address.stop is not None else self._max_size)) + if registers[0] < 0 or (registers[0] + len(registers)) > self._max_size: + raise ValueError("Address slice out of range. It must be 0 <= [starting address" + ":stopping address] < {1}." + .format(address, self._max_size)) buffer = bytearray(len(registers)) read_buffer = self._read_register(registers[0], buffer) return read_buffer - def __setitem__(self, key, value): + def __setitem__(self, address, value): """ Write the value at the given starting index. .. code-block:: python @@ -168,17 +169,17 @@ def __setitem__(self, key, value): if self.write_protected: raise RuntimeError("FRAM currently write protected.") - if isinstance(key, int): + if isinstance(address, int): if not isinstance(value, (int, bytearray, list, tuple)): raise ValueError("Data must be a single integer, or a bytearray," " list, or tuple.") - if key >= self._max_size: - raise ValueError("Requested register '{0}' greater than maximum" - " FRAM register. ({1})".format(key, self._max_size - 1)) + if not (0 < address < self._max_size): + raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." + .format(address, self._max_size)) - self._write(key, value, self._wraparound) + self._write(address, value, self._wraparound) - elif isinstance(key, slice): + elif isinstance(address, slice): raise ValueError("Slicing not available during write operations.") def _read_register(self, register, read_buffer): @@ -241,7 +242,7 @@ def _write(self, start_register, data, wraparound=False): pass else: raise ValueError("Starting register + data length extends beyond" - " FRAM maximum register. Use ``write_wraparound`` to" + " FRAM maximum address. Use ``write_wraparound`` to" " override this warning.") with self._i2c as i2c: for i in range(0, data_length): From 3aa23f3736c00f5b331be2d9367966cc50309e42 Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 12:13:20 -0800 Subject: [PATCH 6/9] Fixed Travis Errors --- adafruit_fram.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index 37b0c8d..3f41ba0 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -134,7 +134,7 @@ def __getitem__(self, address): fram[0:9] """ if isinstance(address, int): - if not (0 < address < self._max_size): + if not 0 < address < self._max_size: raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." .format(address, self._max_size)) buffer = bytearray(1) @@ -143,15 +143,15 @@ def __getitem__(self, address): if address.step is not None: raise ValueError("Slice stepping is not currently available.") - registers = list(range(address.start if address.start is not None else 0, - address.stop + 1 if address.stop is not None else self._max_size)) - if registers[0] < 0 or (registers[0] + len(registers)) > self._max_size: + regs = list(range(address.start if address.start is not None else 0, + address.stop + 1 if address.stop is not None else self._max_size)) + if regs[0] < 0 or (regs[0] + len(regs)) > self._max_size: raise ValueError("Address slice out of range. It must be 0 <= [starting address" - ":stopping address] < {1}." - .format(address, self._max_size)) + ":stopping address] < {0}." + .format(self._max_size)) - buffer = bytearray(len(registers)) - read_buffer = self._read_register(registers[0], buffer) + buffer = bytearray(len(regs)) + read_buffer = self._read_register(regs[0], buffer) return read_buffer @@ -173,7 +173,7 @@ def __setitem__(self, address, value): if not isinstance(value, (int, bytearray, list, tuple)): raise ValueError("Data must be a single integer, or a bytearray," " list, or tuple.") - if not (0 < address < self._max_size): + if not 0 < address < self._max_size: raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." .format(address, self._max_size)) From cae01f6b1ede969d675c5e1cb26314060156274e Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 13:28:04 -0800 Subject: [PATCH 7/9] Changed many uses of register to address --- adafruit_fram.py | 50 ++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index 3f41ba0..d41abc8 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -107,7 +107,7 @@ def write_protected(self): def __len__(self): """ The size of the current FRAM chip. This is one more than the highest - register location that can be read or written to. + address location that can be read or written to. .. code-block:: python @@ -138,7 +138,7 @@ def __getitem__(self, address): raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." .format(address, self._max_size)) buffer = bytearray(1) - read_buffer = self._read_register(address, buffer) + read_buffer = self._read_address(address, buffer) elif isinstance(address, slice): if address.step is not None: raise ValueError("Slice stepping is not currently available.") @@ -151,7 +151,7 @@ def __getitem__(self, address): .format(self._max_size)) buffer = bytearray(len(regs)) - read_buffer = self._read_register(regs[0], buffer) + read_buffer = self._read_address(regs[0], buffer) return read_buffer @@ -182,11 +182,11 @@ def __setitem__(self, address, value): elif isinstance(address, slice): raise ValueError("Slicing not available during write operations.") - def _read_register(self, register, read_buffer): + def _read_address(self, address, read_buffer): # Implemented by subclass raise NotImplementedError - def _write(self, start_register, data, wraparound): + def _write(self, start_address, data, wraparound): # Implemened by subclass raise NotImplementedError @@ -217,15 +217,15 @@ def __init__(self, i2c_bus, address=0x50, write_protect=False, self._i2c = i2cdev(i2c_bus, address) super().__init__(_MAX_SIZE_I2C, write_protect, wp_pin) - def _read_register(self, register, read_buffer): + def _read_address(self, address, read_buffer): write_buffer = bytearray(2) - write_buffer[0] = register >> 8 - write_buffer[1] = register & 0xFF + write_buffer[0] = address >> 8 + write_buffer[1] = address & 0xFF with self._i2c as i2c: i2c.write_then_readinto(write_buffer, read_buffer) return read_buffer - def _write(self, start_register, data, wraparound=False): + def _write(self, start_address, data, wraparound=False): # Decided against using the chip's "Page Write", since that would require # doubling the memory usage by creating a buffer that includes the passed # in data so that it can be sent all in one `i2c.write`. The single-write @@ -237,21 +237,21 @@ def _write(self, start_register, data, wraparound=False): else: data_length = 1 data = [data] - if (start_register + data_length) > self._max_size: + if (start_address + data_length) > self._max_size: if wraparound: pass else: - raise ValueError("Starting register + data length extends beyond" + raise ValueError("Starting address + data length extends beyond" " FRAM maximum address. Use ``write_wraparound`` to" " override this warning.") with self._i2c as i2c: for i in range(0, data_length): - if not (start_register + i) > self._max_size - 1: - buffer[0] = (start_register + i) >> 8 - buffer[1] = (start_register + i) & 0xFF + if not (start_address + i) > self._max_size - 1: + buffer[0] = (start_address + i) >> 8 + buffer[1] = (start_address + i) & 0xFF else: - buffer[0] = ((start_register + i) - self._max_size + 1) >> 8 - buffer[1] = ((start_register + i) - self._max_size + 1) & 0xFF + buffer[0] = ((start_address + i) - self._max_size + 1) >> 8 + buffer[1] = ((start_address + i) - self._max_size + 1) & 0xFF buffer[2] = data[i] i2c.write(buffer) @@ -307,36 +307,36 @@ def __init__(self, spi_bus, spi_cs, write_protect=False, self._spi = _spi super().__init__(_MAX_SIZE_SPI, write_protect, wp_pin) - def _read_register(self, register, read_buffer): + def _read_address(self, address, read_buffer): write_buffer = bytearray(3) write_buffer[0] = _SPI_OPCODE_READ - write_buffer[1] = register >> 8 - write_buffer[2] = register & 0xFF + write_buffer[1] = address >> 8 + write_buffer[2] = address & 0xFF with self._spi as spi: spi.write(write_buffer) spi.readinto(read_buffer) return read_buffer - def _write(self, start_register, data, wraparound=False): + def _write(self, start_addressr, data, wraparound=False): buffer = bytearray(3) if not isinstance(data, int): data_length = len(data) else: data_length = 1 data = [data] - if (start_register + data_length) > self._max_size: + if (start_address + data_length) > self._max_size: if wraparound: pass else: - raise ValueError("Starting register + data length extends beyond" - " FRAM maximum register. Use 'wraparound=True' to" + raise ValueError("Starting address + data length extends beyond" + " FRAM maximum address. Use 'wraparound=True' to" " override this warning.") with self._spi as spi: spi.write(bytearray([_SPI_OPCODE_WREN])) with self._spi as spi: buffer[0] = _SPI_OPCODE_WRITE - buffer[1] = start_register >> 8 - buffer[2] = start_register & 0xFF + buffer[1] = start_address >> 8 + buffer[2] = start_address & 0xFF spi.write(buffer) for i in range(0, data_length): spi.write(bytearray([data[i]])) From f54ae85eb7a3ea00708cae6a6bb3052d17e21dcc Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 13:32:37 -0800 Subject: [PATCH 8/9] Fixed Travis Error --- adafruit_fram.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index d41abc8..7fe3cc2 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -317,7 +317,7 @@ def _read_address(self, address, read_buffer): spi.readinto(read_buffer) return read_buffer - def _write(self, start_addressr, data, wraparound=False): + def _write(self, start_address, data, wraparound=False): buffer = bytearray(3) if not isinstance(data, int): data_length = len(data) From 5365bea36f52a6eaecad08ea51a813e0464edf65 Mon Sep 17 00:00:00 2001 From: Melissa LeBlanc-Williams Date: Fri, 25 Jan 2019 15:08:43 -0800 Subject: [PATCH 9/9] Fixed Zero Address Check --- adafruit_fram.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/adafruit_fram.py b/adafruit_fram.py index 7fe3cc2..69340c7 100755 --- a/adafruit_fram.py +++ b/adafruit_fram.py @@ -134,7 +134,7 @@ def __getitem__(self, address): fram[0:9] """ if isinstance(address, int): - if not 0 < address < self._max_size: + if not 0 <= address < self._max_size: raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." .format(address, self._max_size)) buffer = bytearray(1) @@ -173,7 +173,7 @@ def __setitem__(self, address, value): if not isinstance(value, (int, bytearray, list, tuple)): raise ValueError("Data must be a single integer, or a bytearray," " list, or tuple.") - if not 0 < address < self._max_size: + if not 0 <= address < self._max_size: raise ValueError("Address '{0}' out of range. It must be 0 <= address < {1}." .format(address, self._max_size))