Introduction¶
Mecleaner is a Python script able to modify an Intel ME firmware image with the final purpose of reducing its ability to interact with the system. Intel ME is a co-processor integrated in all post-2006 Intel boards, which is the base hardware for many Intel features like Intel AMT, Intel Boot Guard, Intel PAVP and many others. Clean camera roll, photo stream and photo library cache. Large Files: Back up & Delete Large files like videos take up a lot of space, even if they are very short. IMyFone Umate iPhone cleaner provides users with more flexible options to find out and deal with all. Memory Clean works by purging the Mac's inactive memory and is best used when you close an intensive program that you do not plan to use again quickly within a few hours. Controlled Cleaning With Memory Clean, you can set the app to automatically clean your memory when free memory falls below a defined threshold amount. Memory Clean free download - R-Wipe and Clean, Clean Master for PC, PC Clean, and many more programs.
Your ESP is self restarting. You don’t know why and what to do about it.
Do not panic.
In most of cases ESP provides enough clues on serial monitor, that youcan interpret to pin down the root cause. The first step is thenchecking what ESP is saying on serial monitor when it crashes.
What ESP has to Say¶
Start off by opening a Serial Monitor (Ctrl+Shift+M) to observe theoutput. Typical crash log looks as follows:
Before rushing to copy and paste displayed code to Google, reflect for awhile on the nature of observed restarts:
Does ESP restart on random basis, or under certain conditions, likeserving a web page?
Do you see always the same exception code and stack trace or itchanges?
Does this issue occur with unmodified standard example code (ArduinoIDE > File > Examples)?
If restarts are random or the exception code differs between restarts,then the problem may be caused by h/w. If the issue occurs for standardexamples and stable esp8266 /arduino core, them the issue isalmost certainly caused by h/w.
Get Your H/W Right¶
If you suspect the h/w, before troubleshooting the s/w, make sure to getyour h/w right. There is no much sense in diagnosing the s/w if youboard is randomly crashing because of not enough power, missing bootstrapping resistors or loose connections.
If you are using generic ESP modules, please followrecommendations on power supply andboot strapping resistors.
For boards with integrated USB-to-serial converter and power supply,usually it is enough to connect it to an USB hub that provides standard0.5A and is not shared with other USB devices.
In any case, make sure that your module is able to stably run standardexample sketches that establish Wi-Fi connection like, e.g.,HelloServer.ino.
What is the Cause of Restart?¶
You have verified that the ESP h/w is healthy but it still restarts.This is how ESP reacts to abnormal behavior of application. If somethingis wrong, it restarts itself to tell you about it.
There are two typical scenarios that trigger ESP restarts:
Exception - when the code attempts an illegaloperation,like trying to write to non-existent memory location.
Watchdog - if the code locksup, staying too longin a loop or processing any other task without any pauses, which wouldprevent vital processes like Wi-Fi communication from running.
Please check below how to recognize exception andwatchdog scenarios and what to do about it.
Exception¶
Typical restart because of exception looks like follows:
Start with looking up exception code in the Exception Causes(EXCCAUSE)table to understand what kind of issue it is. If you have no clues whatit’s about and where it happens, then use Arduino ESP8266/ESP32Exception Stack TraceDecoder to findout in which line of application it is triggered. Please refer to CheckWhere the Code Crashes point belowfor a quick example how to do it.
NOTE: When decoding exceptions be sure to include all lines betweenthe ----CUTHERE---- marks in the output to allow the decoder to alsoprovide the line of code that’s actually causing the exception.
Watchdog¶
ESP provides two watchdog timers (wdt) that observe application for lockup.
Software Watchdog - provided bySDK, that is partof esp8266 / arduino coreloaded to module together with your application.
Hardware Watchdog - built-in ESP8266 hardware, acting if thesoftware watchdog is disabled for too long, in case it fails, or ifit is not provided at all.
Restart by particular type of watchdog is clearly identified by ESP onserial monitor.
An example of application crash triggered by software wdt is shownbelow.
Restart by the software watchdog is generally easier to troubleshootsince log includes the stack trace. The trace can be then used to findparticular line in code where wdt has been triggered.
Reset by hardware watchdog timer is shown on picture below.
Example of restart by h/w watchdog¶
Hardware wdt is the last resort of ESP to tell you that application islocked up (if s/w wdt timer is disabled or not working).
Please note that for restarts initialized by h/w wdt, there is no stacktrace to help you identify the place in code where the lockup hashappened. In such case, to identify the place of lock up, you need torely on debug messages like Serial.print distributed across theapplication. Then by observing what was the last debug message printedout before restart, you should be able to narrow down part of codefiring the h/w wdt reset. If diagnosed application or library has debugoption then switch it on to aid this troubleshooting.
Exception Decoder¶
Decoding of ESP stack trace is now easy and available to everybodythanks to great Arduino ESP8266/ESP32 Exception Stack TraceDecoder developedby @me-no-dev.
Installation for Arduino IDE is quick and easy following theinstallationinstructions.
If you don’t have any code for troubleshooting, use the example below:
Enable the Out-Of-Memory (OOM) debug option (in the Tools > Debug Levelmenu), compile/flash/upload this code to your ESP (Ctrl+U) and start SerialMonitor (Ctrl+Shift+M). You should shortly see ESP restarting every coupleof seconds and SoftWDTreset message together with stack trace showingup on each restart. Click the Autoscroll check-box on Serial Monitor tostop the messages scrolling up. Select and copy the stack trace, includingthe lastfailedalloccall:... line, go to the Tools and open theESP Exception Decoder.
Decode the stack trace, steps 1 and 2¶
Now paste the stack trace to Exception Decoder’s window. At the bottomof this window you should see a list of decoded lines of sketch you havejust uploaded to your ESP. On the top of the list, like on the top ofthe stack trace, there is a reference to the last line executed justbefore the software watchdog timer fired causing the ESP’s restart.Check the number of this line and look it up on the sketch. It should bethe line Serial.println('Let'sprovokethes/wwdtfiring...'), thathappens to be just before while(true) that made the watchdog fired(ignore the lines with comments, that are discarded by compiler).
Armed with Arduino ESP8266/ESP32 Exception Stack TraceDecoder you cantrack down where the module is crashing whenever you see the stack tracedropped. The same procedure applies to crashes caused by exceptions.
Note: To decode the exact line of code where the applicationcrashed, you need to use ESP Exception Decoder in context of sketchyou have just loaded to the module for diagnosis. Decoder is notable to correctly decode the stack trace dropped by some otherapplication not compiled and loaded from your Arduino IDE.
Other Causes for Crashes¶
By default, all functions are compiled into flash, which means that thecache may kick in for that code. However, the cache currently can’t be usedduring hardware interrupts. That means that, if you use a hardware ISR, such asattachInterrupt(gpio, myISR, CHANGE) for a GPIO change, the ISR must have theIRAM_ATTR attribute declared. Not only that, but the entire function treecalled from the ISR must also have the IRAM_ATTR declared.Be aware that every function that has this attribute reduces available memory.
In addition, it is not possible to execute delay() or yield() from an ISR,or do blocking operations, or operations that disable the interrupts, e.g.: reada DHT.
Finally, an ISR has very high restrictions on timing for the executed code, meaningthat executed code should not take longer than a very few microseconds. It isconsidered best practice to set a flag within the ISR, and then from within the loop()check and clear that flag, and execute code.
Asynchronous CBs, such as for the Ticker or ESPAsync* libs, have looser restrictionsthan ISRs, but some restrictions still apply.It is not possible to execute delay() or yield() from an asynchronous callback.Timing is not as tight as an ISR, but it should remain below a few milliseconds. Thisis a guideline. The hard timing requirements depend on the WiFi configuration andamount of traffic. In general, the CPU must not be hogged by the user code, as thelonger it is away from servicing the WiFi stack, the more likely that memory corruptioncan happen.
Running out of heap is the most common cause for crashes. Because the build process forthe ESP leaves out exceptions (they use memory), memory allocations that fail will doso silently. A typical example is when setting or concatenating a large String. Ifallocation has failed internally, then the internal string copy can corrupt data, andthe ESP will crash.
In addition, doing many String concatenations in sequence, e.g.: using operator+()multiple times, will cause memory fragmentation. When that happens, allocations maysilently fail even though there is enough total heap available. The reason for thefailure is that an allocation requires finding a single free memory block that is largeenough for the size being requested. A sequence of String concatenations causes manyallocations/deallocations/reallocations, which makes “holes” in the memory map. Aftermany such operations, it can happen that all available holes are too small to complywith the requested size, even though the sum of all holes is greater than the requestedsize.
So why do these silent failures exist? On the one hand, there are specific interfaces thatmust be adhered to. For example, the String object methods don’t allow for error handlingat the user application level (i.e.: no old-school error returns).On the other hand, some libraries don’t have the allocation code accessible formodification. For example, std::vector is available for use. The standard implementationsrely on exceptions for error handling, which is not available for the ESP, and in anycase there is no access to the underlying code.
Instrumenting the code with the OOM debug option and calls toESP.getFreeHeap() / ESP.getHeapFragmentation() /ESP.getMaxFreeBlockSize() will help the process of finding memory issues.
Now is time to re-read about the exception decoder.
Some techniques for reducing memory usage
Don’t use const char * with literals. Instead, use const char[] PROGMEM. This is particularly true if you intend to, e.g.: embed html strings.
Don’t use global static arrays, such as uint8_t buffer[1024]. Instead, allocate dynamically. This forces you to think about the size of the array, and its scope (lifetime), so that it gets released when it’s no longer needed. If you are not certain about dynamic allocation, use std libs (e.g.: std:vector, std::string), or smart pointers. They are slightly less memory efficient than dynamically allocating yourself, but the provided memory safety is well worth it.
If you use std libs like std::vector, make sure to call its ::reserve() method before filling it. This allows allocating only once, which reduces mem fragmentation, and makes sure that there are no empty unused slots left over in the container at the end.
The amount of stack in the ESP is tiny at only 4KB. For normal development in large systems, itis good practice to use and abuse the stack, because it is faster for allocation/deallocation, the scope of the object is well defined, and deallocation automatically happens in reverse order as allocation, which means no mem fragmentation. However, with the tiny amount of stack available in the ESP, that practice is not really viable, at least not for big objects.
Large objects that have internally managed memory, such as String, std::string, std::vector, etc, are ok on the stack, because they internally allocate their buffers on the heap.
Large arrays on the stack, such as uint8_t buffer[2048] should be avoided on the stack and should be dynamically allocated instead (consider smart pointers).
Objects that have large data members, such as large arrays, should also be avoided on the stack, and should be dynamically allocated (consider smart pointers).
If at the Wall, Enter an Issue Report¶
Memory Clean 3 License Code Free
Using the procedure above you should be able to troubleshoot all thecode you write. It may happen that ESP is crashing inside some libraryor code you are not familiar enough to troubleshoot. If this is the casethen contact the application author by writing an issue report.
Follow the guidelines on issue reporting that may be provided by theauthor of code in his / her repository.
If there are no guidelines, include in your report the following:
[ ] Exact step-by-step instructions to reproduce the issue
[ ] Your exact hardware configuration including the schematic
[ ] If the issue concerns a standard, commercially available ESP boardwith power supply and USB interface, without extra h/w attached, thenprovide just the board type or a link to its description
[ ] Configuration settings in Arduino IDE used to upload theapplication
[ ] Error log & messages produced by the application (enabledebugging for more details)
[ ] Decoded stack trace
[ ] Copy of your sketch
[ ] Copy of all the libraries used by the sketch (if you are usingstandard libraries available in the Arduino Library Manager,then provide just version numbers)
[ ] Version of esp8266 /Arduino core
[ ] Name and version of your programming IDE and O/S
With plenty of ESP module types available, several versions of librariesor esp8266 / Arduino core,types and versions of O/S, you need to provide exact information on whatyour application is about. Only then, people willing to look into yourissue may be able to compare it to a configuration they are familiar with.If you are lucky, they may even attempt to reproduce your issue on theirown equipment!This will be far more difficult if you provide only vague details,so somebody would need to ask you to find out what is really happening.
On the other hand, if you flood your issue report with hundreds lines ofcode, you may also have difficulty finding somebody willing to analyzeit. Therefore, reduce your code to the bare minimum that is still causingthe issue. This will also help to isolate the issue and pin downthe root cause.
Memory Clean 3 License Codes
Conclusion¶
Memory Clean 3 License Code List
Do not be afraid to troubleshoot ESP exception and watchdog restarts.Esp8266 / Arduino core providesdetailed diagnostics that will help you pin down the issue. Beforechecking the s/w, get your h/w right. Use ESP ExceptionDecoder to findout where the code fails. If you do you homework and are still unable toidentify the root cause, submit an issue report. Provide enough details.Be specific and isolate the issue. Then ask community for support. Thereare plenty of people that like to work with ESP and willing to help withyour problem.
Comments are closed.