I am currently using a ESP32-S2 which got PSRAM. So I thought I could use that as a cache-storage for faster access compared to the Flash or SD-Memory.
I found that lib but I am not sure I it is the best lib for that since there are some problems with it. ( It would be great if I could use it like a filesystem)
Which is the best way to interact with PSRAM?
Well you'll only get 4MB from under the Arduino IDE as a note.
Here I use PSRAM as a serial receive buffer location
#include "esp32-hal-psram.h"
void fReceiveSerial_LIDAR( void * parameters )
{
char OneChar;
char *str;
str = (char *)ps_calloc(300, sizeof(char) ); // put str buffer into PSRAM
bool BeginSentence = false;
sSerial.reserve ( StringBufferSize300 );
for ( ;; )
{
EventBits_t xbit = xEventGroupWaitBits (eg, evtReceiveSerial_LIDAR, pdTRUE, pdTRUE, portMAX_DELAY);
if ( LIDARSerial.available() >= 1 )
{
while ( LIDARSerial.available() )
{
OneChar = LIDARSerial.read();
if ( BeginSentence )
{
if ( OneChar == ‘>’)
{
if ( xSemaphoreTake( sema_ParseLIDAR_ReceivedSerial, xSemaphoreTicksToWait10 ) == pdTRUE )
{
xQueueOverwrite( xQ_LIDAR_Display_INFO, ( void * ) &sSerial );
xEventGroupSetBits( eg, evtParseLIDAR_ReceivedSerial );
//
}
BeginSentence = false;
break;
}
sSerial.concat ( OneChar );
}
else
{
if ( OneChar == ‘<’ )
{
sSerial = “”; // clear string buffer
BeginSentence = true; // found begining of sentence
}
}
} // while ( LIDARSerial.available() )
} //if ( LIDARSerial.available() >= 1 )
xSemaphoreGive( sema_ReceiveSerial_LIDAR );
}
vTaskDelete( NULL );
} //void fReceiveSerial_LIDAR( void * parameters )
here is a copy of my experimentations using PSRAM under the Arduino IDE.
//#include "sdkconfig.h" //
//#include "freertos/FreeRTOS.h"
//#include "freertos/task.h"
//#include "freertos/queue.h"
//#include "esp_system.h" //This inclusion configures the peripherals in the ESP system.
#include "esp32-hal-psram.h"
#include "esp_himem.h"
// #include "esp_spiram.h"
// #include "rom/cache.h"
extern "C"
{
//#include <esp_himem.h>
#include <esp_spiram.h>
}
//#include <esp_himem.h>
////
const int SerialDataBits = 115200;
////
struct stuTime
{
int iSeconds = 0;
int iMinutes = 0;
int iHours = 0;
};
////
void setup()
{
// Serial.begin(115200);
//
// Serial.println("========================================");
// Serial.printf("PSRAM total size : %u \n", esp_spiram_get_size());
// Serial.println("----------------------------------------");
// Serial.printf("PSRAM first 4MB size : %u \n", ESP.getPsramSize());
// Serial.printf("PSRAM first 4MB free : %u \n", ESP.getMaxAllocPsram());
// Serial.printf("PSRAM HI-MEM size : %u \n", esp_himem_get_phys_size());
// Serial.printf("PSRAM HI-MEM free : %u \n", esp_himem_get_free_size());
// Serial.println("========================================");
// Serial.printf("Internal RAM size : %u \n", ESP.getHeapSize());
// Serial.printf("Internal RAM free : %u \n", ESP.getFreeHeap());
// Serial.println("========================================");
//
// Serial.println("Testing the free memory of PSRAM HI-MEM ...");
// test_region(esp_himem_get_free_size(), 0xaaaa);
// Serial.println("Done!");
////////////////////////////////////////////////////////////////////////////////
esp_spiram_init();
vTaskDelay(1);
// esp_himem_handle_t mh; //Handle for the address space we're using
// esp_himem_rangehandle_t rh; //Handle for the actual RAM.
// esp_himem_alloc( 1024, &mh);
// Serial.begin( SerialDataBits );
// psramInit();
// vTaskDelay(3);
// esp_spiram_init();
// vTaskDelay(1);
// log_i("Total heap: %u", ESP.getHeapSize());
// log_i("Free heap: %u", ESP.getFreeHeap());
// log_i("Total PSRAM: %u", ESP.getPsramSize());
// log_i("Free PSRAM: %d", ESP.getFreePsram());
// log_i("spiram size %u", esp_spiram_get_size());
// log_i("himem free %u", esp_himem_get_free_size());
// log_i("himem phys %u", esp_himem_get_phys_size());
// log_i("himem reserved %u", esp_himem_reserved_area_size());
//
// int *ptr, *ptr1;
// int n, n1, i, sum = 0;
// float *ptrFloat;
// // Get the number of elements for the array
// n = 10;
// n1 = 20;
// log_i("Number of elements ptr: %d", n);
// log_i("Number of elements ptr1: %d", n1);
// log_i("Number of elements ptr1: %d\n", n1);
// // Dynamically allocate memory using malloc()
// // ptr = (int*)ps_malloc(n * sizeof(int)); //works
// ptr = (int*)ps_calloc( n, sizeof(int) ); // works
// log_i("Free PSRAM: %d", ESP.getFreePsram());
// ptr1 = (int*)ps_calloc( n1, sizeof(int) ); // works
// log_i("Free PSRAM: %d", ESP.getFreePsram());
// // Check if the memory has been successfully
// // allocated in ps_ram
// ptrFloat = (float*)ps_calloc( n, sizeof(float) ); // works
// if (ptr == NULL) {
// log_i(" ptr memory not allocated.\n");
// exit(0);
// }
// if (ptr1 == NULL)
// {
// log_i("ptr1 memory not allocated.\n");
// exit(0);
// }
// else
// {
// // Memory has been successfully allocated
// // log_i("ps_ram memory successfully allocated using ps_calloc.");
// // put elements into ps_ram array
// for (i = 0; i < n; ++i)
// {
// ptr[i] = i + 1;
// }
// for (i = 0; i < n1; ++i)
// {
// ptr1[i] = i + 2;
// }
// for (i = 0; i < n; ++i)
// {
// ptrFloat[i] = (float)i + 1.06555f;
// }
// // Print the elements of the array
// log_i("The elements of the ptr array are: ");
// for (i = 0; i < n; ++i) {
// log_i("%d, ", ptr[i]);
// }
// log_i("The elements of the ptr1 array are: ");
// for (i = 0; i < n1; ++i) {
// log_i("%d, ", ptr1[i]);
// }
// log_i("The elements of the ptrFloat array are: ");
// for (i = 0; i < n1; ++i) {
// log_i("%f, ", ptrFloat[i]);
// }
// }
// //
// // put a structure into psram. Works.
// struct stuTime *ptrStuTime;
// log_i("size of structure: %d", sizeof(struct stuTime) );
// //
// ptrStuTime = (struct stuTime *)ps_malloc(sizeof(struct stuTime));
// log_i("Free PSRAM after structure: %d", ESP.getFreePsram());
// ptrStuTime->iSeconds = 10;
// ptrStuTime->iMinutes = 60;
// ptrStuTime->iHours = 100;
// log_i("Seconds: %d Minutes: %d Hours: %d", ptrStuTime->iSeconds, ptrStuTime->iMinutes, ptrStuTime->iHours );
// free(ptr);
// free(ptr1);
// free(ptrStuTime);
// // works
// log_i("Free PSRAM before String: %d", ESP.getFreePsram());
// char *str;
// char OneChar = 'a';
// char TwoChar = 'b';
// char ThreeChar = 'c';
// str = (char *)ps_calloc(300, sizeof(char) );
// log_i("Free PSRAM after String: %d", ESP.getFreePsram());
// // concantenate one char variable to end of char array to the str
// strncat( str, &OneChar, 1 ); //works
// strncat( str, &TwoChar, 1 );
// strncat( str, &ThreeChar, 1 );
// //
// //*(str+0) = 'G'; // works
// //*(str+1) = 'f';
// //*(str+2) = 'G';
// //*(str+3) = '\0';
// log_i("%s", str );
// free(str);
///////
//size_t memfree=esp_himem_get_free_size();
//log_i( "himemFree %d", memfree );
// int memcnt=esp_himem_get_phys_size();
// int memfree=esp_himem_get_free_size();
// log_i( "SpiRamPhysSize %d", memcnt );
// log_i( "SpiRamFree %d", memfree );
// esp_himem_get_phys_size(void)
// esp_himem_handle_t mh; //Handle for the address space we're using
// esp_himem_rangehandle_t rh; //Handle for the actual RAM.
// esp_err_t intError = esp_himem_alloc( 4095, &mh);
// log_i( "%s", esp_err_to_name( intError) );
// log_i("spiram size %u", esp_spiram_get_size());
// log_i( "Handle %d", mh );
} // setup()
////
/* possible adds to the config
#define CONFIG_ESP32_SPIRAM_SUPPORT 1
#define CONFIG_SPIRAM_BOOT_INIT 1
#define CONFIG_SPIRAM_IGNORE_NOTFOUND 0
#define CONFIG_SPIRAM_USE_MALLOC 1
#define CONFIG_SPIRAM_TYPE_AUTO 1
#define CONFIG_SPIRAM_SIZE -1
#define CONFIG_SPIRAM_SPEED_40M 1
#define CONFIG_SPIRAM_MEMTEST 1
#define CONFIG_SPIRAM_CACHE_WORKAROUND 1
#define CONFIG_SPIRAM_BANKSWITCH_ENABLE 1
#define CONFIG_SPIRAM_BANKSWITCH_RESERVE 4
*/
void loop() {}
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.