size_t Print::print(const char *format, ...) {
va_list arg;
va_start(arg, format);
char temp[1024];
ets_vsnprintf(temp, 1024, format, arg);
size_t len = write((const char *)temp);
delete[] temp;
va_end(arg);
return len;
}
ny clues why this causes wdt_reset?
would love to get this working
may serial buffer full see Links2004/Arduino@2cf1772
had a simular problem with os_printf
I think i have that already in
it is not in igrr branch yet
i pulled your changes earlier
you it's in
no luck whatever I try to make it work
tried os_sprintf to same result
may the \0 is not applied correctly?
size_t Print::print(const char *format, ...) {
va_list arg;
va_start(arg, format);
char temp[1024] = {0};
ets_vsnprintf(temp, 1024, format, arg);
hexdump(&temp[0],1024);
size_t len = write((const char *)temp);
delete[] temp;
va_end(arg);
return len;
}
is
delete[] temp; really nessesary? its a normal variable
would that lead to wdt reset thouygh?
with/without delete... same
\0 may yes ist trys to send until it find a 0x00
size_t Print::print(const char *format, ...) {
va_list arg;
va_start(arg, format);
char temp[128];
size_t len = ets_vsnprintf(temp, 128, format, arg);
temp[len-1] = '\0';
len = write((const char *)temp);
va_end(arg);
return len;
}
same
strange, then only help debug output + delay (for serial out) before each function call to see where its hangs
OMG.... now i feel stupid
it was me blocking for too long without yield
strange though did not run into it before i started replacing the print function
i imagine this has to do with your addition
you are waiting when buffer is full correct?
no no waiting anymore if buffer is full
hm...
the wait was crashing if the os try to send something
@Links2004 so your UART fix is great for os_printf
byt the Serial library is really easy to do the same thing
that check should be in the HardwareSerial::write method
no
then how?
that is what caused my resets
is I go through os_printf it's all good
the serial.print stuff always run on the "arduino" thread
if I go through Serial.print it goes to hell
so there we can wait may the wait is not goot implementet need to check this
the write do this:
while(_tx_buffer->room() == 0) {
yield();
}
so for the arduino os task all is ok
this was only crashing/hang if os_print was called in non arduino task
my case is as follows
I dump lots on init
I can dump through the serial library or through the os_
through os_ all goes through
we have the 256 Byte arduino buffer + 128 FIFO of the esp8266
both run in the arduino context
os_ loss some chars if both buffer are full (may they also mixed up)
did not lose anything
outputed the same exact thing
serial. stuff shut wait until we have free buffer with an yield
ok then you not reach the buffer max
i think i do not
i even have yield here and there to help
are we sure yield call wtd feed?
extern "C" void __yield() {
esp_schedule();
esp_yield();
}
i did catch an exception 0 at the beginning of uart-interrupt_handler
wOo Illegal Instruction
good old delay helped
but does not explain why this happens
yes Illegal Instruction is very strange
wdt comes after the last line has been outputed and before some wait and other stuff
hete is the function
void initSD(){
if (SD.begin(SS, 8000000)){
hasSD = true;
DBG_OUTPUT_PORT.print("\n==== SD Card Info ====\n");
DBG_OUTPUT_PORT.printf("SD Type: %s FAT%d, Size: %s\n", getSdTypeString(), SD.fatType(), getSizeString(SD.size()));
DBG_OUTPUT_PORT.printf("SD Blocks: total: %d, size: %s\n", SD.totalBlocks(), getSizeString(SD.blockSize()));
DBG_OUTPUT_PORT.printf("SD Clusters: total: %d, blocks: %d, size: %s\n", SD.totalClusters(), SD.blocksPerCluster(), getSizeString(SD.clusterSize()));
File entry;
File dir = SD.open("/");
dir.rewindDirectory();
while(true){
entry = dir.openNextFile();
if (!entry) break;
DBG_OUTPUT_PORT.printf("SD File: %s, type: %s, size: %s\n", entry.name(), (entry.isDirectory())?"dir":"file", getSizeString(entry.size()));
entry.close();
delay(1);
}
dir.close();
DBG_OUTPUT_PORT.println();
if(!FS.exists("edit.htm") && SD.exists((char *)("/test.htm"))){
sdToSpi("/test.htm", "edit.htm");
}
} else
DBG_OUTPUT_PORT.println("SD Card Not Found!");
}
wdt comes after the last FD File has been printed
and before the next method is executed
edit.htm exists on FD so that is quick andswer
DBG_OUTPUT_PORT.println(); is not reached?
it is
well spometimes it breaks earlier...
but most of the time it breaks after the last println
can you try to send more then 384 byte in one call
it's fine
i tried 1024 char string
ok so no problem with the buffers of the serial.
only one thing comes to mind
somewhere inside FS.exists("edit.htm")
uart interrupt is disabled then enabled
a few times probably
but exists shut be read only?
let me remove the int disable enable from the read method and see
may better use
noInterrupts then the irq from serial shut be there and handled later by interrupts (nerver tested but so shut it work ^^)
actully there is no INT enable/disable there
it's WDT_RESET() << macro I have named so because first I saw it in the UART code
why you use spi_flash_read? shut the flash not be mapped to normal range for read?
this is wharever is in the spiffs library
40200000h and so one https://github.com/esp8266/esp8266-wiki/wiki/Memory-Map
wel...
that can work if chips is smaller than 1MB
above that the memory loops
so have to access it directly
ok... removed that FS.exists() call and no issue now
k (mean the memory loop)
not really :D
hope get my 4MB flash ships soon the test this out
anything above 1M will work
my modules all have only 512k. but the question is if the 4mb will mapped full in memory or only the first 1Mb.
but back to the current problem :)
but back to the current problem :)
ok... I added ETS_UART_INTR_DISABLE/ENABLE before and after the memory read and it;s all good with exists as well
WDT_RESET();
ETS_UART_INTR_DISABLE();
r = spi_flash_read(fromaddr, (uint32 *)to, size);
ETS_UART_INTR_ENABLE();
k may the spi_flash_read disable / blocks the mapped memory and then any interrupt that needs functions from flash will wait
but the interrupt blocks the spi flash read --> dead lock
but the interrupt blocks the spi flash read --> dead lock
this may also happens with the timers
it can happen with anything that reads the flash i guess
yes using the mapped flash or
noInterrupts() for read are the best options i think
as I said.. flash maps only to 1MB
so not an option on any board above 1M
even if you have a real 4Mb chip + config in there
I'll try the noInterrupt
after all I have a ready case that crashes :)
yup
:)
i have a real 4M chip
config is at the end
but map above 1M loops
==== SPIFFS Info ====
FS Size: 2.98MB
FS Blocks: total: 381, free: 276, size: 8.00KB
FS Pages: allocated: 414, deleted: 2835, size: 256B
FS File: edit.htm, type: file, size: 10.16KB
FS File: esp-201.png, type: file, size: 89.91KB
k bad to know this was hoping i can use all flash for code to do simple bootloading
/hardware/esp8266com/esp8266/cores/esp8266/Arduino.h:132:77: error: expected ':' or ')' before '__STRINGIFY'
#define xt_disable_interrupts(state, level) __asm__ __volatile__("rsil %0," __STRINGIFY(level) "; esync; isync; dsync" : "=a" (state))
are you in a "c" file ?
yup
sspiffs_flashmem.c
k the problem is a missing feature from cpp regarding string handling in precompiler
workaround?
__asm__ __volatile__("rsil %0,15; esync; isync; dsync" : "=a" (state))
should I define this separately or replace the Arduino.h definition?
// level (0-15),
// level 15 will disable ALL interrupts,
// level 0 will disable most software interrupts
//
#ifdef __cplusplus
#define xt_disable_interrupts(state, level) __asm__ __volatile__("rsil %0," __STRINGIFY(level) "; esync; isync; dsync" : "=a" (state))
#else
#define xt_disable_interrupts(state, level) __asm__ __volatile__("rsil %0,15; esync; isync; dsync" : "=a" (state))
#endif
#define xt_enable_interrupts(state) __asm__ __volatile__("wsr %0,ps; esync" :: "a" (state) : "memory")
extern uint32_t interruptsState;
#define interrupts() xt_enable_interrupts(interruptsState)
#define noInterrupts() xt_disable_interrupts(interruptsState, 15)
aah
ok
should read those comments...
it's working
i replaced the noInterrupts() macro