added v2.0
This commit is contained in:
Michael Schröder
1961
tools/olimexino-32u4 firmware/src/SPIFlash.cpp
Normal file
1961
tools/olimexino-32u4 firmware/src/SPIFlash.cpp
Normal file
File diff suppressed because it is too large
Load Diff
267
tools/olimexino-32u4 firmware/src/SPIFlash.h
Normal file
267
tools/olimexino-32u4 firmware/src/SPIFlash.h
Normal file
@@ -0,0 +1,267 @@
|
||||
/* Arduino SPIFlash Library v.2.2.0
|
||||
* Copyright (C) 2015 by Prajwal Bhattaram
|
||||
* Modified by Prajwal Bhattaram - 24/11/2015
|
||||
*
|
||||
* This file is part of the Arduino SPIFlash Library. This library is for
|
||||
* Winbond NOR flash memory modules. In its current form it enables reading
|
||||
* and writing individual data variables, structs and arrays from and to various locations;
|
||||
* reading and writing pages; continuous read functions; sector, block and chip erase;
|
||||
* suspending and resuming programming/erase and powering down for low power operation.
|
||||
*
|
||||
* This Library is free software: you can redistribute it 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 Library 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 v3.0
|
||||
* along with the Arduino SPIFlash Library. If not, see
|
||||
* <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef SPIFLASH_H
|
||||
#define SPIFLASH_H
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
class SPIFlash {
|
||||
public:
|
||||
//----------------------------------------------Constructor-----------------------------------------------//
|
||||
SPIFlash(uint8_t cs = 10, bool overflow = true);
|
||||
//----------------------------------------Initial / Chip Functions----------------------------------------//
|
||||
void begin();
|
||||
uint16_t getManID();
|
||||
uint32_t getJEDECID();
|
||||
bool getAddress(uint16_t size, uint16_t &page_number, uint8_t &offset);
|
||||
uint32_t getAddress(uint16_t size);
|
||||
uint16_t getChipName();
|
||||
uint16_t sizeofStr(String &inputStr);
|
||||
uint32_t getCapacity();
|
||||
uint32_t getMaxPage();
|
||||
//-------------------------------------------Write / Read Bytes-------------------------------------------//
|
||||
bool writeByte(uint32_t address, uint8_t data, bool errorCheck = true);
|
||||
bool writeByte(uint16_t page_number, uint8_t offset, uint8_t data, bool errorCheck = true);
|
||||
uint8_t readByte(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
uint8_t readByte(uint32_t address, bool fastRead = false);
|
||||
//----------------------------------------Write / Read Byte Arrays----------------------------------------//
|
||||
bool writeByteArray(uint32_t address, uint8_t *data_buffer, uint16_t bufferSize, bool errorCheck = true);
|
||||
bool writeByteArray(uint16_t page_number, uint8_t offset, uint8_t *data_buffer, uint16_t bufferSize, bool errorCheck = true);
|
||||
uint8_t readByteArray(uint32_t address, uint8_t *data_buffer, uint16_t bufferSize, bool fastRead = false);
|
||||
uint8_t readByteArray(uint16_t page_number, uint8_t offset, uint8_t *data_buffer, uint16_t bufferSize, bool fastRead = false);
|
||||
//-------------------------------------------Write / Read Chars-------------------------------------------//
|
||||
bool writeChar(uint32_t address, int8_t data, bool errorCheck = true);
|
||||
bool writeChar(uint16_t page_number, uint8_t offset, int8_t data, bool errorCheck = true);
|
||||
int8_t readChar(uint32_t address, bool fastRead = false);
|
||||
int8_t readChar(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
//----------------------------------------Write / Read Char Arrays----------------------------------------//
|
||||
bool writeCharArray(uint32_t address, char *data_buffer, uint16_t bufferSize, bool errorCheck = true);
|
||||
bool writeCharArray(uint16_t page_number, uint8_t offset, char *data_buffer, uint16_t bufferSize, bool errorCheck = true);
|
||||
uint8_t readCharArray(uint32_t address, char *data_buffer, uint16_t buffer_size, bool fastRead = false);
|
||||
uint8_t readCharArray(uint16_t page_number, uint8_t offset, char *data_buffer, uint16_t buffer_size, bool fastRead = false);
|
||||
//------------------------------------------Write / Read Shorts------------------------------------------//
|
||||
bool writeShort(uint32_t address, int16_t data, bool errorCheck = true);
|
||||
bool writeShort(uint16_t page_number, uint8_t offset, int16_t data, bool errorCheck = true);
|
||||
int16_t readShort(uint32_t address, bool fastRead = false);
|
||||
int16_t readShort(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
//-------------------------------------------Write / Read Words-------------------------------------------//
|
||||
bool writeWord(uint32_t address, uint16_t data, bool errorCheck = true);
|
||||
bool writeWord(uint16_t page_number, uint8_t offset, uint16_t data, bool errorCheck = true);
|
||||
uint16_t readWord(uint32_t address, bool fastRead = false);
|
||||
uint16_t readWord(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
//-------------------------------------------Write / Read Longs-------------------------------------------//
|
||||
bool writeLong(uint32_t address, int32_t data, bool errorCheck = true);
|
||||
bool writeLong(uint16_t page_number, uint8_t offset, int32_t data, bool errorCheck = true);
|
||||
int32_t readLong(uint32_t address, bool fastRead = false);
|
||||
int32_t readLong(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
//--------------------------------------Write / Read Unsigned Longs---------------------------------------//
|
||||
bool writeULong(uint32_t address, uint32_t data, bool errorCheck = true);
|
||||
bool writeULong(uint16_t page_number, uint8_t offset, uint32_t data, bool errorCheck = true);
|
||||
uint32_t readULong(uint32_t address, bool fastRead = false);
|
||||
uint32_t readULong(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
//-------------------------------------------Write / Read Floats------------------------------------------//
|
||||
bool writeFloat(uint32_t address, float data, bool errorCheck = true);
|
||||
bool writeFloat(uint16_t page_number, uint8_t offset, float data, bool errorCheck = true);
|
||||
float readFloat(uint32_t address, bool fastRead = false);
|
||||
float readFloat(uint16_t page_number, uint8_t offset, bool fastRead = false);
|
||||
//------------------------------------------Write / Read Strings------------------------------------------//
|
||||
bool writeStr(uint32_t address, String &inputStr, bool errorCheck = true);
|
||||
bool writeStr(uint16_t page_number, uint8_t offset, String &inputStr, bool errorCheck = true);
|
||||
bool readStr(uint32_t address, String &outStr, bool fastRead = false);
|
||||
bool readStr(uint16_t page_number, uint8_t offset, String &outStr, bool fastRead = false);
|
||||
//-------------------------------------------Write / Read Pages-------------------------------------------//
|
||||
bool writePage(uint16_t page_number, uint8_t *data_buffer, bool errorCheck = true);
|
||||
bool readPage(uint16_t page_number, uint8_t *data_buffer, bool fastRead = false);
|
||||
//------------------------------------------Write / Read Anything-----------------------------------------//
|
||||
template <class T> bool writeAnything(uint32_t address, const T& value, bool errorCheck = true);
|
||||
template <class T> bool writeAnything(uint16_t page_number, uint8_t offset, const T& value, bool errorCheck = true);
|
||||
template <class T> bool readAnything(uint32_t address, T& value, bool fastRead = false);
|
||||
template <class T> bool readAnything(uint16_t page_number, uint8_t offset, T& value, bool fastRead = false);
|
||||
//--------------------------------------------Erase functions---------------------------------------------//
|
||||
bool eraseSector(uint32_t address);
|
||||
bool eraseSector(uint16_t page_number, uint8_t offset);
|
||||
bool eraseBlock32K(uint32_t address);
|
||||
bool eraseBlock32K(uint16_t page_number, uint8_t offset);
|
||||
bool eraseBlock64K(uint32_t address);
|
||||
bool eraseBlock64K(uint16_t page_number, uint8_t offset);
|
||||
bool eraseChip(void);
|
||||
//---------------------------------------------Power functions--------------------------------------------//
|
||||
bool suspendProg(void);
|
||||
bool resumeProg(void);
|
||||
bool powerDown(void);
|
||||
bool powerUp(void);
|
||||
//--------------------------------------------Private functions-------------------------------------------//
|
||||
private:
|
||||
void _troubleshoot(uint8_t error);
|
||||
void _cmd(uint8_t cmd, bool _continue = true, uint8_t cs = 0);
|
||||
void _endProcess(void);
|
||||
void _errorCodeCheck(void);
|
||||
void _beginRead(uint32_t address);
|
||||
void _beginFastRead(uint32_t address);
|
||||
bool _noSuspend(void);
|
||||
bool _notBusy(uint32_t timeout = 10L);
|
||||
bool _notPrevWritten(uint32_t address, uint8_t size = 1);
|
||||
bool _addressCheck(uint32_t address);
|
||||
bool _beginWrite(uint32_t address);
|
||||
bool _writeNextByte(uint8_t c, bool _continue = true);
|
||||
bool _writeEnable(void);
|
||||
bool _writeDisable(void);
|
||||
bool _getJedecId(uint8_t *b1, uint8_t *b2, uint8_t *b3);
|
||||
bool _getManId(uint8_t *b1, uint8_t *b2);
|
||||
bool _chipID(void);
|
||||
uint8_t _readStat1(void);
|
||||
uint8_t _readNextByte(bool _continue = true);
|
||||
uint32_t _getAddress(uint16_t page_number, uint8_t offset = 0);
|
||||
uint32_t _prepRead(uint32_t address);
|
||||
uint32_t _prepRead(uint16_t page_number, uint8_t offset = 0);
|
||||
uint32_t _prepWrite(uint32_t address);
|
||||
uint32_t _prepWrite(uint16_t page_number, uint8_t offset = 0);
|
||||
template <class T> bool _writeErrorCheck(uint32_t address, const T& value);
|
||||
//-------------------------------------------Private variables------------------------------------------//
|
||||
bool pageOverflow;
|
||||
volatile uint8_t *cs_port;
|
||||
uint8_t cs_mask, csPin, errorcode;
|
||||
uint16_t name;
|
||||
uint32_t capacity, maxPage;
|
||||
uint32_t currentAddress = 1;
|
||||
const uint8_t devType[10] = {0x5, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17};
|
||||
const uint32_t memSize[10] = {64L * 1024L, 128L * 1024L, 256L * 1024L, 512L * 1024L, 1L * 1024L * 1024L,
|
||||
2L * 1024L * 1024L, 4L * 1024L * 1024L, 8L * 1024L * 1024L, 16L * 1024L * 1024L};
|
||||
const uint16_t chipName[10] = {05, 10, 20, 40, 80, 16, 32, 64, 128, 256};
|
||||
};
|
||||
|
||||
|
||||
//--------------------------------------------Templates-------------------------------------------//
|
||||
|
||||
// Writes any type of data to a specific location in the flash memory.
|
||||
// Has two variants:
|
||||
// A. Takes two arguments -
|
||||
// 1. address --> Any address from 0 to maxAddress
|
||||
// 2. T& value --> Variable to return data into
|
||||
// 4. errorCheck --> Turned on by default. Checks for writing errors
|
||||
// B. Takes three arguments -
|
||||
// 1. page --> Any page number from 0 to maxPage
|
||||
// 2. offset --> Any offset within the page - from 0 to 255
|
||||
// 3. const T& value --> Variable with the data to be written
|
||||
// 4. errorCheck --> Turned on by default. Checks for writing errors
|
||||
// WARNING: You can only write to previously erased memory locations (see datasheet).
|
||||
// Use the eraseSector()/eraseBlock32K/eraseBlock64K commands to first clear memory (write 0xFFs)
|
||||
// Variant A
|
||||
template <class T> bool SPIFlash::writeAnything(uint32_t address, const T& value, bool errorCheck) {
|
||||
if (!_prepWrite(address))
|
||||
return false;
|
||||
else {
|
||||
const byte* p = (const byte*)(const void*)&value;
|
||||
_beginWrite(address);
|
||||
for (uint16_t i = 0; i < sizeof(value); i++) {
|
||||
#if defined (__arm__) && defined (__SAM3X8E__)
|
||||
if (i == sizeof(value)-1)
|
||||
_writeNextByte(*p++, false);
|
||||
#endif
|
||||
_writeNextByte(*p++);
|
||||
}
|
||||
_endProcess();
|
||||
}
|
||||
|
||||
if (!errorCheck)
|
||||
return true;
|
||||
else
|
||||
return _writeErrorCheck(address, value);
|
||||
}
|
||||
// Variant B
|
||||
template <class T> bool SPIFlash::writeAnything(uint16_t page_number, uint8_t offset, const T& value, bool errorCheck) {
|
||||
uint32_t address = _getAddress(page_number, offset);
|
||||
return writeAnything(address, value, errorCheck);
|
||||
}
|
||||
|
||||
// Reads any type of data from a specific location in the flash memory.
|
||||
// Has two variants:
|
||||
// A. Takes two arguments -
|
||||
// 1. address --> Any address from 0 to maxAddress
|
||||
// 2. T& value --> Variable to return data into
|
||||
// 2. fastRead --> defaults to false - executes _beginFastRead() if set to true
|
||||
// B. Takes three arguments -
|
||||
// 1. page --> Any page number from 0 to maxPage
|
||||
// 2. offset --> Any offset within the page - from 0 to 255
|
||||
// 3. T& value --> Variable to return data into
|
||||
// 3. fastRead --> defaults to false - executes _beginFastRead() if set to true
|
||||
// Variant A
|
||||
template <class T> bool SPIFlash::readAnything(uint32_t address, T& value, bool fastRead) {
|
||||
if (!_prepRead(address))
|
||||
return false;
|
||||
|
||||
byte* p = (byte*)(void*)&value;
|
||||
if(!fastRead)
|
||||
_beginRead(address);
|
||||
else
|
||||
_beginFastRead(address);
|
||||
for (uint16_t i = 0; i < sizeof(value); i++) {
|
||||
#if defined (__arm__) && defined (__SAM3X8E__)
|
||||
if (i == sizeof(value)-1)
|
||||
*p++ = _readNextByte(false);
|
||||
#endif
|
||||
*p++ =_readNextByte();
|
||||
}
|
||||
_endProcess();
|
||||
return true;
|
||||
}
|
||||
// Variant B
|
||||
template <class T> bool SPIFlash::readAnything(uint16_t page_number, uint8_t offset, T& value, bool fastRead)
|
||||
{
|
||||
uint32_t address = _getAddress(page_number, offset);
|
||||
return readAnything(address, value, fastRead);
|
||||
}
|
||||
|
||||
// Private template to check for errors in writing to flash memory
|
||||
template <class T> bool SPIFlash::_writeErrorCheck(uint32_t address, const T& value) {
|
||||
if (!_prepRead(address))
|
||||
return false;
|
||||
|
||||
const byte* p = (const byte*)(const void*)&value;
|
||||
_beginRead(address);
|
||||
for(uint16_t i = 0; i < sizeof(value);i++)
|
||||
{
|
||||
#if defined (__arm__) && defined (__SAM3X8E__)
|
||||
if (i == sizeof(value)-1) {
|
||||
if (*p++ != _readNextByte(false))
|
||||
return false;
|
||||
else
|
||||
return true;
|
||||
}
|
||||
else
|
||||
if (*p++ != _readNextByte())
|
||||
return false;
|
||||
#elif defined (__AVR__)
|
||||
if (*p++ != _readNextByte())
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
_endProcess();
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
#endif // _SPIFLASH_H_
|
||||
1
tools/olimexino-32u4 firmware/src/iceprog.cpp
Symbolic link
1
tools/olimexino-32u4 firmware/src/iceprog.cpp
Symbolic link
@@ -0,0 +1 @@
|
||||
../iceprog.ino
|
||||
Reference in New Issue
Block a user