Add CurieSerialFlash wrapper over SerialFlash library

The examples declare the correct CS pin and use the overloaded begin() method, passing SPI1 as port

The link in the last line of the header opens the library manager to allow easy import of the father library

Author: facchinm

libraries/CurieSerialFlash/CurieSerialFlash.h

@@ -0,0 +1,4 @@
+#if !defined (__arc__)
+#error These examples only work with onboard SPI flash on Arduino/Genuino 101 board
+#endif
+#include "SerialFlash.h"

libraries/CurieSerialFlash/examples/CopyFromSerial/CopyFromSerial.ino

@@ -0,0 +1,268 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ * 
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ * 
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ * 
+ * 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 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.
+ * 
+ * For more information, please refer to <http://unlicense.org>
+ * -------------------------------------------------------------------------
+ * 
+ * This is example code to 1) format an SPI Flash chip, and 2) copy raw 
+ * audio files (mono channel, 16 bit signed, 44100Hz) to it using the 
+ * SerialFlash library.  The audio can then be played back using the 
+ * AudioPlaySerialflashRaw object in the Teensy Audio library.
+ * 
+ * To convert a .wav file to the proper .RAW format, use sox:
+ * sox input.wav -r 44100 -b 16 --norm -e signed-integer -t raw OUTPUT.RAW remix 1,2
+ * 
+ * Note that the OUTPUT.RAW filename must be all caps and contain only the following
+ * characters: A-Z, 0-9, comma, period, colon, dash, underscore.  (The SerialFlash
+ * library converts filenames to caps, so to avoid confusion we just enforce it here).
+ * 
+ * It is a little difficult to see what is happening; aswe are using the Serial port
+ * to upload files, we can't just throw out debug information.  Instead, we use the LED
+ * (pin 13) to convey state.
+ * 
+ * While the chip is being formatted, the LED (pin 13) will toggle at 1Hz rate.  When 
+ * the formatting is done, it flashes quickly (10Hz) for one second, then stays on 
+ * solid.  When nothing has been received for 3 seconds, the upload is assumed to be 
+ * completed, and the light goes off.
+ * 
+ * Use the 'rawfile-uploader.py' python script (included in the extras folder) to upload
+ * the files.  You can start the script as soon as the Teensy is turned on, and the
+ * USB serial upload will just buffer and wait until the flash is formatted.
+ * 
+ * This code was written by Wyatt Olson <wyatt@digitalcave.ca> (originally as part 
+ * of Drum Master http://drummaster.digitalcave.ca and later modified into a 
+ * standalone sample).
+ * 
+ * Enjoy!
+ *
+ * SerialFlash library API: https://github.com/PaulStoffregen/SerialFlash
+ *
+ * This example depens on http://librarymanager/all#SerialFlash&SPI (clickme!)
+ */
+
+#include <CurieSerialFlash.h>
+#include <SPI.h>
+
+//Buffer sizes
+#define USB_BUFFER_SIZE      128
+#define FLASH_BUFFER_SIZE    4096
+
+//Max filename length (8.3 plus a null char terminator)
+#define FILENAME_STRING_SIZE      13
+
+//State machine
+#define STATE_START      0
+#define STATE_SIZE      1
+#define STATE_CONTENT    2
+
+//Special bytes in the communication protocol
+#define BYTE_START      0x7e
+#define BYTE_ESCAPE      0x7d
+#define BYTE_SEPARATOR    0x7c
+
+#define CSPIN             21
+
+void setup(){
+  Serial.begin(9600);  //Teensy serial is always at full USB speed and buffered... the baud rate here is required but ignored
+
+  pinMode(13, OUTPUT);
+  
+  SerialFlash.begin(SPI1, CSPIN);
+
+  //We start by formatting the flash...
+  uint8_t id[5];
+  SerialFlash.readID(id);
+  SerialFlash.eraseAll();
+  
+  //Flash LED at 1Hz while formatting
+  while (!SerialFlash.ready()) {
+    delay(500);
+    digitalWrite(13, HIGH);
+    delay(500);
+    digitalWrite(13, LOW);
+  }
+
+  //Quickly flash LED a few times when completed, then leave the light on solid
+  for(uint8_t i = 0; i < 10; i++){
+    delay(100);
+    digitalWrite(13, HIGH);
+    delay(100);
+    digitalWrite(13, LOW);
+  }
+  digitalWrite(13, HIGH);
+  
+  //We are now going to wait for the upload program
+  while(!Serial.available());
+  
+  SerialFlashFile flashFile;
+  
+  uint8_t state = STATE_START;
+  uint8_t escape = 0;
+  uint8_t fileSizeIndex = 0;
+  uint32_t fileSize = 0;
+  char filename[FILENAME_STRING_SIZE];
+  
+  char usbBuffer[USB_BUFFER_SIZE];
+  uint8_t flashBuffer[FLASH_BUFFER_SIZE];
+  
+  uint16_t flashBufferIndex = 0;
+  uint8_t filenameIndex = 0;
+  
+  uint32_t lastReceiveTime = millis();
+  
+  //We assume the serial receive part is finished when we have not received something for 3 seconds
+  while(Serial.available() || lastReceiveTime + 3000 > millis()){
+    uint16_t available = Serial.readBytes(usbBuffer, USB_BUFFER_SIZE);
+    if (available){
+      lastReceiveTime = millis();
+    }
+
+    for (uint16_t usbBufferIndex = 0; usbBufferIndex < available; usbBufferIndex++){
+      uint8_t b = usbBuffer[usbBufferIndex];
+      
+      if (state == STATE_START){
+        //Start byte.  Repeat start is fine.
+        if (b == BYTE_START){
+          for (uint8_t i = 0; i < FILENAME_STRING_SIZE; i++){
+            filename[i] = 0x00;
+          }
+          filenameIndex = 0;
+        }
+        //Valid characters are A-Z, 0-9, comma, period, colon, dash, underscore
+        else if ((b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9') || b == '.' || b == ',' || b == ':' || b == '-' || b == '_'){
+          filename[filenameIndex++] = b;
+          if (filenameIndex >= FILENAME_STRING_SIZE){
+            //Error name too long
+            flushError();
+            return;
+          }
+        }
+        //Filename end character
+        else if (b == BYTE_SEPARATOR){
+          if (filenameIndex == 0){
+            //Error empty filename
+            flushError();
+            return;
+          }
+          
+          //Change state
+          state = STATE_SIZE;
+          fileSizeIndex = 0;
+          fileSize = 0;
+          
+        }
+        //Invalid character
+        else {
+          //Error bad filename
+          flushError();
+          return;
+        }
+      }
+      //We read 4 bytes as a uint32_t for file size
+      else if (state == STATE_SIZE){
+        if (fileSizeIndex < 4){
+          fileSize = (fileSize << 8) + b;
+          fileSizeIndex++;
+        }
+        else if (b == BYTE_SEPARATOR){
+          state = STATE_CONTENT;
+          flashBufferIndex = 0;
+          escape = 0;
+          
+          if (SerialFlash.exists(filename)){
+            SerialFlash.remove(filename);  //It doesn't reclaim the space, but it does let you create a new file with the same name.
+          }
+          
+          //Create a new file and open it for writing
+          if (SerialFlash.create(filename, fileSize)) {
+            flashFile = SerialFlash.open(filename);
+            if (!flashFile) {
+              //Error flash file open
+              flushError();
+              return;
+            }
+          }
+          else {
+            //Error flash create (no room left?)
+            flushError();
+            return;
+          }
+        }
+        else {
+          //Error invalid length requested
+          flushError();
+          return;
+        }
+      }
+      else if (state == STATE_CONTENT){
+        //Previous byte was escaped; unescape and add to buffer
+        if (escape){
+          escape = 0;
+          flashBuffer[flashBufferIndex++] = b ^ 0x20;
+        }
+        //Escape the next byte
+        else if (b == BYTE_ESCAPE){
+          //Serial.println("esc");
+          escape = 1;
+        }
+        //End of file
+        else if (b == BYTE_START){
+          //Serial.println("End of file");
+          state = STATE_START;
+          flashFile.write(flashBuffer, flashBufferIndex);
+          flashFile.close();
+          flashBufferIndex = 0;
+        }
+        //Normal byte; add to buffer
+        else {
+          flashBuffer[flashBufferIndex++] = b;
+        }
+        
+        //The buffer is filled; write to SD card
+        if (flashBufferIndex >= FLASH_BUFFER_SIZE){
+          flashFile.write(flashBuffer, FLASH_BUFFER_SIZE);
+          flashBufferIndex = 0;
+        }
+      }
+    }
+  }
+
+  //Success!  Turn the light off.
+  digitalWrite(13, LOW);
+}
+
+void loop(){
+  //Do nothing.
+}
+
+void flushError(){
+  uint32_t lastReceiveTime = millis();
+  char usbBuffer[USB_BUFFER_SIZE];
+  //We assume the serial receive part is finished when we have not received something for 3 seconds
+  while(Serial.available() || lastReceiveTime + 3000 > millis()){
+    if (Serial.readBytes(usbBuffer, USB_BUFFER_SIZE)){
+      lastReceiveTime = millis();
+    }
+  }
+}

libraries/CurieSerialFlash/examples/EraseEverything/EraseEverything.ino

@@ -0,0 +1,80 @@
+// This example depens on http://librarymanager/all#SerialFlash&SPI (clickme!)
+
+#include <CurieSerialFlash.h>
+#include <SPI.h>
+
+const int FlashChipSelect = 21; // digital pin for flash chip CS pin
+
+SerialFlashFile file;
+
+const unsigned long testIncrement = 4096;
+
+void setup() {
+  //uncomment these if using Teensy audio shield
+  //SPI.setSCK(14);  // Audio shield has SCK on pin 14
+  //SPI.setMOSI(7);  // Audio shield has MOSI on pin 7
+
+  //uncomment these if you have other SPI chips connected
+  //to keep them disabled while using only SerialFlash
+  //pinMode(4, INPUT_PULLUP);
+  //pinMode(10, INPUT_PULLUP);
+
+  Serial.begin(9600);
+
+  // wait up to 10 seconds for Arduino Serial Monitor
+  unsigned long startMillis = millis();
+  while (!Serial && (millis() - startMillis < 10000)) ;
+  delay(100);
+
+  SerialFlash.begin(SPI1, FlashChipSelect);
+  unsigned char id[5];
+  SerialFlash.readID(id);
+  unsigned long size = SerialFlash.capacity(id);
+
+  if (size > 0) {
+    Serial.print("Flash Memory has ");
+    Serial.print(size);
+    Serial.println(" bytes.");
+    Serial.println("Erasing ALL Flash Memory:");
+    // Estimate the (lengthy) wait time.
+    Serial.print("  estimated wait: ");
+    int seconds = (float)size / eraseBytesPerSecond(id) + 0.5;
+    Serial.print(seconds);
+    Serial.println(" seconds.");
+    Serial.println("  Yes, full chip erase is SLOW!");
+    SerialFlash.eraseAll();
+    unsigned long dotMillis = millis();
+    unsigned char dotcount = 0;
+    while (SerialFlash.ready() == false) {
+      if (millis() - dotMillis > 1000) {
+        dotMillis = dotMillis + 1000;
+        Serial.print(".");
+        dotcount = dotcount + 1;
+        if (dotcount >= 60) {
+          Serial.println();
+          dotcount = 0;
+        }
+      }
+    }
+    if (dotcount > 0) Serial.println();
+    Serial.println("Erase completed");
+    unsigned long elapsed = millis() - startMillis;
+    Serial.print("  actual wait: ");
+    Serial.print(elapsed / 1000ul);
+    Serial.println(" seconds.");
+  }
+}
+
+float eraseBytesPerSecond(const unsigned char *id) {
+  if (id[0] == 0x20) return 152000.0; // Micron
+  if (id[0] == 0x01) return 500000.0; // Spansion
+  if (id[0] == 0xEF) return 419430.0; // Winbond
+  if (id[0] == 0xC2) return 279620.0; // Macronix
+  return 320000.0; // guess?
+}
+
+
+void loop() {
+
+}
+

libraries/CurieSerialFlash/examples/FileWrite/FileWrite.ino

@@ -0,0 +1,50 @@
+// This example depens on http://librarymanager/all#SerialFlash&SPI (clickme!)
+
+#include <CurieSerialFlash.h>
+#include <SPI.h>
+
+#define FSIZE 256
+
+const char *filename = "myfile.txt";
+const char *contents = "0123456789ABCDEF";
+
+const int FlashChipSelect = 21; // digital pin for flash chip CS pin
+
+void setup() {
+  Serial.begin(9600);
+
+  // wait for Arduino Serial Monitor
+  while (!Serial) ;
+  delay(100);
+
+  // Init. SPI Flash chip
+  if (!SerialFlash.begin(SPI1, FlashChipSelect)) {
+    Serial.println("Unable to access SPI Flash chip");
+  }
+
+  SerialFlashFile file;
+
+  // Create the file if it doesn't exist
+  if (!create_if_not_exists(filename)) {
+    Serial.println("Not enough space to create file " + String(filename));
+    return;
+  }
+
+  // Open the file and write test data
+  file = SerialFlash.open(filename);
+  file.write(contents, strlen(contents) + 1);
+  Serial.println("String \"" + String(contents) + "\" written to file " + String(filename));
+}
+
+bool create_if_not_exists (const char *filename) {
+  if (!SerialFlash.exists(filename)) {
+    Serial.println("Creating file " + String(filename));
+    return SerialFlash.create(filename, FSIZE);
+  }
+
+  Serial.println("File " + String(filename) + " already exists");
+  return true;
+}
+
+void loop() {
+}

libraries/CurieSerialFlash/examples/ListFiles/ListFiles.ino

@@ -0,0 +1,63 @@
+// This example depens on http://librarymanager/all#SerialFlash&SPI (clickme!)
+
+#include <CurieSerialFlash.h>
+#include <SPI.h>
+
+const int FlashChipSelect = 21; // digital pin for flash chip CS pin
+
+void setup() {
+  //uncomment these if using Teensy audio shield
+  //SPI.setSCK(14);  // Audio shield has SCK on pin 14
+  //SPI.setMOSI(7);  // Audio shield has MOSI on pin 7
+
+  //uncomment these if you have other SPI chips connected
+  //to keep them disabled while using only SerialFlash
+  //pinMode(4, INPUT_PULLUP);
+  //pinMode(10, INPUT_PULLUP);
+
+  Serial.begin(9600);
+
+  // wait for Arduino Serial Monitor
+  while (!Serial) ;
+  delay(100);
+  Serial.println("All Files on SPI Flash chip:");
+
+  if (!SerialFlash.begin(SPI1, FlashChipSelect)) {
+    error("Unable to access SPI Flash chip");
+  }
+
+  SerialFlash.opendir();
+  unsigned int count = 0;
+  while (1) {
+    char filename[64];
+    unsigned long filesize;
+
+    if (SerialFlash.readdir(filename, sizeof(filename), filesize)) {
+      Serial.print("  ");
+      Serial.print(filename);
+      spaces(20 - strlen(filename));
+      Serial.print("  ");
+      Serial.print(filesize);
+      Serial.print(" bytes");
+      Serial.println();
+    } else {
+      break; // no more files
+    }
+  }
+}
+
+void spaces(int num) {
+  for (int i=0; i < num; i++) {
+    Serial.print(" ");
+  }
+}
+
+void loop() {
+}
+
+void error(const char *message) {
+  while (1) {
+    Serial.println(message);
+    delay(2500);
+  }
+}