Cansat
/
SPIFlash_LowPowerLab
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use SPI_TRANSCTIONS when supported

This commit is contained in:
LowPowerLab 2015-06-02 15:02:10 -04:00
parent 126592337b
commit 6e92ea284a
1 changed files with 72 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
SPIFlash.cpp
View File

@ -1,22 +1,40 @@
/* // Copyright (c) 2013-2015 by Felix Rusu, LowPowerLab.com
* Copyright (c) 2013 by Felix Rusu <felix@lowpowerlab.com> // SPI Flash memory library for arduino/moteino.
* SPI Flash memory library for arduino/moteino. // This works with 256byte/page SPI flash memory
* This works with 256byte/page SPI flash memory // For instance a 4MBit (512Kbyte) flash chip will have 2048 pages: 256*2048 = 524288 bytes (512Kbytes)
* For instance a 4MBit (512Kbyte) flash chip will have 2048 pages: 256*2048 = 524288 bytes (512Kbytes) // Minimal modifications should allow chips that have different page size but modifications
* Minimal modifications should allow chips that have different page size but modifications // DEPENDS ON: Arduino SPI library
* DEPENDS ON: Arduino SPI library // > Updated Jan. 5, 2015, TomWS1, modified writeBytes to allow blocks > 256 bytes and handle page misalignment.
* // > Updated Feb. 26, 2015 TomWS1, added support for SPI Transactions (Arduino 1.5.8 and above)
* Updated Jan. 5, 2015, TomWS1, modified writeBytes to allow blocks > 256 bytes and handle page misalignment. // > Selective merge by Felix after testing in IDE 1.0.6, 1.6.4
* // **********************************************************************************
* This file is free software; you can redistribute it and/or modify // License
* it under the terms of either the GNU General Public License version 2 // **********************************************************************************
* or the GNU Lesser General Public License version 2.1, both as // This program is free software; you can redistribute it
* published by the Free Software Foundation. // and/or modify it under the terms of the GNU General
*/ // Public License as published by the Free Software
// Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will
// be useful, but WITHOUT ANY WARRANTY; without even the
// implied warranty of MERCHANTABILITY or FITNESS FOR A
// PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General
// Public License along with this program.
// If not, see <http://www.gnu.org/licenses/>.
//
// Licence can be viewed at
// http://www.gnu.org/licenses/gpl-3.0.txt
//
// Please maintain this license information along with authorship
// and copyright notices in any redistribution of this code
#include <SPIFlash.h> #include <SPIFlash.h>
byte SPIFlash::UNIQUEID[8]; uint8_t SPIFlash::UNIQUEID[8];
/// IMPORTANT: NAND FLASH memory requires erase before write, because /// IMPORTANT: NAND FLASH memory requires erase before write, because
/// it can only transition from 1s to 0s and only the erase command can reset all 0s to 1s /// it can only transition from 1s to 0s and only the erase command can reset all 0s to 1s
@ -34,15 +52,22 @@ SPIFlash::SPIFlash(uint8_t slaveSelectPin, uint16_t jedecID) {
/// Select the flash chip /// Select the flash chip
void SPIFlash::select() { void SPIFlash::select() {
noInterrupts();
//save current SPI settings //save current SPI settings
#ifndef SPI_HAS_TRANSACTION
noInterrupts();
#endif
_SPCR = SPCR; _SPCR = SPCR;
_SPSR = SPSR; _SPSR = SPSR;
//set FLASH chip SPI settings
#ifdef SPI_HAS_TRANSACTION
SPI.beginTransaction(_settings);
#else
// set FLASH SPI settings
SPI.setDataMode(SPI_MODE0); SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(MSBFIRST); SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV4); //decided to slow down from DIV2 after SPI stalling in some instances, especially visible on mega1284p when RFM69 and FLASH chip both present SPI.setClockDivider(SPI_CLOCK_DIV4); //decided to slow down from DIV2 after SPI stalling in some instances, especially visible on mega1284p when RFM69 and FLASH chip both present
SPI.begin(); SPI.begin();
#endif
digitalWrite(_slaveSelectPin, LOW); digitalWrite(_slaveSelectPin, LOW);
} }
@ -50,9 +75,13 @@ void SPIFlash::select() {
void SPIFlash::unselect() { void SPIFlash::unselect() {
digitalWrite(_slaveSelectPin, HIGH); digitalWrite(_slaveSelectPin, HIGH);
//restore SPI settings to what they were before talking to the FLASH chip //restore SPI settings to what they were before talking to the FLASH chip
#ifdef SPI_HAS_TRANSACTION
SPI.endTransaction();
#else
interrupts();
#endif
SPCR = _SPCR; SPCR = _SPCR;
SPSR = _SPSR; SPSR = _SPSR;
interrupts();
} }
/// setup SPI, read device ID etc... /// setup SPI, read device ID etc...
@ -61,6 +90,10 @@ boolean SPIFlash::initialize()
_SPCR = SPCR; _SPCR = SPCR;
_SPSR = SPSR; _SPSR = SPSR;
pinMode(_slaveSelectPin, OUTPUT); pinMode(_slaveSelectPin, OUTPUT);
#ifdef SPI_HAS_TRANSACTION
_settings = SPISettings(4000000, MSBFIRST, SPI_MODE0);
#endif
unselect(); unselect();
wakeup(); wakeup();
@ -74,7 +107,7 @@ boolean SPIFlash::initialize()
} }
/// Get the manufacturer and device ID bytes (as a short word) /// Get the manufacturer and device ID bytes (as a short word)
word SPIFlash::readDeviceId() uint16_t SPIFlash::readDeviceId()
{ {
#if defined(__AVR_ATmega32U4__) // Arduino Leonardo, MoteinoLeo #if defined(__AVR_ATmega32U4__) // Arduino Leonardo, MoteinoLeo
command(SPIFLASH_IDREAD); // Read JEDEC ID command(SPIFLASH_IDREAD); // Read JEDEC ID
@ -82,7 +115,7 @@ word SPIFlash::readDeviceId()
select(); select();
SPI.transfer(SPIFLASH_IDREAD); SPI.transfer(SPIFLASH_IDREAD);
#endif #endif
word jedecid = SPI.transfer(0) << 8; uint16_t jedecid = SPI.transfer(0) << 8;
jedecid |= SPI.transfer(0); jedecid |= SPI.transfer(0);
unselect(); unselect();
return jedecid; return jedecid;
@ -91,47 +124,47 @@ word SPIFlash::readDeviceId()
/// Get the 64 bit unique identifier, stores it in UNIQUEID[8]. Only needs to be called once, ie after initialize /// Get the 64 bit unique identifier, stores it in UNIQUEID[8]. Only needs to be called once, ie after initialize
/// Returns the byte pointer to the UNIQUEID byte array /// Returns the byte pointer to the UNIQUEID byte array
/// Read UNIQUEID like this: /// Read UNIQUEID like this:
/// flash.readUniqueId(); for (byte i=0;i<8;i++) { Serial.print(flash.UNIQUEID[i], HEX); Serial.print(' '); } /// flash.readUniqueId(); for (uint8_t i=0;i<8;i++) { Serial.print(flash.UNIQUEID[i], HEX); Serial.print(' '); }
/// or like this: /// or like this:
/// flash.readUniqueId(); byte* MAC = flash.readUniqueId(); for (byte i=0;i<8;i++) { Serial.print(MAC[i], HEX); Serial.print(' '); } /// flash.readUniqueId(); uint8_t* MAC = flash.readUniqueId(); for (uint8_t i=0;i<8;i++) { Serial.print(MAC[i], HEX); Serial.print(' '); }
byte* SPIFlash::readUniqueId() uint8_t* SPIFlash::readUniqueId()
{ {
command(SPIFLASH_MACREAD); command(SPIFLASH_MACREAD);
SPI.transfer(0); SPI.transfer(0);
SPI.transfer(0); SPI.transfer(0);
SPI.transfer(0); SPI.transfer(0);
SPI.transfer(0); SPI.transfer(0);
for (byte i=0;i<8;i++) for (uint8_t i=0;i<8;i++)
UNIQUEID[i] = SPI.transfer(0); UNIQUEID[i] = SPI.transfer(0);
unselect(); unselect();
return UNIQUEID; return UNIQUEID;
} }
/// read 1 byte from flash memory /// read 1 byte from flash memory
byte SPIFlash::readByte(long addr) { uint8_t SPIFlash::readByte(uint32_t addr) {
command(SPIFLASH_ARRAYREADLOWFREQ); command(SPIFLASH_ARRAYREADLOWFREQ);
SPI.transfer(addr >> 16); SPI.transfer(addr >> 16);
SPI.transfer(addr >> 8); SPI.transfer(addr >> 8);
SPI.transfer(addr); SPI.transfer(addr);
byte result = SPI.transfer(0); uint8_t result = SPI.transfer(0);
unselect(); unselect();
return result; return result;
} }
/// read unlimited # of bytes /// read unlimited # of bytes
void SPIFlash::readBytes(long addr, void* buf, word len) { void SPIFlash::readBytes(uint32_t addr, void* buf, uint16_t len) {
command(SPIFLASH_ARRAYREAD); command(SPIFLASH_ARRAYREAD);
SPI.transfer(addr >> 16); SPI.transfer(addr >> 16);
SPI.transfer(addr >> 8); SPI.transfer(addr >> 8);
SPI.transfer(addr); SPI.transfer(addr);
SPI.transfer(0); //"dont care" SPI.transfer(0); //"dont care"
for (word i = 0; i < len; ++i) for (uint16_t i = 0; i < len; ++i)
((byte*) buf)[i] = SPI.transfer(0); ((uint8_t*) buf)[i] = SPI.transfer(0);
unselect(); unselect();
} }
/// Send a command to the flash chip, pass TRUE for isWrite when its a write command /// Send a command to the flash chip, pass TRUE for isWrite when its a write command
void SPIFlash::command(byte cmd, boolean isWrite){ void SPIFlash::command(uint8_t cmd, boolean isWrite){
#if defined(__AVR_ATmega32U4__) // Arduino Leonardo, MoteinoLeo #if defined(__AVR_ATmega32U4__) // Arduino Leonardo, MoteinoLeo
DDRB |= B00000001; // Make sure the SS pin (PB0 - used by RFM12B on MoteinoLeo R1) is set as output HIGH! DDRB |= B00000001; // Make sure the SS pin (PB0 - used by RFM12B on MoteinoLeo R1) is set as output HIGH!
PORTB |= B00000001; PORTB |= B00000001;
@ -157,7 +190,7 @@ boolean SPIFlash::busy()
/* /*
select(); select();
SPI.transfer(SPIFLASH_STATUSREAD); SPI.transfer(SPIFLASH_STATUSREAD);
byte status = SPI.transfer(0); uint8_t status = SPI.transfer(0);
unselect(); unselect();
return status & 1; return status & 1;
*/ */
@ -165,11 +198,11 @@ boolean SPIFlash::busy()
} }
/// return the STATUS register /// return the STATUS register
byte SPIFlash::readStatus() uint8_t SPIFlash::readStatus()
{ {
select(); select();
SPI.transfer(SPIFLASH_STATUSREAD); SPI.transfer(SPIFLASH_STATUSREAD);
byte status = SPI.transfer(0); uint8_t status = SPI.transfer(0);
unselect(); unselect();
return status; return status;
} }
@ -178,7 +211,7 @@ byte SPIFlash::readStatus()
/// Write 1 byte to flash memory /// Write 1 byte to flash memory
/// WARNING: you can only write to previously erased memory locations (see datasheet) /// WARNING: you can only write to previously erased memory locations (see datasheet)
/// use the block erase commands to first clear memory (write 0xFFs) /// use the block erase commands to first clear memory (write 0xFFs)
void SPIFlash::writeByte(long addr, uint8_t byt) { void SPIFlash::writeByte(uint32_t addr, uint8_t byt) {
command(SPIFLASH_BYTEPAGEPROGRAM, true); // Byte/Page Program command(SPIFLASH_BYTEPAGEPROGRAM, true); // Byte/Page Program
SPI.transfer(addr >> 16); SPI.transfer(addr >> 16);
SPI.transfer(addr >> 8); SPI.transfer(addr >> 8);
@ -192,7 +225,7 @@ void SPIFlash::writeByte(long addr, uint8_t byt) {
/// use the block erase commands to first clear memory (write 0xFFs) /// use the block erase commands to first clear memory (write 0xFFs)
/// This version handles both page alignment and data blocks larger than 256 bytes. /// This version handles both page alignment and data blocks larger than 256 bytes.
/// ///
void SPIFlash::writeBytes(long addr, const void* buf, uint16_t len) { void SPIFlash::writeBytes(uint32_t addr, const void* buf, uint16_t len) {
uint16_t n; uint16_t n;
uint16_t maxBytes = 256-(addr%256); // force the first set of bytes to stay within the first page uint16_t maxBytes = 256-(addr%256); // force the first set of bytes to stay within the first page
uint16_t offset = 0; uint16_t offset = 0;
@ -205,7 +238,7 @@ void SPIFlash::writeBytes(long addr, const void* buf, uint16_t len) {
SPI.transfer(addr); SPI.transfer(addr);
for (uint16_t i = 0; i < n; i++) for (uint16_t i = 0; i < n; i++)
SPI.transfer(((byte*) buf)[offset + i]); SPI.transfer(((uint8_t*) buf)[offset + i]);
unselect(); unselect();
addr+=n; // adjust the addresses and remaining bytes by what we've just transferred. addr+=n; // adjust the addresses and remaining bytes by what we've just transferred.
@ -227,7 +260,7 @@ void SPIFlash::chipErase() {
} }
/// erase a 4Kbyte block /// erase a 4Kbyte block
void SPIFlash::blockErase4K(long addr) { void SPIFlash::blockErase4K(uint32_t addr) {
command(SPIFLASH_BLOCKERASE_4K, true); // Block Erase command(SPIFLASH_BLOCKERASE_4K, true); // Block Erase
SPI.transfer(addr >> 16); SPI.transfer(addr >> 16);
SPI.transfer(addr >> 8); SPI.transfer(addr >> 8);
@ -236,7 +269,7 @@ void SPIFlash::blockErase4K(long addr) {
} }
/// erase a 32Kbyte block /// erase a 32Kbyte block
void SPIFlash::blockErase32K(long addr) { void SPIFlash::blockErase32K(uint32_t addr) {
command(SPIFLASH_BLOCKERASE_32K, true); // Block Erase command(SPIFLASH_BLOCKERASE_32K, true); // Block Erase
SPI.transfer(addr >> 16); SPI.transfer(addr >> 16);
SPI.transfer(addr >> 8); SPI.transfer(addr >> 8);