Embedded Overview

Overview of embedded system development.

1. Memory
2. Storage
3. Power
4. Processing power

On ARM Processors:

• Unordered List ItemGenerally local variables are allocated in registers. However if we take the address of a local variable, compiler will not allocate the variable to register.
• The compiler will never put the global variable into register.
• Try to ensure that small functions take four or fewer arguments. These will not use the stack for argument passing. It will copied into registers.
• If a function needs more than four arguments, try to ensure that it does a significant amount of work, so that the cost of passing the stacked arguments is outweighed.
• Pass pointers to structures instead of passing the structure itself.
• Put related arguments in a structure, and pass a pointer to the structure to functions. This will reduce the number of parameters and increase readability.
• Minimize the number of long long parameters, as these take two argument words. This also applies to doubles if software floating-point is enabled.
• Avoid functions with a parameter that is passed partially in a register and partially on the stack (split-argument). This is not handled efficiently by the current compilers: all register arguments are pushed on the stack.
• Avoid functions with a variable number of parameters. Varargs functions

On Arm there is the “pure” keyword which tells the compiler the computation is all contained within the function so the compiler can optimize it as much as possible. Not dependent on outside variables.

Example:

__pure int square(int x)
{ return x * x;
}

On ARM processors pass in 4 or less parameters to functions, they will be put in registers and save stack space!

• Smaller data types are better
• use <stding.h>
• Use unit8_t not char, etc. More portable.
• Some processors short == int. Don't assume bit size

IEEE754 standard

• float 32 bits, 6 decimal places
• double 64 bits, 15 decimal places
• long double 80 bits, 19 decimal places

FPU - Floating point unit Does not take extra power Takes less procesisng power Make sure you need floats More memory needed when switching thread contents

Look at the *.map file at the end to see program memory usage ZI = Zero initialized data RW Data - read/write data

Binary can be like: 0c000100 Remember XOR! Great Macro:

#define MASK(0) ((uint8_t(1<<x))

Better use of memory.

typedef union {
	struct{
		unsigned monday : 1;
		unsigned tuesday : 1;
		unsigned wednesday : 1;
		unsigned thursday : 1;
		unsigned friday : 1;
		unsigned saturday : 1;
		unsigned sunday : 1;
      	} days;
	uint8_t byte_sized;
} weekdays;

weekdays active_days;
active_days.days.monday = 0;

Being specific about variables

Volatile – tells the compiler that the variable may change at any time by some source other than the code it’s compiling. This may avoid the compiler optimizing out a section of code that appears to never get execute due to a conditional.

• Blocking delays
• Loops that loop to delay
• Use volatile to avoid optimizing loop out

• Stored in ROM, use less space.
• #defines are simply replaces in-line by the compiler, canbloat.
• #defines are not visible to the debugger
• Try to use const if you can

• Functions use a lot of memory for the stack
• Lookup tables and inline functions use ROM
• Lookup tables are easy on the CPU
• Lookup tables are const arrays. Use const
• Limitations: values are discrete so you may have to use interpolation

#define square_macro(x) x*x
* part of the pre-processor

Error!

Square_macro(2+3) == 11, wrong answer!

* Macros should be one line
* Always in-line function. Bloat may occur, function would be better

• Almost identical to regular functions
• Add the “inline” keyword
• The compiler may decide not to inline
• You can force the compiler to always inline

To force inlining:

	Int square_AI(unsigned char x)__attribute__((always_inline));
	Int square_AI(unsigned char x) {
		Return x*x;
 	}

To suggest inlining:

	Int inline square_SI(unsigned char x){
		Return x*x;
	}

Inline advantages over macros:

• Compiler checks parameter types
• Debugging is easier

• Note that for a float 100,000,000.00 + 1.00 = 100,000,000.00!
• Use fixed point when you can anticipate the range
• Fixed point can be faster than float on processors without an FPU

Design an elevator. Think about it, there are some user controls and indicators that need to be implements, some sensors and auto controls, some for safety.

Process car calls Process hall calls Indicate direction indicate current floor

Move and stop the car Emergency brake Open/close the door