Try this:
PROGMEM const char lorem[]="Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.";
volatile char x;
void setup() {
while(!Serial);
delay(10);
unsigned long t = ARM_DWT_CYCCNT;
for (int i = 0; i < 20; i+=1) x = lorem[i*8];
t = ARM_DWT_CYCCNT - t;
Serial.println(t);
Serial.println(x);
}
void loop() {}
Try this:
...
Not sure if the optimization plays a role - I used "fast". You'll see >250 Cycles difference (60Mhz vs. 133Mhz) for these RANDOM reads
Edit: it is a littly tricky to get around the cache AND the gcc optimization... therefore the funny loop.
T:\tCode\Memory\FlashMemSpeed\FlashMemSpeed.ino Dec 30 2020 12:56:41
1416
u
T:\tCode\Memory\FlashMemSpeed\FlashMemSpeed.ino Dec 30 2020 13:00:54
1676
uPROGMEM const char [B]lorem[592][/B] = "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.";
volatile char x;
void setup() {
while (!Serial && millis() < 4000 );
Serial.println("\n" __FILE__ " " __DATE__ " " __TIME__);
delay(10);
unsigned long t = ARM_DWT_CYCCNT;
for (int i = 0; i < 20; i += 1) x = [B]lorem[591-(i * 8)][/B];
t = ARM_DWT_CYCCNT - t;
Serial.println(t);
Serial.println(x);
}
void loop() {}T:\tCode\Memory\FlashMemSpeed\FlashMemSpeed.ino Dec 30 2020 13:02:47
2986
m
T:\tCode\Memory\FlashMemSpeed\FlashMemSpeed.ino Dec 30 2020 13:03:11
2627
mT:\tCode\Memory\FlashMemSpeed\FlashMemSpeed.ino Dec 30 2020 13:08:11
6026
32
T:\tCode\Memory\FlashMemSpeed\FlashMemSpeed.ino Dec 30 2020 13:08:35
6897
32Yes, in this case the GCC optimization kicks in, removes the loop, and does not even read the array. It loads "x" with the corresponding values, directly - without reading them from the flash..
CoreMark 1.0 : 2382.09 / GCC10.2.1 20201103 (release) (flags unknown) / STACK greiman commented on Nov 23, 2020 •
I will provide these functions in the next release:
bool getAccessDateTime( uint16_t * pdate, uint16_t * ptime );
bool getCreateDateTime( uint16_t * pdate, uint16_t * ptime );
bool getModifyDateTime( uint16_t * pdate, uint16_t * ptime );
FAT32/FAT16 only has access date so I will return zero for time. uint8_t *p = nullptr;
*p = 5;Hardfault.
Return Address: 0x16A
(DACCVIOL) Data Access Violation
(MMARVALID) Accessed Address: 0x0 ([COLOR=#ff0000]nullptr)[/COLOR]Hardfault.
Return Address: 0x14A0
(DACCVIOL) Data Access Violation
(MMARVALID) Accessed Address: 0x200032C8 [COLOR=#ff0000](Stack problem)
Check for stack overflows, array bounds, etc.[/COLOR] NVIC_ENABLE_IRQ(IRQ_Reserved5);
NVIC_STIR = IRQ_Reserved5;Fault.
Unused ISR No. 128 called#ifndef SHOW_HARDFAULTS
#define SHOW_HARDFAULTS 1
#endif
#ifndef HARDFAULTSOUT
#define HARDFAULTSOUT Serial
#endif
No more silent passing away... (in most cases)
#if defined(HAS_KINETIS_SDHC)I just saw that - if no DMA channel is available, Teensy just hardfaults.
If there was a intention to put the hardfault handling into the core, i'd try to add something like printing an errormessage for problems like this
extern SDClass SD;class SDClass : public FS
{
public:
SDClass() { }
bool begin(uint8_t csPin = 10) {
#ifdef BUILTIN_SDCARD
if (csPin == BUILTIN_SDCARD) {
return sdfs.begin(SdioConfig(FIFO_SDIO));
//return sdfs.begin(SdioConfig(DMA_SDIO));
}
#endif
return sdfs.begin(SdSpiConfig(csPin, SHARED_SPI, SD_SCK_MHZ(16)));
//return sdfs.begin(csPin, SD_SCK_MHZ(24));
}
File open(const char *filepath, uint8_t mode = FILE_READ) {
oflag_t flags = O_READ;
if (mode == FILE_WRITE) flags = O_RDWR | O_CREAT | O_AT_END;
else if (mode == FILE_WRITE_BEGIN) flags = O_RDWR | O_CREAT;
SDFAT_FILE file = sdfs.open(filepath, flags);
if (file) return File(new SDFile(file));
return File();
}
bool exists(const char *filepath) {
return sdfs.exists(filepath);
}
bool mkdir(const char *filepath) {
return sdfs.mkdir(filepath);
}
bool rename(const char *oldfilepath, const char *newfilepath) {
return sdfs.rename(oldfilepath, newfilepath);
}
bool remove(const char *filepath) {
return sdfs.remove(filepath);
}
bool rmdir(const char *filepath) {
return sdfs.rmdir(filepath);
}
uint64_t usedSize() {
return (uint64_t)(sdfs.clusterCount() - sdfs.freeClusterCount())
* (uint64_t)sdfs.bytesPerCluster();
}
uint64_t totalSize() {
return (uint64_t)sdfs.clusterCount() * (uint64_t)sdfs.bytesPerCluster();
}
public: // allow access, so users can mix SD & SdFat APIs
SDFAT_BASE sdfs;
};
extern SDClass SD;class LittleFS : public FS
{
public:
LittleFS() {
configured = false;
mounted = false;
config.context = nullptr;
}
bool quickFormat();
bool lowLevelFormat(char progressChar=0);
uint32_t formatUnused(uint32_t blockCnt, uint32_t blockStart);
File open(const char *filepath, uint8_t mode = FILE_READ) {
//Serial.println("LittleFS open");
if (!mounted) return File();
if (mode == FILE_READ) {
struct lfs_info info;
if (lfs_stat(&lfs, filepath, &info) < 0) return File();
//Serial.printf("LittleFS open got info, name=%s\n", info.name);
if (info.type == LFS_TYPE_REG) {
//Serial.println(" regular file");
lfs_file_t *file = (lfs_file_t *)malloc(sizeof(lfs_file_t));
if (!file) return File();
if (lfs_file_open(&lfs, file, filepath, LFS_O_RDONLY) >= 0) {
return File(new LittleFSFile(&lfs, file, filepath));
}
free(file);
} else { // LFS_TYPE_DIR
//Serial.println(" directory");
lfs_dir_t *dir = (lfs_dir_t *)malloc(sizeof(lfs_dir_t));
if (!dir) return File();
if (lfs_dir_open(&lfs, dir, filepath) >= 0) {
return File(new LittleFSFile(&lfs, dir, filepath));
}
free(dir);
}
} else {
lfs_file_t *file = (lfs_file_t *)malloc(sizeof(lfs_file_t));
if (!file) return File();
if (lfs_file_open(&lfs, file, filepath, LFS_O_RDWR | LFS_O_CREAT) >= 0) {
if (mode == FILE_WRITE) {
// FILE_WRITE opens at end of file
lfs_file_seek(&lfs, file, 0, LFS_SEEK_END);
} // else FILE_WRITE_BEGIN
return File(new LittleFSFile(&lfs, file, filepath));
}
}
return File();
}
bool exists(const char *filepath) {
if (!mounted) return false;
struct lfs_info info;
if (lfs_stat(&lfs, filepath, &info) < 0) return false;
return true;
}
bool mkdir(const char *filepath) {
if (!mounted) return false;
if (lfs_mkdir(&lfs, filepath) < 0) return false;
return true;
}
bool rename(const char *oldfilepath, const char *newfilepath) {
if (!mounted) return false;
if (lfs_rename(&lfs, oldfilepath, newfilepath) < 0) return false;
return true;
}
bool remove(const char *filepath) {
if (!mounted) return false;
if (lfs_remove(&lfs, filepath) < 0) return false;
return true;
}
bool rmdir(const char *filepath) {
return remove(filepath);
}
uint64_t usedSize() {
if (!mounted) return 0;
int blocks = lfs_fs_size(&lfs);
if (blocks < 0 || (lfs_size_t)blocks > config.block_count) return totalSize();
return blocks * config.block_size;
}
uint64_t totalSize() {
if (!mounted) return 0;
return config.block_count * config.block_size;
}
protected:
bool configured;
bool mounted;
lfs_t lfs;
lfs_config config;
};LittleFS_SPIFlash FLASH;