32 #include "esp_vfs_fat.h" 33 #include "esp_task_wdt.h" 34 #include "driver/sdspi_host.h" 35 #include "sdmmc_cmd.h" 36 #include "esp_spiffs.h" 37 #include "soc/efuse_reg.h" 57 : m_start(esp_timer_get_time())
62 bool TimeOut::expired(
int valueMS)
64 return valueMS > -1 && ((esp_timer_get_time() - m_start) / 1000) > valueMS;
77 int squaredbit = 0x40000000;
80 while (squaredbit > 0) {
81 if (remainder >= (squaredbit | root)) {
82 remainder -= (squaredbit | root);
97 bool calcParity(uint8_t v)
101 return (0x6996 >> v) & 1;
110 void * realloc32(
void * ptr,
size_t size)
112 uint32_t * newBuffer = (uint32_t*) heap_caps_malloc(size, MALLOC_CAP_32BIT);
114 moveItems(newBuffer, (uint32_t*)ptr, size /
sizeof(uint32_t));
121 void free32(
void * ptr)
131 uint32_t msToTicks(
int ms)
133 return ms < 0 ? portMAX_DELAY : pdMS_TO_TICKS(ms);
140 ChipPackage getChipPackage()
143 uint32_t ver_pkg = (REG_READ(EFUSE_BLK0_RDATA3_REG) >> 9) & 7;
146 return ChipPackage::ESP32D0WDQ6;
148 return ChipPackage::ESP32D0WDQ5;
150 return ChipPackage::ESP32D2WDQ5;
152 return ChipPackage::ESP32PICOD4;
154 return ChipPackage::Unknown;
160 adc1_channel_t ADC1_GPIO2Channel(gpio_num_t gpio)
163 case ADC1_CHANNEL_0_GPIO_NUM:
164 return ADC1_CHANNEL_0;
165 case ADC1_CHANNEL_1_GPIO_NUM:
166 return ADC1_CHANNEL_1;
167 case ADC1_CHANNEL_2_GPIO_NUM:
168 return ADC1_CHANNEL_2;
169 case ADC1_CHANNEL_3_GPIO_NUM:
170 return ADC1_CHANNEL_3;
171 case ADC1_CHANNEL_4_GPIO_NUM:
172 return ADC1_CHANNEL_4;
173 case ADC1_CHANNEL_5_GPIO_NUM:
174 return ADC1_CHANNEL_5;
175 case ADC1_CHANNEL_6_GPIO_NUM:
176 return ADC1_CHANNEL_6;
177 case ADC1_CHANNEL_7_GPIO_NUM:
178 return ADC1_CHANNEL_7;
180 return ADC1_CHANNEL_0;
187 void configureGPIO(gpio_num_t gpio, gpio_mode_t mode)
189 PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
190 gpio_set_direction(gpio, mode);
196 uint32_t getApbFrequency()
198 rtc_cpu_freq_config_t conf;
199 rtc_clk_cpu_freq_get_config(&conf);
200 return conf.freq_mhz >= 80 ? 80000000 : (conf.source_freq_mhz * 80000000 / conf.div);
206 uint32_t getCPUFrequencyMHz()
208 rtc_cpu_freq_config_t conf;
209 rtc_clk_cpu_freq_get_config(&conf);
210 return conf.freq_mhz;
217 struct esp_intr_alloc_args {
220 intr_handler_t handler;
222 intr_handle_t * ret_handle;
223 TaskHandle_t waitingTask;
226 void esp_intr_alloc_pinnedToCore_task(
void * arg)
228 auto args = (esp_intr_alloc_args*) arg;
229 esp_intr_alloc(args->source, args->flags, args->handler, args->arg, args->ret_handle);
230 xTaskNotifyGive(args->waitingTask);
234 void esp_intr_alloc_pinnedToCore(
int source,
int flags, intr_handler_t handler,
void * arg, intr_handle_t * ret_handle,
int core)
236 esp_intr_alloc_args args = { source, flags, handler, arg, ret_handle, xTaskGetCurrentTaskHandle() };
237 xTaskCreatePinnedToCore(esp_intr_alloc_pinnedToCore_task,
"" , 1024, &args, 3, NULL, core);
238 ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
246 void replacePathSep(
char * path,
char newSep)
248 for (; *path; ++path)
249 if (*path ==
'\\' || *path ==
'/')
258 static int clipLine_code(
int x,
int y, Rect
const & clipRect)
263 else if (x > clipRect.X2)
267 else if (y > clipRect.Y2)
274 bool clipLine(
int & x1,
int & y1,
int & x2,
int & y2, Rect
const & clipRect,
bool checkOnly)
280 int topLeftCode = clipLine_code(newX1, newY1, clipRect);
281 int bottomRightCode = clipLine_code(newX2, newY2, clipRect);
283 if ((topLeftCode == 0) && (bottomRightCode == 0)) {
291 }
else if (topLeftCode & bottomRightCode) {
295 int ncode = topLeftCode != 0 ? topLeftCode : bottomRightCode;
297 x = newX1 + (newX2 - newX1) * (clipRect.Y2 - newY1) / (newY2 - newY1);
299 }
else if (ncode & 4) {
300 x = newX1 + (newX2 - newX1) * (clipRect.Y1 - newY1) / (newY2 - newY1);
302 }
else if (ncode & 2) {
303 y = newY1 + (newY2 - newY1) * (clipRect.X2 - newX1) / (newX2 - newX1);
305 }
else if (ncode & 1) {
306 y = newY1 + (newY2 - newY1) * (clipRect.X1 - newX1) / (newX2 - newX1);
309 if (ncode == topLeftCode) {
312 topLeftCode = clipLine_code(newX1, newY1, clipRect);
316 bottomRightCode = clipLine_code(newX2, newY2, clipRect);
328 void removeRectangle(Stack<Rect> & rects, Rect
const & mainRect, Rect
const & rectToRemove)
330 if (!mainRect.intersects(rectToRemove) || rectToRemove.contains(mainRect))
334 if (mainRect.Y1 < rectToRemove.Y1)
335 rects.push(Rect(mainRect.X1, mainRect.Y1, mainRect.X2, rectToRemove.Y1 - 1));
338 if (mainRect.Y2 > rectToRemove.Y2)
339 rects.push(Rect(mainRect.X1, rectToRemove.Y2 + 1, mainRect.X2, mainRect.Y2));
342 if (mainRect.X1 < rectToRemove.X1)
343 rects.push(Rect(mainRect.X1, tmax(rectToRemove.Y1, mainRect.Y1), rectToRemove.X1 - 1, tmin(rectToRemove.Y2, mainRect.Y2)));
346 if (mainRect.X2 > rectToRemove.X2)
347 rects.push(Rect(rectToRemove.X2 + 1, tmax(rectToRemove.Y1, mainRect.Y1), mainRect.X2, tmin(rectToRemove.Y2, mainRect.Y2)));
354 Rect IRAM_ATTR Rect::merge(Rect
const & rect)
const 356 return Rect(imin(rect.X1,
X1), imin(rect.Y1,
Y1), imax(rect.X2,
X2), imax(rect.Y2,
Y2));
360 Rect IRAM_ATTR Rect::intersection(Rect
const & rect)
const 362 return Rect(tmax(
X1, rect.X1), tmax(
Y1, rect.Y1), tmin(
X2, rect.X2), tmin(
Y2, rect.Y2));
369 void rgb222_to_hsv(
int R,
int G,
int B,
double * h,
double * s,
double * v)
374 double cmax = tmax<double>(tmax<double>(r, g), b);
375 double cmin = tmin<double>(tmin<double>(r, g), b);
376 double diff = cmax - cmin;
380 *h = fmod((60.0 * ((g - b) / diff) + 360.0), 360.0);
382 *h = fmod((60.0 * ((b - r) / diff) + 120.0), 360.0);
384 *h = fmod((60.0 * ((r - g) / diff) + 240.0), 360.0);
385 *s = cmax == 0 ? 0 : (diff / cmax) * 100.0;
395 StringList::StringList()
405 StringList::~StringList()
411 void StringList::clear()
414 for (
int i = 0; i < m_count; ++i)
415 free((
void*) m_items[i]);
421 m_count = m_allocated = 0;
425 void StringList::copyFrom(StringList
const & src)
428 m_count = src.m_count;
429 checkAllocatedSpace(m_count);
430 for (
int i = 0; i < m_count; ++i) {
431 m_items[i] =
nullptr;
432 set(i, src.m_items[i]);
438 void StringList::checkAllocatedSpace(
int requiredItems)
440 if (m_allocated < requiredItems) {
441 if (m_allocated == 0) {
443 m_allocated = requiredItems;
446 while (m_allocated < requiredItems)
449 m_items = (
char const**) realloc32(m_items, m_allocated *
sizeof(
char const *));
450 m_selMap = (uint32_t*) realloc32(m_selMap, (31 + m_allocated) / 32 *
sizeof(uint32_t));
455 void StringList::insert(
int index,
char const * str)
458 checkAllocatedSpace(m_count);
459 moveItems(m_items + index + 1, m_items + index, m_count - index - 1);
460 m_items[index] =
nullptr;
466 int StringList::append(
char const * str)
468 insert(m_count, str);
473 int StringList::appendFmt(
const char *format, ...)
477 va_start(ap, format);
478 int size = vsnprintf(
nullptr, 0, format, ap) + 1;
481 va_start(ap, format);
483 vsnprintf(buf, size, format, ap);
484 insert(m_count, buf);
491 void StringList::append(
char const * strlist[],
int count)
493 for (
int i = 0; i < count; ++i)
494 insert(m_count, strlist[i]);
498 void StringList::set(
int index,
char const * str)
501 free((
void*)m_items[index]);
502 m_items[index] = (
char const*) malloc(strlen(str) + 1);
503 strcpy((
char*)m_items[index], str);
505 m_items[index] = str;
510 void StringList::remove(
int index)
513 free((
void*)m_items[index]);
514 moveItems(m_items + index, m_items + index + 1, m_count - index - 1);
520 void StringList::takeStrings()
525 for (
int i = 0; i < m_count; ++i) {
526 char const * str = m_items[i];
527 m_items[i] =
nullptr;
534 void StringList::deselectAll()
536 for (
int i = 0; i < (31 + m_count) / 32; ++i)
541 bool StringList::selected(
int index)
543 return m_selMap[index / 32] & (1 << (index % 32));
547 void StringList::select(
int index,
bool value)
550 m_selMap[index / 32] |= 1 << (index % 32);
552 m_selMap[index / 32] &= ~(1 << (index % 32));
566 char const * FileBrowser::s_SPIFFSMountPath;
567 bool FileBrowser::s_SPIFFSMounted =
false;
568 size_t FileBrowser::s_SPIFFSMaxFiles;
570 char const * FileBrowser::s_SDCardMountPath;
571 bool FileBrowser::s_SDCardMounted =
false;
572 size_t FileBrowser::s_SDCardMaxFiles;
573 int FileBrowser::s_SDCardAllocationUnitSize;
574 int8_t FileBrowser::s_SDCardMISO;
575 int8_t FileBrowser::s_SDCardMOSI;
576 int8_t FileBrowser::s_SDCardCLK;
577 int8_t FileBrowser::s_SDCardCS;
581 FileBrowser::FileBrowser()
586 m_includeHiddenFiles(false),
587 m_namesStorage(nullptr)
592 FileBrowser::~FileBrowser()
601 void FileBrowser::clear()
606 free(m_namesStorage);
607 m_namesStorage =
nullptr;
616 if (m_dir ==
nullptr || strcmp(path, m_dir) != 0) {
618 m_dir = strdup(path);
629 if (!m_dir || strlen(subdir) == 0)
631 if (strcmp(subdir,
"..") == 0) {
633 auto lastSlash = strrchr(m_dir,
'/');
635 if (lastSlash != m_dir)
643 auto oldLen = strcmp(m_dir,
"/") == 0 ? 0 : strlen(m_dir);
644 char * newDir = (
char*) malloc(oldLen + 1 + strlen(subdir) + 1);
645 strcpy(newDir, m_dir);
646 newDir[oldLen] =
'/';
647 strcpy(newDir + oldLen + 1, subdir);
655 int FileBrowser::countDirEntries(
int * namesLength)
658 if (strcmp(m_dir,
"/") == 0) {
670 auto dirp = opendir(m_dir);
672 auto dp = readdir(dirp);
675 if (strcmp(
".", dp->d_name) && strcmp(
"..", dp->d_name) && dp->d_type != DT_UNKNOWN) {
676 *namesLength += strlen(dp->d_name) + 1;
693 for (
int i = 0; i < m_count; ++i)
694 if (strcmp(name, m_items[i].name) == 0)
697 for (
int i = 0; i < m_count; ++i)
698 if (strcasecmp(name, m_items[i].name) == 0)
708 char fullpath[strlen(m_dir) + 1 + strlen(name) + 1];
709 sprintf(fullpath,
"%s/%s", m_dir, name);
710 auto fr = fopen(fullpath,
"rb");
712 fseek(fr, 0, SEEK_END);
722 char fullpath[strlen(m_dir) + 1 + strlen(name) + 1];
723 sprintf(fullpath,
"%s/%s", m_dir, name);
725 if (stat(fullpath, &s))
727 auto tm = *localtime((time_t*)&s.st_ctime);
728 *year = 1900 + tm.tm_year;
729 *month = 1 + tm.tm_mon;
732 *minutes = tm.tm_min;
733 *seconds = imin(tm.tm_sec, 59);
740 char fullpath[strlen(m_dir) + 1 + strlen(name) + 1];
741 sprintf(fullpath,
"%s/%s", m_dir, name);
743 if (stat(fullpath, &s))
745 auto tm = *localtime((time_t*)&s.st_mtime);
746 *year = 1900 + tm.tm_year;
747 *month = 1 + tm.tm_mon;
750 *minutes = tm.tm_min;
751 *seconds = imin(tm.tm_sec, 59);
758 char fullpath[strlen(m_dir) + 1 + strlen(name) + 1];
759 sprintf(fullpath,
"%s/%s", m_dir, name);
761 if (stat(fullpath, &s))
763 auto tm = *localtime((time_t*)&s.st_atime);
764 *year = 1900 + tm.tm_year;
765 *month = 1 + tm.tm_mon;
768 *minutes = tm.tm_min;
769 *seconds = imin(tm.tm_sec, 59);
775 int DirComp(
const void * i1,
const void * i2)
780 return d1->
isDir ? -1 : +1;
792 int c = countDirEntries(&namesAlloc);
794 m_namesStorage = (
char*) malloc(namesAlloc);
795 char * sname = m_namesStorage;
797 if (strcmp(m_dir,
"/") == 0) {
800 if (s_SPIFFSMounted) {
801 m_items[m_count].
name = s_SPIFFSMountPath + 1;
802 m_items[m_count].
isDir =
true;
805 if (s_SDCardMounted) {
806 m_items[m_count].
name = s_SDCardMountPath + 1;
807 m_items[m_count].
isDir =
true;
814 m_items[0].
name =
"..";
815 m_items[0].
isDir =
true;
818 int hiddenFilesCount = 0;
819 auto dirp = opendir(m_dir);
821 auto dp = readdir(dirp);
824 if (strcmp(
".", dp->d_name) && strcmp(
"..", dp->d_name) && dp->d_type != DT_UNKNOWN) {
825 DirItem * di = m_items + m_count;
827 auto slashPos = strchr(dp->d_name,
'/');
830 auto len = slashPos - dp->d_name;
831 strncpy(sname, dp->d_name, len);
840 bool isHidden = dp->d_name[0] ==
'.';
841 if (!isHidden || m_includeHiddenFiles) {
842 strcpy(sname, dp->d_name);
844 di->
isDir = (dp->d_type == DT_DIR);
845 sname += strlen(sname) + 1;
865 qsort(m_items, m_count,
sizeof(
DirItem), DirComp);
875 int dirnameLen = strlen(dirname);
876 if (dirnameLen > 0) {
879 char fullpath[strlen(m_dir) + 3 + 2 * dirnameLen + 1];
882 auto next = name + 1;
883 while (*next && *next !=
'\\' && *next !=
'/')
885 strcpy(fullpath, m_dir);
886 if (dirname != name) {
887 strcat(fullpath,
"/");
888 strncat(fullpath, dirname, name - dirname - 1);
890 strcat(fullpath,
"/");
891 strncat(fullpath, name, next - name);
892 strcat(fullpath,
"/.");
893 strncat(fullpath, name, next - name);
894 replacePathSep(fullpath,
'/');
895 FILE * f = fopen(fullpath,
"wb");
903 char fullpath[strlen(m_dir) + 1 + dirnameLen + 1];
904 sprintf(fullpath,
"%s/%s", m_dir, dirname);
905 replacePathSep(fullpath,
'/');
906 mkdir(fullpath, ACCESSPERMS);
917 char fullpath[strlen(m_dir) + 1 + strlen(name) + 1];
918 sprintf(fullpath,
"%s/%s", m_dir, name);
919 int r = unlink(fullpath);
931 char hidpath[strlen(m_dir) + 3 + 2 * strlen(name) + 1];
932 sprintf(hidpath,
"%s/%s/.%s", m_dir, name, name);
935 auto dirp = opendir(fullpath);
937 auto dp = readdir(dirp);
940 if (strcmp(
".", dp->d_name) && strcmp(
"..", dp->d_name) && dp->d_type != DT_UNKNOWN) {
941 char sfullpath[strlen(fullpath) + 1 + strlen(dp->d_name) + 1];
942 sprintf(sfullpath,
"%s/%s", fullpath, dp->d_name);
955 char oldfullpath[strlen(m_dir) + 1 + strlen(oldName) + 1];
956 sprintf(oldfullpath,
"%s/%s", m_dir, oldName);
958 char newfullpath[strlen(m_dir) + 1 + strlen(newName) + 1];
959 sprintf(newfullpath,
"%s/%s", m_dir, newName);
968 constexpr
int FLEN = 6;
969 auto ret = (
char*) malloc(strlen(m_dir) + 1 + FLEN + 4 + 1);
971 char name[FLEN + 1] = { 0 };
972 for (
int i = 0; i < FLEN; ++i)
973 name[i] = 65 + (rand() % 26);
974 sprintf(ret,
"%s/%s.TMP", m_dir, name);
983 constexpr
size_t BUFLEN = 512;
985 char fullpath[strlen(m_dir) + 1 + strlen(name) + 1];
986 sprintf(fullpath,
"%s/%s", m_dir, name);
995 if (::
rename(fullpath, tempFilename) == 0) {
996 void * buf = malloc(BUFLEN);
998 auto fr = fopen(tempFilename,
"rb");
1000 auto fw = fopen(fullpath,
"wb");
1004 auto l = fread(buf, 1, tmin(size, BUFLEN), fr);
1007 fwrite(buf, 1, l, fw);
1012 for (; size > 0; --size)
1022 unlink(tempFilename);
1033 return (outPath ? snprintf(outPath, maxlen,
"%s/%s", m_dir, name) : snprintf(
nullptr, 0,
"%s/%s", m_dir, name)) + 1;
1039 char fullpath[strlen(m_dir) + 1 + strlen(filename) + 1];
1040 strcpy(fullpath, m_dir);
1041 strcat(fullpath,
"/");
1042 strcat(fullpath, filename);
1044 replacePathSep(fullpath,
'/');
1046 return fopen(fullpath, mode);
1058 if (strncmp(path,
"/spiffs", 7) == 0 || (s_SPIFFSMounted && strncmp(path, s_SPIFFSMountPath, strlen(s_SPIFFSMountPath)) == 0)) {
1060 }
else if (s_SDCardMounted && strncmp(path, s_SDCardMountPath, strlen(s_SDCardMountPath)) == 0) {
1070 esp_task_wdt_init(45,
false);
1075 char drv[3] = {(char)(
'0' + drive),
':', 0};
1078 void * buffer = malloc(FF_MAX_SS);
1083 DWORD plist[] = { 100, 0, 0, 0 };
1084 if (f_fdisk(drive, plist, buffer) != FR_OK) {
1090 if (f_mkfs(drv, FM_ANY, 16 * 1024, buffer, FF_MAX_SS) != FR_OK) {
1104 bool r = (esp_spiffs_format(
nullptr) == ESP_OK);
1115 bool FileBrowser::mountSDCard(
bool formatOnFail,
char const * mountPath,
size_t maxFiles,
int allocationUnitSize,
int MISO,
int MOSI,
int CLK,
int CS)
1117 if (getChipPackage() == ChipPackage::ESP32PICOD4) {
1122 s_SDCardMountPath = mountPath;
1123 s_SDCardMaxFiles = maxFiles;
1124 s_SDCardAllocationUnitSize = allocationUnitSize;
1125 s_SDCardMISO = MISO;
1126 s_SDCardMOSI = MOSI;
1130 sdmmc_host_t host = SDSPI_HOST_DEFAULT();
1131 sdspi_slot_config_t slot_config = SDSPI_SLOT_CONFIG_DEFAULT();
1132 slot_config.gpio_miso = int2gpio(MISO);
1133 slot_config.gpio_mosi = int2gpio(MOSI);
1134 slot_config.gpio_sck = int2gpio(CLK);
1135 slot_config.gpio_cs = int2gpio(CS);
1136 esp_vfs_fat_sdmmc_mount_config_t mount_config;
1137 mount_config.format_if_mount_failed = formatOnFail;
1138 mount_config.max_files = maxFiles;
1139 mount_config.allocation_unit_size = allocationUnitSize;
1141 s_SDCardMounted = (esp_vfs_fat_sdmmc_mount(mountPath, &host, &slot_config, &mount_config, &card) == ESP_OK);
1142 return s_SDCardMounted;
1148 if (s_SDCardMounted) {
1149 esp_vfs_fat_sdmmc_unmount();
1150 s_SDCardMounted =
false;
1158 return mountSDCard(
false, s_SDCardMountPath, s_SDCardMaxFiles, s_SDCardAllocationUnitSize, s_SDCardMISO, s_SDCardMOSI, s_SDCardCLK, s_SDCardCS);
1164 s_SPIFFSMountPath = mountPath;
1165 s_SPIFFSMaxFiles = maxFiles;
1166 esp_vfs_spiffs_conf_t conf = {
1167 .base_path = mountPath,
1168 .partition_label =
nullptr,
1169 .max_files = maxFiles,
1170 .format_if_mount_failed =
true 1172 s_SPIFFSMounted = (esp_vfs_spiffs_register(&conf) == ESP_OK);
1173 return s_SPIFFSMounted;
1179 if (s_SPIFFSMounted) {
1180 esp_vfs_spiffs_unregister(
nullptr);
1181 s_SPIFFSMounted =
false;
1189 return mountSPIFFS(
false, s_SPIFFSMountPath, s_SPIFFSMaxFiles);
1200 DWORD free_clusters;
1201 char drv[3] = {(char)(
'0' + drive),
':', 0};
1202 if (f_getfree(drv, &free_clusters, &fs) != FR_OK)
1204 int64_t total_sectors = (fs->n_fatent - 2) * fs->csize;
1205 int64_t free_sectors = free_clusters * fs->csize;
1206 *total = total_sectors * fs->ssize;
1207 *used = *total - free_sectors * fs->ssize;
1213 size_t stotal = 0, sused = 0;
1214 if (esp_spiffs_info(NULL, &stotal, &sused) != ESP_OK)
1235 void LightMemoryPool::mark(
int pos, int16_t size,
bool allocated)
1237 m_mem[pos] = size & 0xff;
1238 m_mem[pos + 1] = ((size >> 8) & 0x7f) | (allocated ? 0x80 : 0);
1242 int16_t LightMemoryPool::getSize(
int pos)
1244 return m_mem[pos] | ((m_mem[pos + 1] & 0x7f) << 8);
1248 bool LightMemoryPool::isFree(
int pos)
1250 return (m_mem[pos + 1] & 0x80) == 0;
1254 LightMemoryPool::LightMemoryPool(
int poolSize)
1256 m_poolSize = poolSize + 2;
1257 m_mem = (uint8_t*) heap_caps_malloc(m_poolSize, MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
1258 mark(0, m_poolSize - 2,
false);
1262 LightMemoryPool::~LightMemoryPool()
1264 heap_caps_free(m_mem);
1268 void * LightMemoryPool::alloc(
int size)
1270 for (
int pos = 0; pos < m_poolSize; ) {
1271 int16_t blockSize = getSize(pos);
1273 if (blockSize == size) {
1275 mark(pos, size,
true);
1276 return m_mem + pos + 2;
1277 }
else if (blockSize > size) {
1279 int remainingSize = blockSize - size - 2;
1280 if (remainingSize > 0)
1281 mark(pos + 2 + size, remainingSize,
false);
1284 mark(pos, size,
true);
1285 return m_mem + pos + 2;
1289 int nextBlockPos = pos + 2 + blockSize;
1290 if (nextBlockPos < m_poolSize && isFree(nextBlockPos)) {
1292 mark(pos, blockSize + getSize(nextBlockPos) + 2,
false);
1295 pos += blockSize + 2;
1300 pos += blockSize + 2;
1307 bool LightMemoryPool::memCheck()
1310 while (pos < m_poolSize) {
1311 int16_t blockSize = getSize(pos);
1312 pos += blockSize + 2;
1314 return pos == m_poolSize;
1318 int LightMemoryPool::totFree()
1321 for (
int pos = 0; pos < m_poolSize; ) {
1322 int16_t blockSize = getSize(pos);
1325 pos += blockSize + 2;
1331 int LightMemoryPool::totAllocated()
1334 for (
int pos = 0; pos < m_poolSize; ) {
1335 int16_t blockSize = getSize(pos);
1338 pos += blockSize + 2;
1344 int LightMemoryPool::largestFree()
1347 for (
int pos = 0; pos < m_poolSize; ) {
1348 int16_t blockSize = getSize(pos);
1349 if (isFree(pos) && blockSize > r)
1351 pos += blockSize + 2;
1366 int CoreUsage::s_busiestCore = -1;
This file contains fabgl::PS2Controller definition.
This file contains fabgl::VGA16Controller definition.
bool truncate(char const *name, size_t size)
Truncates a file to the specified size.
void rename(char const *oldName, char const *newName)
Renames a file.
void remove(char const *name)
Removes a file or directory.
static bool mountSDCard(bool formatOnFail, char const *mountPath, size_t maxFiles=4, int allocationUnitSize=16 *1024, int MISO=16, int MOSI=17, int CLK=14, int CS=13)
Mounts filesystem on SD Card.
bool setDirectory(const char *path)
Sets absolute directory path.
This file contains fabgl::VGAController definition.
size_t fileSize(char const *name)
Determines file size.
bool fileUpdateDate(char const *name, int *year, int *month, int *day, int *hour, int *minutes, int *seconds)
Gets file update date and time.
bool fileCreationDate(char const *name, int *year, int *month, int *day, int *hour, int *minutes, int *seconds)
Gets file creation date and time.
This file contains fabgl::VGA2Controller definition.
static void unmountSDCard()
Unmounts filesystem on SD Card.
This file contains some utility classes and functions.
FileBrowser item specificator.
char * createTempFilename()
Creates a random temporary filename, with absolute path.
int getFullPath(char const *name, char *outPath=nullptr, int maxlen=0)
Composes a full file path given a relative name.
DriveType getCurrentDriveType()
Returns the drive type of current directory.
static bool format(DriveType driveType, int drive)
Formats SPIFFS or SD Card.
DriveType
This enum defines drive types (SPIFFS or SD Card)
static bool remountSDCard()
Remounts SDCard filesystem, using the same parameters.
void makeDirectory(char const *dirname)
Creates a directory.
bool fileAccessDate(char const *name, int *year, int *month, int *day, int *hour, int *minutes, int *seconds)
Gets file access date and time.
static DriveType getDriveType(char const *path)
Returns the drive type of specified path.
void changeDirectory(const char *subdir)
Sets relative directory path.
FILE * openFile(char const *filename, char const *mode)
Opens a file from current directory.
static bool mountSPIFFS(bool formatOnFail, char const *mountPath, size_t maxFiles=4)
Mounts filesystem on SPIFFS (Flash)
bool exists(char const *name, bool caseSensitive=true)
Determines if a file or directory exists.
bool reload()
Reloads directory content.
static bool getFSInfo(DriveType driveType, int drive, int64_t *total, int64_t *used)
Gets total and free space on a filesystem.
static bool remountSPIFFS()
Remounts SPIFFS filesystem, using the same parameters.
static void unmountSPIFFS()
Unmounts filesystem on SPIFFS (Flash)