(Part 2) Best products from r/embedded

I would actually advise against a development board. The time spent getting up to speed on the MCU/SOC, tooling, datasheet style, etc, is huge. Usually for most designs the IC is chosen specifically to cater to the design. For example, one design needs very low power (like an MSP430), one needs many fast ADC's, one needs one or two high resolution but slow ADC's, one needs a very beefy CPU with tons of RAM, etc. It's unlikely that the knowledge gained from that development board will translate well to other designs.

Instead, consider getting them a tool. An oscilloscope is always a very safe bet, but they tend to be a few hundred dollars. The DS1054z is cream of the crop for hobbysts right now, and is $350 roughly.

If you need cheaper, then a nice proper soldering iron like the TS100 here for $80 with a few tips is a very, very, safe bet.

Those tools will stick with him/her for years and years and will be used often. The development board on the other hand likely won't.

If you must go for a development board, I would actually recommend a teensy for $30 instead of something like an Arduino. The teensy 3.6 is an awesome platform that is very arduino like but uses an actually modern beefy MCU on it. The library support for it is fantastic, and it has a decent bit of I/O for future designs. It also uses a Kinetis chip which is in my opinion very well documented, so once he has to go beyond the Arduino library he can easily do it himself.

Then on the side, get him an ESP32 which is very cheap. Sparkfun has their own ESP32 module for $20 but is very thoroughly documented. You can get them cheaper form Amazon for like $10 like this. The cool thing about the ESP32 is it's insanely cheap and very well documented in terms of API. If he wants to use an ESP32 in a design, you can get modules for $4 each. This thing is a very fast chip with Wifi built in and very easy to work with.

TLDR; Get him an ESP32 module for like $20 and a Teensy 3.6 for $30 and he should be set. Ideally get him a piece of equipment like a TS100 for $80 or a DS1054z for $350 if you are willing to spend that much money.

Not sure what your budget is (buy used books or South Asia editions), but you may find the following useful :-)

Also, unless required, avoid programming in assembly but use C/C++ exclusively. This allows you to carry over much of your acquired knowledge across various MCU families.

• Make: AVR Programming This will teach you programming directly-to-the-metal on AVR using C. If you have the Arduino IDE installed, you already have the "avr-gcc" compiler toolchain as part of the package and hence you just need to setup your path and use the the toolchain in your Makefile. The book takes you by hand and shows you everything. Note that you can use the same Arduino board to do both "Arduino language" programming and "AVR C" programming.
  
  
• Designing Embedded Hardware Excellent overview of the hardware aspects of Embedded Systems. As a Software guy, this book is the one which clarified hardware for me.
  
  
• Building Embedded Systems: Programmable Hardware A very good book on all practical aspects of embedded programming. Hard-won knowledge which will make you a "professional" embedded engineer.
  
  
• Introduction to Embedded Systems: Using Microcontrollers and the MSP430 Excellent and comprehensive textbook detailing the hardware and software aspects of embedded systems. Every topic starts with an illustrated overview of the hardware and then shows you how to program for it.
  
  
• Embedded C Introductory book on C programming for 8051. The example code is simple and direct thus enabling you to grasp the concepts clearly.
  
  
• Patterns for Time-Triggered Embedded Systems Comprehensive and full of C code showing how to program all standard peripherals for an 8051. You can translate the code to your favourite MCU family. The book is available for free from the author's company website.
  
  
• ARM System Developer's Guide An oldie but still the best for firmware programming on the ARM microprocessor.
  
  
• Practical Microcontroller Engineering with ARM technology An exhaustive book on programming the Tiva version of the ARM Cortex-M4 MCU. The book reads like a manual but the ARM Cortex is complex enough that there is no easy way to learn it.
  
  
• The Engineering of Reliable Embedded Systems Advanced book showing how to implement industrial quality embedded software on various ARM platforms. The 1st edition of the book was available for free on the web.
  
  and finally;
  
  
• Computer Systems: A Programmer's Perspective A must-read textbook to understand the low-level details for a x86/x86-64 system. Many of these details are similar for MCUs and hence you will understand them better.

Here is a breakdown of what you need to do/know as an Embedded Developer (STM32 based):

1- Understand your tools.

Understand how to use embedded development tools such as compilers, debuggers (hardware and software) and built environements. You can go the GCC-ARM+Make+openOCD/texane_stlink route but this is a time-consuming process and though I do recommend it, it is not necessary. Almost all vendors have a free development IDE available nowadays. For STM32, have a look at their System workbench IDE developed along with AC6. It is eclipse based and includes compiler and integrated openOCD for debugging. The STM32CubeMX code generator is also a very nice tool.

For debuggers, there are plenty of official and unofficial STLink debuggers that can be bought for anywhere between $5-$200. The cheaper ones work great. All ST-Nucleo boards come with built-in debuggers. If you intend to use other ARM chips have a look at the JLink debugger. It's more expensive but worth every penny.

For simply programming the STM32, you can use the STLink debugging hardware, ST-Nucleo drag and drop programmer, or the bootloader. All STM32s come with builtin USB/Serial bootloaders that can be activated via changing voltage levels on the BOOT0 and reset pins. This is a really neat feature that all STM32 developers need to be familiar with.

​

2 - Understand your hardware.

Read the reference manual for whatever chip that you are interested in. Know the chips memory map. You also need to understand how to perform bitwise manipulations in C. Specifically you need to be able to:

- set/clear & toggle one or more bits in a register

- test the state of a particular bit or group of bits in a register

You should leverage the information in the reference manual and knowledge of bitwise manipulation to write your own simple GPIO and Serial driver functions (polling based). Same goes for simple peripherals including SPI, I2C, ADC, DAC, Timers, PWM, and even the onboard DMA.

You also need to be familiar with the CPU's/SOC's Interrupt architecture i.e. how to enable/disable interrupts globally, locally and write your own Interrupt subroutines.

If you can do this then you understand the hardware enough to bend it to your will. You do not need to know the CPU architecture i.e. pipelining, caching e.t.c though it does not hurt and will occasionally come in handy.

​

3 - Understand how to use the hardware vendor's provided API.

Writing your own drivers is great but the hardware vendor's API provides better portability and is `usually` better tested and supported than custom drivers. Also writing custom drivers for more advanced peripherals such as USB, Ethernet, SD card interface e.t.c. can be quite a challenge. It's better to utilize the available vendor API instead for those big boy peripherals . Don't try to jump directly to the Vendor API for all peripherals though. Understand the hardware and at least build and test a couple of simple custom drivers as mentioned in step 2.

​

4- Understand how to use an RTOS.

Nowadays more and more projects rely on a real-time operating system(RTOS). FreeRTOS is a very good and popular choice. Learn how to use it. RTOS knowledge and use is essential for large embedded developer projects.

​

Books:

- Carmine Novello's Mastering STM32

- Muhammamd Ali Mazidi's STM32 Arm Programming for Embedded Systems

- Jim Cooling's Real-time Operating Systems Book 2 - The Practice: Using STM Cube, FreeRTOS and the STM32 Discovery Board

- Warren Gay's Beginning STM32

Good luck

So first, here's the general model by which simple MCU-based embedded devices are constructed. As you've probably already learned, the MCU consists of core components -- in the case of the STm32, instruction execution core, RAM, flash -- and a bunch of peripheral controllers.

Those peripheral controllers may control a peripheral contained on the MCU itself (like maybe an RTC), but they often control external components that are still part of the same board (e.g. GPIO). Some of these peripheral controllers are bus controllers that allow software to communicate with external components attached to standard buses like I2C, SPI, PCI, USB, etc. In many cases, these external components expose registers that software running on the MCU can read and write in order to tell the external peripheral what to do.

Typically, these days, your MCU vendor (e.g. STM) will provide a library that provides high-level functions for working with the on-chip peripheral controllers. So, for instance, if you have I2C devices connected to the STM32, there will be a library with I2C functions, that allow you to read and write registers on those devices. Under the hood, these peripheral controllers themselves are also controlled by registers, access via MMIO, which are read and written just like RAM.

So the key is not to worry about learning "all the STM library functions"; none of us do that. Because whatever software you write is dependent on the hardware you are working with -- what is connected to the MCU and how? -- and so you really only have to focus on the STM library functions that support those peripheral controllers. So a good starting point is to look at the schematic for your board, figure out what's hooked up to the MCU and how, and then think about what external (to the board) components you want to add, and how.

For instance, you've mentioned LEDs, which can obviously control via GPIOs. But there are also external LED controllers that sit on I2C or SPI interfaces. So what is your board using? If you are using an I2C LED controller, you'd look at the datasheet for that controller to see what registers it exposes, and what sort of I2C message formats it expects the MCU to use to talk to it. You can then look at the I2C section of the STM library, see what functions it provides, and match those up with what the part supports.

If your MCU could have an internal audio codec, but external ones are pretty common, and typically rely on PCM, I2S, or SPI interfaces for sending and receiving audio data, often in conjunction with an I2C control interface. You would then have to rely on the STM32 peripheral controller libraries for communicating (for instance) via I2S and I2C.

Also, typically, vendors like STM will provide sample code demonstrating how to use its peripheral controller libraries, so I would lean heavily on those samples.

Ultimately, what I would suggest is something simple to get your feet wet, to help you understand this basic model. Practically every board I work has at least one I2C part on it, so that's a good starting point. If your STM board already has an I2C device on it, you can practice reading and writing registers on that part. Otherwise, assuming your STM board brings out an I2C interface on a header, you can buy something like this.

So I found the book C Interfaces and Implementations, which looks pretty good. Do you have any other recommendations for design pattern books?

I have been following the Linux kernel style guide for a while and I am pretty happy with it. I have skimmed some random kernel code a few times but always felt actually diving in and seriously reading it would require a big time commitment, maybe better to start with something smaller first like Contiki...

As already mentioned Mastering Embedded Linux Programming is a very good book about the topics you're interested in. Did you also have a look at Building Embedded Linux Systems? There is also Embedded Linux Primer, 2nd Edition, by Chris Hallinan, or Linux for Embedded and Real-Time Applications, 3rd Edition, by Doug Abbott, which are very good. Each covers the topics you're interested in; by the end of the day it's quite subjective which writing style you prefer.

I second freeRTOS. Pick up an Atmel dev board. They have good support for freeRTOS. Big concepts here will be stack management, mutex/semaphores for thread safe operations, using message queues to communicate between threads, blocking/non blocking operations, and find a profiler so you can visualize your efficiency.

For driver development I will point you towards Linux. Try writing a basic storage or GPIO driver on a raspberry pi. I have linked a book below that will help with understanding Linux drivers. The big thing is you will have to use ioctl calls to communicate with your driver.
Link to book!

Those are really nice and are the current generation of AVR programmer/debugger, but is a little more than what it seems like you need here. There are multiple options for programming an attiny, depending on how much or little work you want to do.

Probably the easiest way(and cheaper than the ICE) is an older avrisp2. Note that you will need a breadboard or adapter board to connect to the attiny(this applies for any programmer and any chip!)

If you just want to be able to plug in a chip and read/write it, look at sparkfun's Tiny AVR programmer. I don't know if it works with AVR studio(Atmel's official IDE), but it works with avrdude. avrdudess is a nice gui frontend for avrdude.

If you happen to have an arduino(they're cheap at microcenter if you have one close) you can use it as an avr programmer(just ignore the stuff about burning the bootloader - you won't need to do any of that). You can use avrdudess to read and write the attiny.

I usually just slip the board back into the ESD bag it came in before storing it. If you managed to buy a board without an ESD bag, you can pick some up pretty cheaply on Amazon.

Other than that, I've not taken much precaution while working with dev boards (though I do refuse to hand a board directly to someone else if we're not both grounded--I always set it on a table and make them pick it up) and, in 16 years, I've never damaged one with ESD. However, I consider myself lucky. If you live someplace especially dry or you seem to be especially static-prone or you're working with boards that you absolutely cannot afford to fry, then you might buy an ESD mat and grounding strap to use when handling your boards. Here's an option from Amazon (first search result, you might look around a bit before purchasing): https://www.amazon.com/Bertech-Wrist-Strap-Grounding-0-093/dp/B00O0Q03KM

For storage though, an ESD bag should be more than sufficient.

You made my day. Thank You!


I would have told them to hold out for a Ferrari as a signing bonus. Of course you have to be careful to read the fine details in the contract, least be surprised when it is delivered.

I have this book, it's pretty good. Jonathan Valvano is a professor at UT and his course is on edx.

Embedded Systems: Real-Time Operating Systems for ARM Cortex-M Microcontrollers https://www.amazon.com/dp/B01N9P9RNA/ref=cm_sw_r_cp_apa_i_h3zSDbVBTD4WS

>This book, now in its fourth edition (January 2017), is the third in a series of three books that teach the fundamentals of embedded systems as applied to ARM Cortex-M microcontrollers. This book specifically covers the TM4C and MSP432 microcontrollers; however, it could be used with any Cortex-M microcontroller. This third volume is primarily written for senior undergraduate or first-year graduate electrical and computer engineering students. It could also be used for professionals wishing to design or deploy a real-time operating system onto an ARM platform. The first book Embedded Systems: Introduction to the ARM Cortex-M Microcontroller is an introduction to computers and interfacing focusing on assembly language and C programming. The second book Embedded Systems: Real-Time Interfacing to ARM Cortex-M Microcontroller focuses on interfacing and the design of embedded systems. This third book is an advanced book focusing on operating systems, high-speed interfacing, control systems, robotics, Bluetooth, and the Internet of Things.

you could get something like this.

maybe use some LEDs to indicate movement detection or lights on/off in a room. Maybe store a record to a text file of the times whatever you are tracking was detected.

Maybe get a wifi dongle like this. and have it so you can ssh into the r_pi and monitor the log files? If you are feeling really productive, maybe have the r_pi act as a web server and update a webpage with the data/most recent images so it would basically be a security camera.

Those kind of ideas are what I immediately think of with raspberry pi... but you may want to start a lot smaller. like just detecting movement and lighting an LED since you are just learning C++ now.

I found this one very helpful

https://www.amazon.co.uk/Definitive-Guide-Cortex%C2%AE-M0-Cortex-M0-Processors/dp/0128032774

This is the one I have:

https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903