We are compiling an embedded C++ application that is deployed in a shielded device in an environment bombarded with [ionizing radiation][1]. We are using GCC and cross-compiling for ARM. When deployed, our application generates some erroneous data and crashes more often than we would like. The hardware is designed for this environment, and our application has run on this platform for several years.

Are there changes we can make to our code, or compile-time improvements that can be made to identify/correct [soft errors][2] and memory-corruption caused by [single event upsets][3]? Have any other developers had success in reducing the harmful effects of soft errors on a long-running application?

  [1]: https://en.wikipedia.org/wiki/Ionizing_radiation
  [2]: https://en.wikipedia.org/wiki/Soft_error
  [3]: https://en.wikipedia.org/wiki/Single_event_upset




Compiling an application for use in highly radioactive environments

I worked on an embedded system this summer written in straight C.  It was an existing project that the company I work for had taken over.  I have become quite accustomed to writing unit tests in Java using JUnit but was at a loss as to the best way to write unit tests for existing code (which needed refactoring) as well as new code added to the system.

Are there any projects out there that make unit testing plain C code as easy as unit testing Java code with JUnit?  Any insight that would apply specifically to embedded development (cross-compiling to arm-linux platform) would be greatly appreciated.

Unit Testing C Code

I have a computer with 1 MB of RAM and no other local storage. I must use it to accept 1 million 8-digit decimal numbers over a TCP connection, sort them, and then send the sorted list out over another TCP connection. 

The list of numbers may contain duplicates, which I must not discard. The code will be placed in ROM, so I need not subtract the size of my code from the 1&amp;nbsp;MB. I already have code to drive the Ethernet port and handle TCP/IP connections, and it requires 2&amp;nbsp;KB for its state data, including a 1&amp;nbsp;KB buffer via which the code will read and write data. Is there a solution to this problem?

**Sources Of Question And Answer:**

&lt;a href=&quot;http://tech.slashdot.org/comments.pl?sid=232757&amp;cid=18925745&quot;&gt;slashdot.org&lt;/a&gt;

&lt;a href=&quot;https://web.archive.org/web/20160309195130/http://nick.cleaton.net/ramsort.html&quot;&gt;cleaton.net&lt;/a&gt;


Sorting 1 million 8-decimal-digit numbers with 1 MB of RAM

I&#39;d like to be able to unit test my Arduino code. Ideally, I would be able to run any tests without having to upload the code to the Arduino. What tools or libraries can help me with this?

There is an [Arduino emulator in development][1] which could be useful, but it doesn&#39;t yet seem to be ready for use.

[AVR Studio][2] from Atmel contains a chip simulator which could be useful, but I can&#39;t see how I would use it in conjunction with the Arduino IDE.

  [1]: http://radpartbrainmat.blogspot.com/search/label/arduemu
  [2]: http://www.atmel.com/dyn/Products/tools_card.asp?tool_id=2725


How can I unit test Arduino code?

I am trying to understand my embedded Linux application&#39;s memory use.  The `/proc/pid/maps` utility/file seems to be a good resource for seeing the details.  Unfortunately I don&#39;t understand all the columns and entries.

What does the anonymous inode 0 entries mean?  These seem to be some of the larger memory segments.

Understanding Linux /proc/pid/maps or /proc/self/maps

Assuming I have to use C (no C++ or object oriented compilers) and I don&#39;t have dynamic memory allocation, what are some techniques I can use to implement a class, or a good approximation of a class? Is it always a good idea to isolate the &quot;class&quot; to a separate file? Assume that we can preallocate the memory by assuming a fixed number of instances, or even defining the reference to each object as a constant before compile time. Feel free to make assumptions about which OOP concept I will need to implement (it will vary) and suggest the best method for each.

Restrictions:

 - I have to use C and not an OOP
   because I&#39;m writing code for an
   embedded system, and the compiler and
   preexisting code base is in C. 
 - There is no dynamic memory allocation
   because we don&#39;t have enough memory
   to reasonably assume we won&#39;t run out
   if we start dynamically allocating
   it.
 - The compilers we work with have no problems with function pointers

How do you implement a class in C?

How are everyday machines (not so much computers and mobile devices as appliances, digital watches, etc) programmed? What kind of code goes into the programming of a Coca-Cola vending machine? How does my coffee maker accept a pre-programmed time and begin brewing a pot of coffee hours later, when that time arrives?

Do these kinds of machines have operating systems inside of them, or is it something even more basic? Are they written in Assembly, C, or some other language?

And, I would really like to find some resource that lists these operating systems or underlying code systems, possibly even with source code if possible. If anyone knows of such a resource (searching yielded nothing for me), that would be fantastic.

How are everyday machines programmed?

When is it appropriate to use CRC for error detection versus more modern hashing functions such as MD5 or SHA1? Is the former easier to implement on embedded hardware?

When is CRC more appropriate to use than MD5/SHA1?

I have an embedded application with a time-critical ISR that needs to iterate through an array of size 256 (preferably 1024, but 256 is the minimum) and check if a value matches the arrays contents. A `bool` will be set to true is this is the case.

The microcontroller is an NXP LPC4357, ARM Cortex M4 core, and the compiler is GCC. I already have combined optimisation level 2 (3 is slower) and placing the function in RAM instead of flash. I also use pointer arithmetic and a `for` loop, which does down-counting instead of up (checking if `i!=0` is faster than checking if `i&lt;256`). All in all, I end up with a duration of 12.5&amp;nbsp;&#181;s which has to be reduced drastically to be feasible. This is the (pseudo) code I use now:

    uint32_t i;
    uint32_t *array_ptr = &amp;theArray[0];
    uint32_t compareVal = 0x1234ABCD;
    bool validFlag = false;

    for (i=256; i!=0; i--)
    {
        if (compareVal == *array_ptr++)
        {
             validFlag = true;
             break;
         }
    }

What would be the absolute fastest way to do this? Using inline assembly is allowed. Other &#39;less elegant&#39; tricks are also allowed.


Quickly find whether a value is present in a C array?

If we declare a variable as `volatile` every time the fresh value is updated   
If we declare a variable as `const` then the value of that variable will not be changed   

Then `const volatile int temp;`   
What is the use of declaring the variable `temp` as above?   
What happens if we declare as `const int temp`?

Difference between const &amp; const volatile

## Question
I have two compilers on my hardware C++ and C89

I&#39;m thinking about using C++ with classes but without polymorphism (to avoid vtables).
The main reasons I’d like to use C++ are:

-	I prefer to use “inline” functions instead of macro definitions.
-	I’d like to use namespaces as I prefixes clutter the code.
-	I see C++ a bit type safer mainly because of templates, and verbose casting.
-	I really like overloaded functions and constructors (used for automatic casting).

Do you see any reason to stick with C89 when developing for very limited hardware (4kb of RAM)?

## Conclusion
Thank you for your answers, they were really helpful! 

I thought the subject through and I will stick with C mainly because:
 
 1. It is easier to predict actual code in C and this is really important if you have only 4kb of ram. 
 2. My team consists mainly of C developers, so advanced C++ features won&#39;t be frequently used.
 3. I&#39;ve found a way to inline functions in my C compiler (C89).


It is hard to accept one answer as you provided so many good answers. 
Unfortunately I can&#39;t create a wiki and accept it, so I will choose one answer that made me think most.



Is there any reason to use C instead of C++ for embedded development?

I&#39;m writing a small interpreter for a simple BASIC like language as an exercise on an AVR microcontroller in C using the avr-gcc toolchain.

If I were writing this to run on my Linux box, I could use flex/bison. Now that I restricted myself to an 8-bit platform, how would I code the parser?


Writing a parser like Flex/Bison that is usable on 8-bit embedded systems

I have always been an embedded software engineer, but usually at Layer 3 or 2 of the OSI stack. I am not really a hardware guy. I have generally always done telecoms products, usually hand/cell-phones, which generally means something like an ARM 7 processor.

Now I find myself in a more generic embedded world, in a small start-up, where I might move to &quot;not so powerful&quot; processors (there&#39;s the subjective bit) - I cannot predict which.

I have read quite a bit about debate about using STL in C++ in embedded systems and there is no clear cut answer. There are some small worries about portability, and a few about code size or run-time, but I have two major concerns:  
  1 - exception handling; I am still not sure whether to use it (see https://stackoverflow.com/questions/2226227/embeeded-c-to-use-exceptions-or-not)  
  2 - I strongly dislike dynamic memory allocation in embedded systems, because of the problems it can introduce. I generally have a buffer pool which is statically allocated at compile time and which serves up only fixed size buffers (if no buffers, system reset). The STL, of course, does a lot of dynamic allocation.

Now I have to make the decision whether to use or forego the STL - for the whole company, for ever (it&#39;s going into some very core s/w).

Which way do I jump? Super-safe &amp; lose much of what constitutes C++ (imo, it&#39;s more than just the language definition) and maybe run into problems later or have to add lots of exception handling &amp; maybe some other code now?

I am tempted to just go with [Boost][1], but 1) I am not sure if it will port to every embedded processor I might want to use and 2) on their website, they say that they doesn&#39;t guarantee/recommend certain parts of it for embedded systems (especially FSMs, which seems weird). If I go for Boost &amp; we find a problem later ....


  [1]: http://www.boost.org/

Embedded C++ : to use STL or not?

By reading [this question](https://stackoverflow.com/questions/36827659/compiling-an-application-for-use-in-highly-radioactive-environments), I understood, for instance, why dynamic allocation or exceptions are not recommended in environments where radiation is high, like in space or in a nuclear power plant.
Concerning templates, I don&#39;t see why. Could you explain it to me?

Considering [this answer](https://stackoverflow.com/questions/622659/what-are-the-good-and-bad-points-of-c-templates), it says that it is quite safe to use.

Note: I&#39;m not talking about complex standard library stuff, but purpose-made custom templates.


Why is C++ template use not recommended in a space/radiated environment?

I am looking for general purpose programming languages that

 - have an interactive (live coding) prompt
 - work in 32 KB of RAM by itself or 8 KB when the compiler is hosted on a separate machine
 - run on a microcontroller with as little as 8-32 KB RAM total (without an MMU).

Below is my list so far, what am I missing?

 - **Python**: The [PyMite VM][3] needs 64K flash, 8K RAM.  Targets LPC, SAM7 and ATmegas with 8K or more. Hosted.
 - **Lua**: The [eLua][4] FAQ recommends 256K flash, 64K RAM.
 - **FORTH**: [amforth][2] needs 8K flash, 150 bytes RAM, 30 bytes EEPROM on an ATmega.
 - **Scheme**: [armpit Scheme][1] The smallest target is the LPC2103 with 32K Flash, 4K SRAM.
 - **C**: [Interactive C][5] runs on 68HC11 with no flash and 32K SRAM.  Hosted.
 - **C**: [picoc][10] an open source, cross-compiling, interactive C system.  When compiled for AVR, it takes 63K flash, 8K RAM.  The RAM could be reduced with effort to keep tables in flash.
 - **C++**: [AngelScript][11] an open source, byte-code based, C/C++ like scripting language with easy native calls.
 - **Tcl**: [TinyTCL][6] runs on DOS, 60K binary.  Looks easy to port.
 - **BASIC**: [TinyBasic][7]: Initializes with a 64K heap, might be adjustable.
 - **Lisp**
 - **PostScript**: (I haven&#39;t found a FOSS implementation for low memory yet)
 - **Shell**: [bitlash][8]: An interactive command shell for Arduino (ATmega).  See also [AVRSH][9].

  [1]: http://armpit.sourceforge.net/
  [2]: http://amforth.sourceforge.net/
  [3]: http://www.pythononachip.org
  [4]: http://www.eluaproject.net
  [5]: http://en.wikipedia.org/wiki/Interactive_C
  [6]: http://tinytcl.sourceforge.net/
  [7]: http://www.ittybittycomputers.com/IttyBitty/TinyBasic/index.htm
  [8]: http://bitlash.net/
  [9]: http://www.instructables.com/id/AVRSH-A-Command-Interpreter-Shell-for-ArduinoAVR/
  [10]: http://code.google.com/p/picoc/
  [11]: http://www.angelcode.com/angelscript/

What are the available interactive languages that run in tiny memory?

What best practices have you used in unit testing embedded software that are peculiar to embedded systems?

Unit Testing Embedded Software

I need a simple communication protocol between two devices (a PC and a microcontroller). The PC must send some commands and parameters to the micro. The micro must transmit an array of bytes (data from sensor).

The data must be [noise protected][1] (besides parity checking, I think I need some other data correction method).

Is there any standard solution to do this? (I need only an idea, not the complete solution).

P.S. Any advice is appreciated. *P.P.S Sorry for any grammar mistakes, I hope you understand.*

**Edit 1.** I have not decided whether it will be ***master/slave*** protocol or both sides can initiate communication. The PC must know when micro have done a job and can send data. It can continuously poll the micro if data is ready, or the micro can send data, when a job is done. I don&#39;t know which is better and simpler.

**Edit 2.** ***Hardware and [physical layer][2] protocol.*** Since [RS-232][3]C serial standard used in the PC, I will use [asynchronous communication][4]. I will use only RxD, TxD and GND signals. I can&#39;t use additional wires because the microcontroller AFAIK doesn&#39;t support them. BTW I&#39;m using the [AVR][5] ATmega128 chip.

So I will use fixed baud rate, 8 bits of data, 2 stop bits without parity checking (or with?).

***[Data link protocol][6]***. That&#39;s what my question primarily concerned about. Thanks for suggesting [HDLC][7], [PPP][8] and [Modbus][9] protocols. I will research on it.


  [1]: http://en.wikipedia.org/wiki/Error_detection_and_correction
  [2]: http://en.wikipedia.org/wiki/Physical_Layer
  [3]: http://en.wikipedia.org/wiki/RS-232
  [4]: http://en.wikipedia.org/wiki/Asynchronous_serial_communication
  [5]: http://en.wikipedia.org/wiki/Atmel_AVR
  [6]: http://en.wikipedia.org/wiki/Data_Link_Layer
  [7]: http://en.wikipedia.org/wiki/High-Level_Data_Link_Control
  [8]: http://en.wikipedia.org/wiki/Point-to-Point_Protocol
  [9]: http://en.wikipedia.org/wiki/Modbus

Simple serial point-to-point communication protocol

I am programming the host side of a host-accelerator system. The host runs on the PC under Ubuntu Linux and communicates with the embedded hardware via a USB connection. The communication is performed by copying memory chunks to and from the embedded hardware&#39;s memory.

On the board&#39;s memory there is a memory region which I use as a mailbox where I write and read the data. The mailbox is defined as a structure and I use the same definition to allocate a mirror mailbox in my host space.

I used this technique successfully in the past so now I copied the host Eclipse project to my current project&#39;s workspace, and made the appropriate name changes. The strange thing is that when building the host project I now get the following message:

&gt; Building target: fft2d_host  
&gt; Invoking: GCC C Linker  
&gt;  gcc -L/opt/adapteva/esdk/tools/host/x86_64/lib -o &quot;fft2d_host&quot;  ./src/fft2d_host.o   -le_host -lrt  
&gt;
&gt; ./src/fft2d_host.o: In function `main&#39;:  
&gt;
&gt; **fft2d_host.c:(.text+0x280): relocation truncated to fit: R_X86_64_PC32 against symbol `Mailbox&#39; defined in COMMON section in ./src/fft2d_host.o**

What does this error mean and why it won&#39;t build on the current project, while it is OK with the older project?


What does this GCC error &quot;... relocation truncated to fit...&quot; mean?

We have a daemon that contains a lot of print messages. Since we are working on an embedded device with a weak CPU and other constraint hardware, we want to minimize any kinds of costs (IO, CPU, etc..) of printf messages in our final version. (Users don&#39;t have a console)

My teammate and I have a disagreement. He thinks we can just redirect everything to /dev/null. It won&#39;t cost any IO so affections will be minimal. But I think it will still cost CPU and we better define a macro for printf so we can rewrite &quot;printf&quot; (maybe just return).

So I need some opinions about who is right. Will Linux be smart enough to optimize printf? I really doubt it.


Will printf still have a cost even if I redirect output to /dev/null?

I am working on an embedded system running Linux on a DSP. Now we want to make some parts of it scriptable and we are looking for a nice embeddable scripting language. These scripts should integrate nicely with our existing C++ code base, be small and fast.

I understand that Lua is the industry choice for problems like this. We will probably go with Lua because it is tried-and-true and proven to be stable and so on. However, as a programming language it has some rather quirky corners.

So, what alternatives are out there for embeddable languages?

__EDIT:__

This is about a year later.  

We actually used Lua on our embedded system and it performs marvelously well. Over time, we added more and more scripting support to more and more parts of the project and that really helped to bring it along.  

Performance is outstanding, really. Even rather complex operations that involve searching through long arrays or fancy string operations perform surprisingly well. We basically never ran into Lua related performance problems at all.

Interfacing with C functions is very straightforward and works really well. This allowed us to grow the scripting system painlessly.

Finally, we were astounded at how flexible Lua proved to be. Our Lua interpreter has to run on a system with a nonstandard memory allocator and without support for the double data type. There are two well-documented places in one header file we had to modify to make Lua work on that system. It is really well suited for embedding!

Alternatives to Lua as an embedded language?

I&#39;ve been curious to understand if it is possible to apply the power of Haskell to embedded realtime world, and in googling have found the [Atom][1] package. I&#39;d assume that in the complex case the code might have all the classical C bugs - crashes, memory corruptions, etc, which would then need to be traced to the original Haskell code that
caused them. So, this is the first part of the question: &quot;If you had the experience with Atom, how did you deal with the task of debugging the low-level bugs in compiled C code and fixing them in Haskell original code ?&quot;

I searched for some more examples for Atom, [this blog post][2] mentions the resulting C code 22KLOC (and obviously no code:), the [included example][3] is a toy. [This][4] and [this][5] references have a bit more practical code, but this is where this ends. And the reason I put &quot;sizable&quot; in the subject is, I&#39;m most interested if you might share your experiences of working with the generated C code in the range of 300KLOC+. 

As I am a Haskell newbie, obviously there may be other ways that I did not find due to my unknown unknowns, so any other pointers for self-education in this area would be greatly appreciated - and this is the second part of the question - &quot;what would be some other practical methods (if) of doing real-time development in Haskell?&quot;. If the multicore is also in the picture, that&#39;s an extra plus :-) 

(About usage of Haskell itself for this purpose: from what I read in [this blog post][6], the garbage collection and laziness in Haskell makes it rather nondeterministic scheduling-wise, but maybe in two years something has changed. [Real world Haskell programming][7] question on SO was the closest that I could find to this topic)

**Note:** &quot;real-time&quot; above is would be closer to &quot;hard realtime&quot; - I&#39;m curious if it is possible to ensure that the pause time when the main task is not executing is under 0.5ms.



  [1]: http://hackage.haskell.org/package/atom
  [2]: http://archhaskell.wordpress.com/2009/08/01/atom-a-domain-specific-language-for-hard-realtime-applications/
  [3]: http://hackage.haskell.org/packages/archive/atom/0.1.0/doc/html/src/Language-Atom-Example.html#example
  [4]: http://leepike.wordpress.com/source-code/atomfibhs/
  [5]: http://blog.sw17ch.com/wordpress/?p=111
  [6]: http://mikeburrell.wordpress.com/2007/02/01/real-time-haskell/
  [7]: https://stackoverflow.com/questions/1113226/real-world-haskell-programming

Using Haskell for sizable real-time systems: how (if?)?

RTOS and Embedded Linux are used for embedded systems programming. Is Embedded Linux itself an RTOS ? Can anyone list the comparison or difference please?

What is the difference between RTOS and Embedded Linux?

This issue is important especially for embedded development. Exception handling adds some footprint to generated binary output. On the other hand, without exceptions the errors need to be handled some other way, which requires additional code, which eventually also increases binary size.

I&#39;m interested in your experiences, especially:

 1. What is average footprint added by your compiler for the exception handling (if you have such measurements)?
 2. Is the exception handling really more expensive (many say that), in terms of binary output size, than other error handling strategies?
 3. What error handling strategy would you suggest for embedded development?

Please take my questions only as guidance. Any input is welcome.

Addendum:  Does any one have a concrete method/script/tool that, for a specific C++ object/executable, will show the percentage of the loaded memory footprint that is occupied by compiler-generated code and data structures dedicated to exception handling?

How much footprint does C++ exception handling add

Can someone explain the mechanics of a jump table and why is would be needed in embedded systems?

What is a jump table?

I&#39;ve been working in C and CPython for the past 3 - 5 years. Consider that my base of knowledge here.

If I were to use an assembly instruction such as `MOV AL, 61h` to a processor that supported it, what exactly is inside the processor that interprets this code and dispatches it as voltage signals? How would such a simple instruction likely be carried out?

Assembly even feels like a high level language when I try to think of the multitude of steps contained in `MOV AL, 61h` or even `XOR EAX, EBX`.



EDIT: I read a few comments asking why I put this as embedded when the x86-family is not common in embedded systems. Welcome to my own ignorance. Now I figure that if I&#39;m ignorant about this, there are likely others ignorant of it as well.

It was difficult for me to pick a favorite answer considering the effort you all put into your answers, but I felt compelled to make a decision. No hurt feelings, fellas.

I often find that the more I learn about computers the less I realize I actually know. Thank you for opening my mind to microcode and transistor logic!

EDIT #2: Thanks to this thread, I have just comprehended why `XOR EAX, EAX` is faster than `MOV EAX, 0h`. :)

How does an assembly instruction turn into voltage changes on the CPU?

I was reading a [blog post][1] by a game coder for [Introversion][2] and he is busily trying to squeeze every [CPU][3] tick he can out of the code. One trick he mentions off-hand is to

&gt; &quot;re-order the member variables of a
&gt; class into most used and least used.&quot;

I&#39;m not familiar with C++, nor with how it compiles, but I was wondering if 

 1. This statement is accurate?
 2. How/Why?
 3. Does it apply to other (compiled/scripting) languages?

I&#39;m aware that the amount of (CPU) time saved by this trick would be minimal, it&#39;s not a deal-breaker. But on the other hand, in most functions it would be fairly easy to identify which variables are going to be the most commonly used, and just start coding this way by default. 

  [1]: http://forums.introversion.co.uk/defcon/introversion/viewtopic.php?p=79603#79603
  [2]: http://Introversion.co.uk
  [3]: http://en.wikipedia.org/wiki/Central_processing_unit


Optimizing member variable order in C++

What methods are available for determining the optimum stack size for embedded/memory constrained system? If it&#39;s too big then memory is wasted that could be used elsewhere. However, if it is too small then we get this website&#39;s namesake...

To try to jump start things: Jack Ganssle states in *[The Art of Designing Embedded Systems][3]* that, **&quot;With experience, one learns the standard, scientific way to compute the proper size for a stack: Pick a size at random and hope.&quot;** Can anyone do better than that?

A more specific example was requested. So, how about a C program targeting an [MSP430 MCU][1] with 2 kB of RAM using the [IAR Embedded Workbench][2] toolchain without an operating system? This IDE can display the stack contents and usage while using a JTAG debugger.

  [1]: http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95&amp;tabId=140&amp;familyId=342
  [2]: http://www.iar.com/website1/1.0.1.0/50/1/index.php?
  [3]: http://www.amazon.com/Designing-Embedded-Systems-Design-Engineers/dp/0750698691

How to determine maximum stack usage?

I&#39;m writing the startup code for an embedded system -- the code that loads the initial stack pointer before jumping to the main() function -- and I need to tell it how many bytes of stack my application will use (or some larger, conservative estimate).

I&#39;ve been told the gcc compiler now has a -fstack-usage option and -fcallgraph-info option that can somehow be used to statically calculates the exact &quot;Maximum Stack Usage&quot; for me.
( [&quot;Compile-time stack requirements analysis with GCC&quot;][1] by Botcazou, Comar, and Hainque ).

Nigel Jones says that recursion is a really bad idea in embedded systems ([&quot;Computing your stack size&quot;][2] 2009), so I&#39;ve been careful not to make any mutually recursive functions in this code.

Also, I make sure that none of my interrupt handlers ever re-enable interrupts until their final return-from-interrupt instruction, so I don&#39;t need to worry about re-entrant interrupt handlers.

Without recursion or re-entrant interrupt handlers, it should possible to statically determine the maximum stack usage. (And so most of the answers to https://stackoverflow.com/questions/389219/how-to-determine-maximum-stack-usage do not apply).
My understanding is I (or preferably, some bit of code on my PC that is automatically run every time I rebuild the executable) first find the maximum stack depth for each interrupt handler when it&#39;s not interrupted by a higher-priority interrupt, and the maximum stack depth of the main() function when it is not interrupted.
Then I add them all up to find the total (worst-case) maximum stack depth. That occurs (in my embedded system) when the main() background task is at its maximum depth when it is interrupted by the lowest-priority interrupt, and that interrupt is at its maximum depth when it is interrupted by the next-lowest-priority interrupt, and so on.

I&#39;m using YAGARTO with gcc 4.6.0 to compile code for the LM3S1968 ARM Cortex-M3.

So how do I use the -fstack-usage option and -fcallgraph-info option with gcc to calculate the maximum stack depth? Or is there some better approach to determine maximum stack usage?

(See https://stackoverflow.com/questions/6375762/how-to-determine-maximum-stack-usage-in-embedded-system for almost the same question targeted to the Keil compiler .)

  [1]: https://www.adacore.com/uploads/technical-papers/Stack_Analysis.pdf
  [2]: https://embeddedgurus.com/stack-overflow/2009/03/computing-your-stack-size/

All Embedded Solutions on Gang of Coders

Total of 28 Embedded Solutions