update libraries E-I

Author: RobTillaart

libraries/FRAM/FRAM.cpp

@@ -1,17 +1,20 @@
 //
 //    FILE: FRAM.cpp
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.1
-// PURPOSE: Class for FRAM memory
-//     URL:
+// VERSION: 0.2.1
+//    DATE: 2018-01-24
+// PURPOSE: Arduino library for I2C FRAM
+//     URL: https://github.com/RobTillaart/FRAM_I2C
 //
 // HISTORY:
-// 0.1.0 initial version
-// 0.1.1 added suppport for Fujitsu 64Kbit MB85RC64T (kudos ysoyipek)
+// 0.1.0    2018-01-24 initial version
+// 0.1.1    2019-07-31 added suppport for Fujitsu 64Kbit MB85RC64T (kudos ysoyipek)
+// 0.2.0    2020-04-30 refactor, add writeProtectPin code
+// 0.2.1    2020-06-10 fix library.json
 
 #include "FRAM.h"
 
-#define FRAM_SLAVE_ID_         0x7C
+const uint8_t FRAM_SLAVE_ID_= 0x7C;
 
 /////////////////////////////////////////////////////
 //
@@ -20,7 +23,7 @@
 FRAM::FRAM()
 {}
 
-int FRAM::begin(int address = 0X50)
+int FRAM::begin(uint8_t address, int8_t writeProtectPin)
 {
   if (address < 0x50 || address > 0x57)
   {
@@ -30,18 +33,11 @@ int FRAM::begin(int address = 0X50)
   _address = address;
   Wire.begin();
 
-  uint16_t mid = getManufacturerID();
-  uint16_t pid = getProductID();
-  _size = 0;                          // UNKNOWN
-  if (mid == 0x000A)                  // fujitsu
+  if (writeProtectPin > -1)
   {
-    // note pid's are from fujitsu       SIZE    TYPE
-    if (pid == 0x0358) _size = 8;     // 8KB     MB85RC64T
-    if (pid == 0x0510) _size = 32;    // 32KB    MB85RC256V
-    if (pid == 0x0658) _size = 64;    // 64KB    MB85RC512T
-    if (pid == 0x0758) _size = 128;   // 128KB   MB85RC1MT
+    _writeProtectPin = writeProtectPin;
+    pinMode(_writeProtectPin, OUTPUT);
   }
-
   return FRAM_OK;
 }
 
@@ -104,7 +100,7 @@ uint32_t FRAM::read32(uint16_t memaddr)
 
 void FRAM::read(uint16_t memaddr, uint8_t * obj, uint16_t size)
 {
-  const int blocksize = 24;
+  const uint8_t blocksize = 24;
   uint8_t * p = obj;
   while (size >= blocksize)
   {
@@ -113,44 +109,70 @@ void FRAM::read(uint16_t memaddr, uint8_t * obj, uint16_t size)
     p += blocksize;
     size -= blocksize;
   }
+  // remainder
   if (size > 0)
   {
     readBlock(memaddr, p, size);
   }
 }
 
+bool FRAM::setWriteProtect(bool b)
+{
+  if (_writeProtectPin == -1) return false;
+  digitalWrite(_writeProtectPin, b ? HIGH : LOW);
+  return true;
+}
+
 uint16_t FRAM::getManufacturerID()
 {
-  uint16_t value = 0;
-  Wire.beginTransmission(FRAM_SLAVE_ID_);
-  Wire.write(_address << 1);
-  Wire.endTransmission(false);
-  int x = Wire.requestFrom(FRAM_SLAVE_ID_, 2);
-  if (x != 2) return -1;
-  value = Wire.read() << 4;
-  value |= Wire.read() >> 4;
-  return value;
+  return getMetaData(0);
 }
 
 uint16_t FRAM::getProductID()
 {
-  uint16_t value = 0;
+  return getMetaData(1);
+}
+
+uint16_t FRAM::getSize()
+{
+  uint16_t val = getMetaData(2);  // density bits
+  if (val > 0) return 1 << val;
+  return 0;
+}
+
+///////////////////////////////////////////////////////////
+//
+// PRIVATE
+//
+
+// metadata is packed as  [....MMMM][MMMMDDDD][PPPPPPPP]
+// M = manufacturerID
+// D = density => memsize = 2^D KB
+// P = product ID (together with D)
+uint16_t FRAM::getMetaData(uint8_t field)
+{
+  if (field > 2) return 0;
+
   Wire.beginTransmission(FRAM_SLAVE_ID_);
   Wire.write(_address << 1);
   Wire.endTransmission(false);
-  int x = Wire.requestFrom(FRAM_SLAVE_ID_, 3);
+  int x = Wire.requestFrom(FRAM_SLAVE_ID_, (uint8_t)3);
   if (x != 3) return -1;
-  Wire.read();
-  value = (Wire.read() & 0x0F) << 8;
+
+  uint32_t value = 0;
+  value = Wire.read();
+  value |= Wire.read();
   value |= Wire.read();
-  return value;
+  // MANUFACTURER
+  if (field == 0) return (value >> 12) & 0xFF;
+  // PRODUCT ID
+  if (field == 1) return value & 0x0FFF;
+  // DENSITY
+  if (field == 2) return (value >> 8) & 0x0F;
+  return 0;
 }
 
-///////////////////////////////////////////////////////////
-//
-// PRIVATE
-//
-void FRAM::writeBlock(uint16_t memaddr, uint8_t * obj, uint16_t size)
+void FRAM::writeBlock(uint16_t memaddr, uint8_t * obj, uint8_t size)
 {
   // TODO constrain size < 30 ??
   Wire.beginTransmission(_address);
@@ -164,7 +186,7 @@ void FRAM::writeBlock(uint16_t memaddr, uint8_t * obj, uint16_t size)
   Wire.endTransmission();
 }
 
-void FRAM::readBlock(uint16_t memaddr, uint8_t * obj, uint16_t size)
+void FRAM::readBlock(uint16_t memaddr, uint8_t * obj, uint8_t size)
 {
   Wire.beginTransmission(_address);
   Wire.write(memaddr >> 8);
@@ -178,4 +200,4 @@ void FRAM::readBlock(uint16_t memaddr, uint8_t * obj, uint16_t size)
   }
 }
 
-// END OF FILE
+// -- END OF FILE --

libraries/FRAM/FRAM.h

@@ -1,21 +1,20 @@
+#pragma once
 //
 //    FILE: FRAM.h
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.1
-// PURPOSE: Class for FRAM memory
-//     URL:
+// VERSION: 0.2.1
+//    DATE: 2018-01-24
+// PURPOSE: Arduino library for I2C FRAM
+//     URL: https://github.com/RobTillaart/FRAM_I2C
 //
 // HISTORY:
 // see FRAM.cpp file
 //
 
-#ifndef FRAM_H
-#define FRAM_H
-
 #include "Arduino.h"
 #include "Wire.h"
 
-#define FRAM_LIB_VERSION (F("0.1.1"))
+#define FRAM_LIB_VERSION (F("0.2.1"))
 
 #define FRAM_OK               0
 #define FRAM_ERROR_ADDR       -10
@@ -25,7 +24,8 @@ class FRAM
 public:
   FRAM();
 
-  int   begin(const int address);  // defaults to 0x50
+  // writeProtectPin is optional
+  int   begin(const uint8_t address = 0x50, int8_t writeProtectPin = -1);
 
   void  write8(uint16_t memaddr, uint8_t value);
   void  write16(uint16_t memaddr, uint16_t value);
@@ -37,18 +37,19 @@ class FRAM
   uint32_t read32(uint16_t memaddr);
   void     read(uint16_t memaddr, uint8_t * obj, uint16_t size);
 
+  bool     setWriteProtect(bool b);
+
   uint16_t getManufacturerID();
   uint16_t getProductID();
-  uint16_t getSize() { return _size; };
+  uint16_t getSize();
 
 private:
-  int8_t    _address;
-  uint16_t  _size;   // unknown
+  uint8_t   _address;
+  int8_t    _writeProtectPin = -1;  // default no pin ==> no write protect.
 
-  void writeBlock(uint16_t memaddr, uint8_t * obj, uint16_t size);
-  void readBlock(uint16_t memaddr, uint8_t * obj, uint16_t size);
+  uint16_t getMetaData(uint8_t id);
+  void writeBlock(uint16_t memaddr, uint8_t * obj, uint8_t size);
+  void readBlock(uint16_t memaddr, uint8_t * obj, uint8_t size);
 };
 
-#endif
-
-// END OF FILE
+// -- END OF FILE --

libraries/FRAM/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2020 Rob Tillaart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libraries/FRAM/README.md

@@ -0,0 +1,23 @@
+# FRAM_I2C
+
+Arduino library for I2C FRAM 
+
+# Description
+
+FRAM is a library to read and write (over I2C) to an FRAM module. 
+FRAM is much faster than EEPROM and almost as fast as Arduino UNO RAM.
+Another imaportant feature is that FRAM keeps its content after a reboot (non-volatile)
+
+Types of FRAM it should work with
+
+| SIZE  |  TYPE |
+|:---:|:---:|
+| 8KB   | MB85RC64T  |
+| 32KB  | MB85RC256V |
+| 64KB  | MB85RC512T |
+| 128KB | MB85RC1MT  |
+ 
+ 
+# Operational
+ 
+ See examples

libraries/FRAM/examples/testFRAM/testFRAM.ino

@@ -3,7 +3,7 @@
 //  AUTHOR: Rob Tillaart
 // VERSION: 0.1.0
 // PURPOSE: test for FRAM library for Arduino
-//     URL:
+//     URL: https://github.com/RobTillaart/FRAM_I2C
 //
 // Released to the public domain
 //
@@ -171,7 +171,6 @@ void testReadWriteLarge()
   Serial.println();
 }
 
-
 void testWriteText()
 {
   char str[10][20] =

libraries/FRAM/examples/testFRAMPerformance/testFRAMPerformance.ino

@@ -3,9 +3,7 @@
 //  AUTHOR: Rob Tillaart
 // VERSION: 0.1.0
 // PURPOSE: test for FRAM library for Arduino
-//     URL:
-//
-// Released to the public domain
+//     URL: https://github.com/RobTillaart/FRAM_I2C
 //
 
 #include "FRAM.h"
@@ -15,6 +13,8 @@ FRAM fram;
 uint32_t start;
 uint32_t stop;
 
+int ar[600];
+  
 void setup()
 {
   Serial.begin(115200);
@@ -55,30 +55,31 @@ void testReadWriteLarge()
   Serial.println();
   Serial.println(__FUNCTION__);
 
-  uint8_t ar[100];
-  for (int i = 0; i < 100; i++) ar[i] = i;
+  for (int i = 0; i < 600; i++) ar[i] = i;
 
   start = millis();
-  fram.write(1000, ar, 100);
+  fram.write(1000, (uint8_t*)ar, 1200);
   stop = millis();
-  Serial.print("WRITE 100 bytes TIME:\t");
+  Serial.print("WRITE 1200 bytes TIME:\t");
   Serial.print(stop - start);
   Serial.println(" ms");
 
-  for (int i = 0; i < 100; i++) ar[i] = 0;
+  for (int i = 0; i < 600; i++) ar[i] = 0;
 
   start = millis();
-  fram.read(1000, ar, 100);
+  fram.read(1000, (uint8_t*)ar, 1200);
   stop = millis();
-  Serial.print("READ 100 bytes TIME:\t");
+  Serial.print("READ 1200 bytes TIME:\t");
   Serial.print(stop - start);
   Serial.println(" ms");
 
-  for (int i = 0; i < 100; i++)
+  for (int i = 0; i < 600; i++)
   {
     if (ar[i] != i)
     {
       Serial.print("FAIL: \t");
+      Serial.print(ar[i]);
+      Serial.print('\t');
       Serial.println(i);
     }
   }

libraries/FRAM/keywords.txt

@@ -1,22 +1,25 @@
-#######################################
 # Syntax Coloring Map for FRAM
-#######################################
 
-#######################################
 # Datatypes (KEYWORD1)
-#######################################
-
 FRAM	KEYWORD1
 
-#######################################
 # Methods and Functions (KEYWORD2)
-#######################################
+begin	KEYWORD2
+
+write8	KEYWORD2
+write16	KEYWORD2
+write32	KEYWORD2
+write	KEYWORD2
+
+read8	KEYWORD2
+read16	KEYWORD2
+read32	KEYWORD2
+read	KEYWORD2
 
 getManufacturerID	KEYWORD2
 getProductID	KEYWORD2
+getSize	KEYWORD2
 
-#######################################
 # Constants (LITERAL1)
-#######################################
-
-unknown	LITERAL1
+FRAM_OK	LITERAL1
+FRAM_ERROR_ADDR	LITERAL1