http://stackoverflow.

com/questions/17210254/embedded-developer-what-skills-are-i
mportant
C essentials
OOP/ C++ - classes, encapsulation, polymorphism, overloading/ overriding, templa
tes
Algorithms - search, sort, b-trees
Design Patterns - factory, observer, singleton etc.
Real Time Operating Systems - primitives (semaphore, mutex), scheduling techniqu
es, user/ kernel space
Linux fundamentals, driver writing, shell
microprocessor fundamentals - interrupt processing, registers, assembly code, et
c.
microcontroller fundamentals - ADC, DAC, Timers, PWM, DMA, watchdog, etc.
Memory - NOR, NAND, SRAM, DRAM, wear levelling
Basic protocols - I2C, SPI, UART, LIN
Advanced protocols - SATA, PCIE, USB, CAN, MOST
Concurrent/ parallel programming - MPI for SMP etc.
UML - class diagram, component diagram, state diagram, sequence diagram
Perl or Python for scripting, for e.g. to modify simple text files.
Java and Android
Basic electronics - schematics reading, using oscilloscope, multimeter, solderin
g iron
Specialized techniques for embedded programming e.g. debouncing of switches, res
istive ladder switches, rotary encoders, etc.
software engineering - SDLC, CMMI, agile methods e.g. SCRUM, version control (Cl
earCase, git, svn), bug tracking (JIRA?), static code checking, Lint, unit testi
ng, continuous integration
build environments - makefile, cmake
Basic FPGA/ ASIC design, basic DSP
http://electronics.stackexchange.com/questions/3343/how-to-become-an-embedded-so
ftware-developer
Learn C: The fundamental language of the hardware that is still portable (too so
me degree). Don't just learn it, but become an expert of all it's features like
volatile and why it is important for writing device drivers.
Start out with a good development kit like Arduino, but as said before learn oth
er architectures once you got a good feel for it. Luckily there are some Arduino
compatible boards built with other processors, that way you can rewrite the sam
e design on a different uC not mess up your whole design while getting a feel fo
r something new.
In the learning stage, feel free to re-invent the wheel on device drivers or oth
er pieces of code. Don't just plop someone else's driver code down in there. The
re's value in re-inventing the wheel when you're learning.
Challenge yourself to re-write your code more efficiently in terms of speed and
memory usage.
Becoming familiar with different styles of embedded systems software architectur
es. Start with basic interrupt driven/background loop processing, then move up t
o background schedulers, then real-time operating systems.
Get good source control! I prefer Mercurial myself.
Even sign up for some free source control hosting sites like Sourceforge.net or
Bitbucket.org to host your project even if you're the only one working on it. Th
ey'll back your code up, so you don't have to worry about that occasional hard d
rive crash destroying everything! Using a distributed VCS comes in handy, becaus
e you can check in changes to your hard drive then upload to the host site when
ready.
Learn your tools well for whatever chip you're working on! Knowing how the compi
ler creates assembly is essential. You need to get a feel for how efficient the
code is, because you may need to rewrite in assembly. Knowing how to use the lin

ker file and interpreting the memory map output is also essential! How else are
you going to know if that routine you just wrote is the culprit of taking up too
much ROM/Flash!
Learn new techniques and experiment with them in your designs!
Assume nothing when debugging. Verify it!
Learn how to program defensively to catch errors and verify assumptions (like us
ing assert)
Build a debugging information into your code where you can such as outputting me
mory consumption or profiling code with timers or using spare pins on the uC to
toggle and measure interrupt latency on a O-scope.
https://www.quora.com/What-are-the-list-of-skills-that-every-embedded-software-e
ngineer-must-have
rom a theoretical point of view, the study of following areas is important:
1.) Computer Organization
Visualization of the components that make up the system. You are assumed to know
the hardware layout of the embedded system when writing software for the same.
In other words, one needs to be aware of different peripherals connected to the
system, and the buses involved.
2.) Operating Systems
The basic software needed to run any system. This is what an embedded software e
ngineer would mostly work on. But more importantly, unlike desktop systems, oper
ating system software for embedded systems has a huge design space. This is beca
use there are multiple optimizations and tradeoffs allowed to be made, depending
on the purpose of the system. Contrast this to a general purpose desktop system
where you would have almost all rudimentary hardware. Resources are limited in
an embedded system, so you need to be familiar with each one of them, to know wh
at not to include in the design.
Now, from an implementation point of view, there are multiple tools, which if yo
u master can ease your life up a bit. I list them here in (IMO) decreasing order
of utility. I would recommend to explore the features of each and try to develo
p your own working habits.
Low level Programming Language - AFAIK, only C and assembly come to mind.
Master your C concepts. That should automatically send you chasing concepts on h
ow the software and hardware work in unison.
This should be a good start : C PUZZLES, Some interesting C problems
Source Browser - cscope works well for C and C++ codebases.
Vim/Cscope tutorial
Using an advanced editor - Vim is my favourite. The basic idea is to edit progra
mmatically. For example, using macros to group a sequence of commands and then e
xecuting it over various sections of the file. Coupled with cscope, vim helps yo
u develop a nice workflow. Multiple Window features is an absolute blessing. The
ability to go back and forth between cscope and vim interfaces shouts "nice int
egration".
Seven habits of effective text editing
Scripting - I would recommend getting familiar with Python and Bash, especially

for text formatting. I am a big fan of piping various text processing tools toge
ther to form one specifically tailored to my purpose.
Dive Into Python is a good book for programmers.
Version Control - Not inevitable, but is surely something that you would thank y
ourself for learning.
I would recommend GIT. Git - Book
Based on my almost 40 years of working in the embedded systems field, these are
- IMHO - the minimum must have skills/knowledge:
A good understanding of digital and small signal analog electronics.
Ability to read and understand schematics.
Ability to effectively use a Volt/Ohm meter and an Oscilloscope.
Ability to perform at least basic electronics debugging/troubleshooting.
Competency in at least one assembly language.
Competency in the C programming language.
A good understanding of microprocessor internals (mostly the registers).
An understanding of memory regions, and their uses (heap, stack, IVT, code).
Working with hexadecimal numbers and hexadecimal math.
A very good understanding of boolean math (logic).
An excellent knowledge of what interrupts are and how they work in code.
An understanding of the different kinds of memory (RAM, ROM, Flash), the differe
nces between them and how they are read, written, accessed.
An understanding of multi-tasking (in the embedded world we use the original ter
m multi-tasking . The term multi-threaded was a term somebody made up later to mean t
he exact same thing. What others call threads we have called tasks since the 1970s).
Ability to use a debugger to perform at least simple operations such as setting
breakpoints, single stepping, examining variable values, examining memory, exami
ning registers - and understanding the when to enable and disable interrupts whe
n single stepping using a debugger.
Ability to debug multi-tasking code.
The ability to read and understand datasheets, and produce driver code for a giv
en device based on the information contained in its datasheet.
Understanding the advantages & disadvantages of using a foreground loop with int
errupts vs. using a multi-tasking kernel.
Developing code to run under an RTOS (Real Time Operating System), and how to us
e semaphores, mutexes, queues, inter-task communications.
How to develop and debug code for peripherals such as UARTs, A/D & D/A converter
s, timers, PWM generation from a timer, real-time clocks, etc.
How to develop and debug code for communications using RS-232 (and it s variants),
SPI, I2C, and parallel data ports.
How to develop and debug code with stacks, queues, linked-lists, and other commo
n data constructs.
A good understanding of DMA (Direct Memory Access), and how to implement it for
systems which have DMA capability.