[solved]Timer functions do not load into IRAM

[danieldecesaro]

Hey guys,

I have the following problem: I need to trigger a timer interrupt every 250us, and in this interrupt I check an IO pin (in this example I am also triggering it so I can monitor it) and I also increment a counter depending on the state of this IO. In version 1.0.6 this worked properly, but in newer versions (I identified this from 2.0.6 onwards), this does not occur as it should.
 The problem occurs because the firmware also works with files using LITTLEFS and when Flash memory is being used to record these files the timer is not activated.
 I believe that in newer versions the IO instructions or even the timer function are not being loaded into IRAM, despite the "IRAM_ATTR" directive being added to the interrupt function.
How can I get these instructions loaded into IRAM so that everything works properly?

I currently use version 2.0.14. In this version, the timer stops, as seen in image 1.

In the same code compiled in version 1.0.6, this does not occur, as shown in image 2.

Same image with more time

Below is code for analysis

#include "Arduino.h"
#include "FS.h"
//#include "SPIFFS.h"
#include "LITTLEFS.h"

#define SPIFFS LITTLEFS
#define FORMAT_LITTLEFS_IF_FAILED true

#define CONFIG_ARDUINO_ISR_IRAM 1
#define CONFIG_GPTIMER_ISR_HANDLER_IN_IRAM 1
#define CONFIG_GPTIMER_CTRL_FUNC_IN_IRAM 1
#define CONFIG_GPTIMER_ISR_IRAM_SAFE 1
#define CONFIG_GPIO_CTRL_FUNC_IN_IRAM 1

hw_timer_t *timer = NULL;

portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

/****
 * Here's the problem
 */
void IRAM_ATTR onTimer() {
  digitalWrite(4, !digitalRead(4));
}

void createDir(fs::FS &fs, const char *path) {
	Serial.printf("Creating Dir: %s\n", path);
	if (fs.mkdir(path)) {
		Serial.println("Dir created");
	} else {
		Serial.println("mkdir failed");
	}
}

void removeDir(fs::FS &fs, const char *path) {
	Serial.printf("Removing Dir: %s\n", path);
	if (fs.rmdir(path)) {
		Serial.println("Dir removed");
	} else {
		Serial.println("rmdir failed");
	}
}

void readFile(fs::FS &fs, const char *path) {
	Serial.printf("Reading file: %s\n", path);

	File file = fs.open(path);
	if (!file) {
		Serial.println("Failed to open file for reading");
		return;
	}

	Serial.print("Read from file: ");
	while (file.available()) {
		Serial.write(file.read());
	}
	file.close();
}

void writeFile(fs::FS &fs, const char *path, const char *message) {
	Serial.printf("Writing file: %s\n", path);

	File file = fs.open(path, FILE_WRITE);
	if (!file) {
		Serial.println("Failed to open file for writing");
		return;
	}
	if (file.print(message)) {
		Serial.println("File written");
	} else {
		Serial.println("Write failed");
	}
	file.close();
}

void appendFile(fs::FS &fs, const char *path, const char *message) {
	Serial.printf("Appending to file: %s\n", path);

	File file = fs.open(path, FILE_APPEND);
	if (!file) {
		Serial.println("Failed to open file for appending");
		return;
	}
	if (file.print(message)) {
		Serial.println("Message appended");
	} else {
		Serial.println("Append failed");
	}
	file.close();
}

void renameFile(fs::FS &fs, const char *path1, const char *path2) {
	Serial.printf("Renaming file %s to %s\n", path1, path2);
	if (fs.rename(path1, path2)) {
		Serial.println("File renamed");
	} else {
		Serial.println("Rename failed");
	}
}

void deleteFile(fs::FS &fs, const char *path) {
	Serial.printf("Deleting file: %s\n", path);
	if (fs.remove(path)) {
		Serial.println("File deleted");
	} else {
		Serial.println("Delete failed");
	}
}

void setup() {
	Serial.begin(115200);

	pinMode(4, OUTPUT);

	timer = timerBegin(0, 80, true);
	timerAttachInterrupt(timer, &onTimer, true);
	timerAlarmWrite(timer, 200, true);
	timerAlarmEnable(timer);

	if (!SPIFFS.begin(FORMAT_LITTLEFS_IF_FAILED)) {
		Serial.println("LITTLEFS Mount Failed");
		return;
	}

}

void loop() {
	static uint8_t count = 0;
	Serial.print('.');
	if (++count == 80) {
		Serial.println();
		count = 0;
	}

	Serial.println("----create the new again----");
	createDir(SPIFFS, "/mydir");

	for (uint8_t i = 0; i < 100; i++) {
		Serial.println("----create and work with file----");
		writeFile(SPIFFS, "/mydir/hello.txt", "Teste de Criação no arquivo");
		appendFile(SPIFFS, "/mydir/hello.txt", "Teste de inserção no arquivo!\n");
	}

	Serial.println("----remove dir after deleting file----");
	deleteFile(SPIFFS, "/mydir/hello.txt");
	removeDir(SPIFFS, "/mydir");
}

[me-no-dev]

Since you only need to check every 250ms, why not just spin a task and

void my250task(void *arg){
  for(;;){
    digitalWrite(4, !digitalRead(4)); //or whatever you want to do
    delay(250);
  }
}

No timers or interrupts needed and the timing will be fairly accurate

[me-no-dev]

cc @P-R-O-C-H-Y

[danieldecesaro]

Thanks @me-no-dev

I can't use your suggestion, I need to continue reading the IO while writing the files, that's why I need the interruption. For this reason I need the interrupt to be loaded into IRAM.

[me-no-dev]

If task is with sufficient priority, it should work just fine. In 2.x and on, interrupts do not run in IRAM anymore. That was causing too many issues with users. Timer should work just fine though. Maybe @P-R-O-C-H-Y will shed some light on what could be happening

[danieldecesaro]

@me-no-dev, even with the appropriate priority, this code will not work correctly, because when accessing Flash to write files it will not be executed. For this code to work, it must be in IRAM, as the ESP32 blocks code execution when flash (which is the same for codes and the file system) is used.

Is there any way to force these codes to be loaded into IRAM?

[me-no-dev]

Even without IRAM, the ISR will be serviced within a microsecond or so. Let's go back to the timer and wait for @P-R-O-C-H-Y to maybe explain why it stops running for you

[danieldecesaro]

Problem solved, I used direct calls to gpio.c functions as advised by @igrr in this issue:
espressif/esp-idf#2408