What are /r/embedded's favorite Products & Services?

From 3.5 billion Reddit comments

As an embedded firmware developer recently interested in game design, I can maybe give you some pointers.

Arduino is more a maker tool than an engineer one, but is definitely good to get you started. Think about Arduino like you think about some simple game engine (like GameMaker Studio?): there's certainly people making impressing stuff with it, but pros won't consider it powerful/flexible enough. (I hope my analogy works; I'm still new to game design haha)

The book Making Embedded Systems from Elecia White is pretty good. It is beginner friendly and it's quite good at explaining typical embedded system trade-offs.

Hello! I would recommend this book: https://www.amazon.com/Writing-Efficient-Code-Thorough-Introduction/dp/1530414156/ref=mp_s_a_1_1?keywords=jonas+Skeppstedt&qid=1576967771&sr=8-1

It covers a lot of subjects but there is some great chapters on multicore programming and cache memory interactions and threading which is the basics of multicore programming.

That's where I started then I would continue to work with rtos. Make a event driven system. Somting working with the publisher subscriber pattern ��

I know a lot of embedded devs are quite dogmatic about volatile, but I am of the opinion that volatile is overused.

For memory mapped IO it makes perfect sense. For variables that are somehow shared and you hope volatile will fix your issues, not so much.

I remember Linus had a quite good breakdown on volatile and I think he is right.

https://www.kernel.org/doc/html/v5.5/process/volatile-considered-harmful.html

https://yarchive.net/comp/volatile.html

When I know that an interview is gona be technical - I run through Expert C Programming: Deep C Secrets by van Linden. It's pretty dope - not boring and goes pretty deep on the low-level stuff.

The book Real-time C++: Efficient Object Oriented and Template Microcontroller Programming is a great reference for exactly what you are looking for. It goes over concepts like encapsulating peripheral I/O in efficient classes, useful C++ language constructs like constexpr, and even extending the language to get for example std::chrono to work with your micros clock tick. Would recommend

> while being similar to QNX or other commercial offerings such as VXWorks?

The Zephyr kernel originates from Wind River Systems (the company behind VxWorks), for what it's worth. I am currently evaluating Zephyr for a STM32 project. It is really impressive, well thought out abstractions, and a lot of useful infrastructure. I won't hesitate to recommend it ... but, it is a young project. Not being comfortable with C development might be a showstopper in terms of even getting up and running with your basic peripherals (depends on your board).

> Would I need experience with C or C++ [...] I have experience with Linux

Well yes, but don't let that stop you, a real-world project is an excellent way to learn. Zephyr has "inherited" the DeviceTree system from Linux, which I personally like a lot, docs on Zephyr DeviceTree. But it probably won't really do you any good unless you've been doing low-level work with Linux.

Personally I would pick the OS based on how much (or how good) code is available for MCU, peripherals and other hardware in your project. If you can be running on FreeRTOS tonight, but Zephyr doesn't support your MCU at all... well... Try to avoid as much low-level work as possible and get along to writing application code.

You can buy 2 cheap usb to 485 plugs from amazon like this, as thats the most common hardware standard to talk over modbus

And wire them together and write a py script that talks to itself or annother script across 2 com ports

Python has modbus libraries and code implementations on github if you want to write and modify your own modbus functions

Yes! This knowledge is important, very important. And the questions were pretty basic in my opinion. But hey, we all mess up simple stuff in life at one point or the other. So chill.

Get a good book, maybe this one: https://www.amazon.de/dp/0124080820/ref=cm_sw_r_cp_apa_glt_i_D7WAQAJFK5KQ04QJKVFF

Learn about the arm arch and if there are general computer science concepts you find you don't know look up on google.

If you are more of a video course guy, look at courses by fast bit academy on udemy and also on youtube.

Happy learning.

1) Work toward a clear, concise style of writing code. Use the Linux kernel style as a starting point. https://www.kernel.org/doc/html/v4.10/process/coding-style.html

2) K.I.S.S. Don't fret about learning to implement some esoteric sorting algorithm for embedded systems. There are usually so few things stored that I when search that I usually just linear search and don't worry about sorting. The code is dead simple that way and easy to understand for the next person who picks it up.

3) For most embedded systems, some amount of determinism is desired. Write code with an eye for average execution time, best case and worst case. For example, a linear search of a small array of objects is O(n), 1 at best n/2 on average and n at worst. But if you have a priori knowledge of requests, you can make the search tend toward 1, not n.

4) With regard to algorithm knowledge, most compilers come with implementations of searching and sorting algorithms that have been tested, eg qsort, bsearch. Most employers will ask questions about linked lists. I do not know why. In practice, on microcontrollers, I avoid them like the plague.

doxygen can do that if you use the EXTRACT_ALL option in the doxyfile.cfg .

It can genrate .svg call & includes graphs using graphviz.

​

Another option is Sourcetrail, but this needs a bit more config, espcially if you have an niche toolchain / no makefiles, ...

Bootlin course materials are amazing IMO. Also using the book : Embedded Linux driver development is a pretty good way to start writing device drivers.

Yes it is true. You can read why here

https://www.kernel.org/doc/html/v5.12/process/coding-style.html#typedefs

I follow the Linux kernel conventions of not using typedef for structs and I do that even for non Linux MCU work. Before working on the kernel I used to use typedefs but I now find it much clearer without them (for structs). Typedefs are stilll good for numeric types that may be different on different systems.

This was my first (and only) book I used for 8051 programming, maybe it helps...

https://libgen.is/search.php?req=The+8051+Microcontroller+MacKenzie&open=0&res=25&view=simple&phrase=1&column=def

To be honest, we don't promote any IDE. It is up to the developer which IDE or OS to use. Our goal is to give developers freedom.

Nevertheless, to reduce "bounce rate" (when people never heard about any IDE or embedded, and do not which to choose), we propose default solution which is very simple and easy for using. This is PlatformIO IDE.

Previously we created an extension for Atom editor and later for VSCode. VSCode provides better support for C/C++ projects.

In any case, you can use your favorite OS and IDE in pair with PlatformIO. See supported list https://docs.platformio.org/en/latest/ide.html

From my experience (and that of a few other peers), I would still do some leetcode in C++ since there's a few things that they do like to quiz on.

According to this page ( https://www.freecodecamp.org/news/how-to-landing-your-embedded-software-dream-job-4ff9674bf1c4/ ), you should study:

• Algorithmical complexity
• Pointers
• Arrays
• Linked Lists
• Strings (although I personally haven't seen one on strings and a lot of times they can be seen as array questions)
• Stacks and queues

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.

If you're working with Yocto then this sounds like an embedded Linux position.

There's a pretty good book called "Building Embedded Linux Systems" that can get you up to speed.

Also pick up "The C Programming Language" by K&R

Some more suggestions:

• The Linux Programming Interface by Michael Kerrisk

• Linux System Programming by Robert Love

Feel free to PM me with any questions. I was in the same position as you about 10 years ago. Get ready to read, a lot.

We introduced in our project kconfig for the interactive header creation for different variants and test builds of needed.as it is ide independent. https://www.kernel.org/doc/html/latest/kbuild/kconfig-language.html

I'd highly recommend going with cmake. It's way more human readable comparing it to Makefile. Actually it will generate a Makefile for you so you can build actual firmware.

When it comes to hal you have option to use ST's C hal, or if you want to go full C++ there are quite few modern C++ STM32 hal libs out there. To be honest I've never tried any yet. The project I'm currently working on is based on STM32WB and I'm using ST's C hal, application layer is in C++, and I'm using cmake for build automation.

This blog might be a good starting point https://dev.to/younup/cmake-on-stm32-the-beginning-3766

And when you get into actual multi core systems where you have a hierarchy of caches (think newer X86-64 systems where you have registers, L1, L2, L3, and memory).

> force the compiler to reload the variable every time it's accessed.

What does this mean if you are modifying a word which spans across two cache lines and another thread is acting on that variable? Then you play into what sort of memory ordering you want, do you want it to be relaxed? Do you want to make sure it gets physically written to RAM? What about when you have a NUMA system, like the 2700x which has two CCX's?

These questions are already answered in C++ via atomic's and an explicit memory model, and part of the reason why volatile is getting deprecated for many use cases. For C, the linux kernel also has it's own alternative, such that volatile is incredibly frowned upon, and to be used only in extremely rare circumstances.

That original sentance I quoted above becomes far too nuanced for such systems. Personally, I would very quickly abandon volatile in embedded, even for MMIO, and replace accesses with explicit std::memory_order and whatnot.

Linux has a driver for the SAA7134. I would try a Linux that has that module (https://www.kernel.org/doc/html/v4.10/media/v4l-drivers/saa7134.html) and it should come up as a video capture device. You might read the Linux source to understand how it works.

If your board has a TV tuner chip, you'll need to figure that out too. You might check here first though: https://www.linuxtv.org/wiki/index.php/Saa713x_devices

I work with STM32s a lot. Great little processors. While I've used freeRTOS, I actually prefer QP (http://www.state-machine.com/). It's free for non-commercial use. I have a couple of projects that I released that use the STM32941-EVAL board but they can be modified to run on the Discovery board fairly easily: https://sourceforge.net/projects/stm324x9ievalqpcportwithlwip/

There's also a client that works over serial and ethernet in the same project.

Yes, Lego Mindstorms. There's some pretty cool stuff there. Definitely not a bad place to start for little ones.

I think Scratch also has some ability to integrate with Arduino hardware, but I don't remember how.

The full manual can be found here: http://www.doxygen.nl/manual/docblocks.html

In case that would apply here would be the inline comments:

The line

uint32_t aaa; //[0x8001FE04] Base Trap Vector Table Pointer

Would turn into something like:

uint32_t aaa; /**< [0x8001FE04] Base Trap Vector Table pointer */

Search that page for "Putting documentation after members"

I would probably also add the \struct documentation as well.

Keep in mind that Arduino IDE and API are 2 orthogonal things. You can use another IDE and still code using the Arduino API.

PlatformIO uses VSCode or Atom: https://platformio.org/platformio-ide

Take the basic circuits or digital logic course(s) if you can. You will definitely need to know how to read a schematic. If you are not an accomplished self-learner, the basic courses will make it much easier for you.

You also might want to learn about serial protocols (such as SPI) and maybe something popular at the moment like touch sensors:

http://hackaday.com/2012/05/27/making-capacitive-touch-sensors-with-pencil-and-paper/

Many/most embedded engineers also need to have a fair bit of electronics experience, since embedded systems are most often found in electronic devices. You'd be writing code that runs on toasters and thermostats and similar.

Personally, I'd start with something like:

https://www.amazon.com/EL-KIT-001-Project-Complete-Starter-Tutorial/dp/B01CZTLHGE/ref=sr_1_5?dchild=1&amp;keywords=arduino+starter&amp;qid=1627286549&amp;sr=8-5

To get some of the low-level electronics knowledge. The main disadvantage of the arduino platform for learning embedded is that it hides a lot of the stuff an embedded systems engineer will want to know. However, you can also throw the arduino stuff away and program the chip directly to gain more knowledge.

Then, I'd get something like an ESP32 and learn how to connect it to something like AWS IoT or similar services at Microsoft or Google. Maybe take some of the sensors from your arduino kit and use those.

Note that like arduino, there are tools for the ESP32 which hides a lot of the complexity. You'll want to throw that away and use native development and probably FreeRTOS to gain the experience you'll need.

have you considered the stm32 family? it's far more popular with wide applicability. your effort is stretched further...

also i'd imagine it's easier to find good resources to learn it. i used the warren gay's book [https://www.amazon.com/Beginning-STM32-Developing-FreeRTOS-libopencm3/dp/1484236238 ] which used parts easy to source.

&#x200B;

now to be reaching into other micros like the above, i plan on picking on rust programming. it's ecosystem has a generalised framework for all architectures! again more bang for your effort.

Working in a regulated environment for over 20 years, I've seen and written a lot of architecture and design documentation.

You aren't going to be able to extract and architecture from the code automagicaly. Its going to require reading and understanding the code at a high level.

To document the architecture you break the system into a series of "views". A view is one way of looking at the system.

Example views are:

Module - List all the modules in the system and their purpose.

Layer - List the software layers, what they do, and how they interface.

Threads - List all the threads in the system and their purpose.

You can sprinkle in some class diagrams and sequence diagrams as needed.

These are some example views but are the main ones.

A good book on this topic is: Documenting Software Architectures: Views and Beyond

Apologies, it looks like I got the name wrong from memory, it’s actually “Making Embedded Systems” and here’s the amazon link: Making Embedded Systems: Design Patterns for Great Software https://www.amazon.com/dp/1449302149/ref=cm_sw_r_cp_api_glc_fabc_3o9cGbZG63W6N?_encoding=UTF8&amp;psc=1

As they say, por que no los dos? There is no reason why you can't tackle these at the same time. The Linux kernel is C only, so if you want to do driver development on embedded Linux, you need to advance your C skills. Then, anything user space depends on the application you would be working on, but C++ is definitely very common. Therefor, you can spend time reading "Linux Device Drivers" together with "The C Programming Language" (always worth a read) and at the same time dabble in C++ or things like Qt.

It was up earlier this year...it hasn't been in active development in a while if I recall correctly.

Maybe I have a tarball somewhere..

Edit: SourceForge to the rescue!

https://sourceforge.net/projects/uclinux/files/

Since the Raspberry Pi doesn't have any certification for medical purposes, you will have to do a lot of the heavy lifting yourself. But as an OEM you need to provide the risk model, risk management and test evidence that the unit you sell will perform to its intended purpose. For this purpose the the Raspberry Pi is a tough sell because of the life cycle management. Every year you will get a new unit with a different design. That's why at our current project we went with the Olimex A20-Olinuxino-Lime2. You know they will maintain the same product and probably will inform you when things change.

I did a presentation on hardware outsourcing based on my experience in 2009 at Philips Healthcare. https://www.slideshare.net/jhaand/outsourcing-hardware-development The main problem with supplier management remains that the customer sees a logo of your company on the product. They don't even know what kind of embedded product is. (slide 19) But in the end, you as an OEM bear the responsibility in releasing a certified product.

Most modern controllers these days at LEAST support C99.

Most companies compilers platforms are based around the GCC compiler which will support C99 & C++14 in any recent version. If you're on an ARM M0/M3/M4 chip it will likely be based on the &quot;GNU ARM Embedded Toolchain&quot; and have support for C++14. If not it should be fairly easy to use the latest ARM Embedded Toolchain instead of whatever the vendor shipped.

IAR compiler does NOT support C++11, let alone C++14. They do support C99 though.

Keil supposedly has some C++11 support.

I have no experience with the other proprietary compilers.

There's a great tutorial on MQTT, quite short and practical, here: http://hackaday.com/2016/05/09/minimal-mqtt-building-a-broker/ (All four articles are here: http://hackaday.com/tag/minimal-mqtt/)

This will take you through setting up a server and getting devices to communicate with it. You can skip some of the details on a first pass. The second part of the tutorial uses a mqtt library for the esp8266, but I guess that the mqtt library you end up using is probably quite similar.

so, you have declared char buf[1]; that should have sizeof == 2 but in that printf you are trying to access buf[2] which would mean that you are trying to access data out of bounds...

also you are doing read one byte at the time. normaly this should be fine but i have seen kernel interfaces that do not like such spliting (procfs, sysfs, debugfs). Try doing read and write calls as a whole.

Can you try copying the example code from kernel docs and see if it works better? https://www.kernel.org/doc/html/latest/i2c/dev-interface.html

Are you on Mac or Windows 10? You can use Oracle's VirtualBox Virtual Box website and install Linux inside it. After that, you can QEMU, emulate a hardware board and try to install Linux on it. For example, check this tutorial, even I was surprised that it's on a Microsoft website.

Beware though that volatile may not be sufficient, because the hardware can reorder whatever the compiler says to do. To ensure that hardware reads/writes match the order of reads/writes in your code, you also need to add appropriate fence instructions. See also the linux kernel guide to memory barriers.

I got a few "coding challenges" from different companies, mostly but not only startups. Always on hackerrank or Hackerearth or sites like those. I personally don't like them that much and depending on the company I reject or take them, but I like to seolve them in my free time. For Linked lists I got this two for resversing a linked list and reversing a double linked list.

Application-based coding tests are a better suit for me at least, and I enjoy doing them. In a few on-site interview I got asked to code by hand circular buffers, recursive functions or some other stuff too, but not that many were that way.

&#x200B;

I hope it went well anyway, I do think that the approach and the problen solving skills are important than knowing how to reverse a linked list withouth checking your cheatsheets.

If you are developing on Linux, I hope my notes can help you.

In any case I suggest using GCC ARM embedded toolchain to build, and one of STM32Cube or libopencm3 to access peripheral registers and manage interrupts. Maybe libopencm3 is more similar to AVR library so the transition might be smoother.

OpenOCD is great, but be aware that if your board doesn't have a JTAG adapter you will need to buy one separately; fortunately there are cheap FTDI cables like the ones that I mention in my notes.

Website from an 8 bitter? You're a brave soul. Take a look here: http://hackaday.com/2012/07/17/lightweight-web-server-using-the-msp430/

As far as Embedded TCP/IP vs regular, the basics are the same. It's the implementation that's different. The protocols don't change since you have to talk between embedded and non-embedded, you have to follow the same rules of how to create packets and whatnot. Any good book on TCP/UDP can explain the stack to you.

If after reading a book on TCP, you still want to know how to write your own stack, start disecting LWIP or uIP. They're both small enough where you can get a handle on their code fairly easily.

I've never had the motivation to learn how to use latex for graphics so I always used draw.io for university assignments. I know a good free logic gate simulator though: http://www.cburch.com/logisim/index.html I'ts a bit weird at first but works great after a while as long as you're not about to build an entire CPU from gates or smt.

make does all of that, and doesn't require a Python interpreter.

I'm familiar with SCons, and for those interested:

http://www.scons.org/wiki/SconsVsOtherBuildTools

The question now is, How is PlatformIO different than SCons?

You could use appimage: https://appimage.org/

But overall you should probably think about more...

• how will updates be handled
• what will the customer need to do, he still needs to set up raspbian
• maybe you can use Raspbians packet manager and submit your app to an app store. So you have an update distribution mechanisms + security already and don't need a lot of manual work

You will never be able to fully recover C code, but decompilers exist. You can get an ARM decompiler for IDA Pro but it’s expensive. There is also Ghidra which is free and supports a ton of architectures for its decompiler.

I find that manufacturer's IDEs and their frameworks are the worst part of developing embedded software and especially when you're trying to spec a part for a project that you don't have any experience with. I typically only seem to find out too far into the development that you can't get enough control over the bit of hardware you want without replacing some part of the manufacturer's framework or middleware which is a nightmare akin to pulling at a thread on a sweater.

We too had a crack at using the CC3200 and dropped it because their stack never allowed you to use it to the potential that the datasheet claimed you could. I've had the same experience with Atmel's ASF; the hardware potential was great but the released framework was missing the components that took advantage of it although to be fair that was at the time of the Microchip takeover and so it could have been due to that.

I'm keen to try out https://platformio.org on a project to avoid having to suffer another Eclipse but it would have to be a personal project before I selected it for work.

If you are new to embedded programming, I recommend to take a look at https://PlatformIO.Org. There is support for Sipeed MAIX. See examples https://github.com/sipeed/platform-kendryte210/tree/master/examples

If you're going to be doing any sort of programming, go to https://devdocs.io/ and choose all the language/framework/tool docs you'd like to store offline. However, I don't know for sure about it's resilience long-term, because I've never been without internet for more than a day or two.

great list.
For documentation diagram, take a look at mermaid-js

> Small python tools I've hacked together to parse compiler/objdump output:

I'm curious about this. How do you monitor stack usage?

This book is great: https://smile.amazon.com/Making-Embedded-Systems-Patterns-Software/dp/1449302149/ref=mp_s_a_1_1?dchild=1&amp;qid=1627350531&amp;refinements=p_27%3AElecia+White%2Cp_n_availability%3A2661600011&amp;rnid=2661599011&amp;s=books&amp;sr=1-1&amp;text=Ele...

You can start with Cortex M0. I recommend this book: https://www.amazon.com/Definitive-Guide-Cortex-Cortex-M0-Processors/dp/0128032774/ref=sr_1_3?dchild=1&amp;keywords=definitive+guide+to+cortex&amp;qid=1627321589&amp;sr=8-3 You can go with Discovery F0 board by ST.

If it's a CAN bus analyzer you're looking for, this little board is a great deal, and works with Linux SocketCAN drivers right out of the box.

https://www.amazon.com/Innomaker-Converter-Module-Raspberry-Zero/dp/B07P9JGXXB/ref=sr\_1\_3?dchild=1&amp;keywords=Can+Bus+Analyzer&amp;qid=1626046017&amp;sr=8-3

I'm already taking a paid udemy course on linux driver development (+ I have this book but it doesn't seem adequate alone) but obviously nothing can be compared to what a book can provide in terms of explanation of concepts.

The first book might either be "Secure Software Design" or "Secure Software Development"?

I think I have both of the books, but I don't recall much about them.

Arylic WiFi & Bluetooth Audio Receiver Board, Wireless Multizone Home Stereo Music Receiver Circuit Module with Airplay Spotify Connect and Remote Control for DIY Speakers-Up2Stream Mini V3 https://www.amazon.com/dp/B07W7QB2RX/ref=cm_sw_r_cp_api_fabt1_FjUVFbXHP1W18?_encoding=UTF8&amp;psc=1

Could help you out without having to reinvent the wheel.

Oh, and make sure that it can handle the 120v ac or whatever your requirements are. BE CAREFUL WHEN WORKING WITH AC! Seriously, if you have no AC experience, you can get an AV/DC wall wart/converter. I have bought this Adjustable Power Supply 100-240V AC to 3-12V 5A 50-60hz DC Converter.

https://www.amazon.com/gp/product/B083GG2H6R/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&amp;psc=1

If you do a lot of projects and have $50-$60 to spare, I recommend an Adjustable Regulated Switching Power Supply https://www.amazon.com/gp/product/B07X2VZSL9/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&amp;psc=1

Search Amazon for "ac to dc 5v module". Pick the ones you need and read the reviews. 4+* only.

https://www.amazon.com/Converter-Universal-Isolated-Switching-Version/dp/B07SGQ6XXR/ref=sr_1_2?dchild=1&amp;keywords=ac+to+dc+5v+module&amp;qid=1605206530&amp;sr=8-2

Wio Terminal : https://www.amazon.com/dp/B08CKJKP9Y

Has a screen, buttons, and 5 way joystick all in a handy enclosure.

Screen is epic and needed to debug variables. Buttons epic so you can diddle variables live time.

No idea.

Amazon has a few books:

https://www.amazon.com/Software-Engineering-Embedded-Systems-Integration-ebook/dp/B019ZU5APU/ref=sr_1_4?keywords=ISO26262&amp;qid=1555694080&amp;s=gateway&amp;sr=8-4

Self assessment should go over what you need to know internally:

https://www.amazon.com/ISO-26262-Complete-Self-Assessment-Guide-ebook/dp/B07CVVGKCN/ref=sr_1_3?keywords=ISO26262&amp;qid=1555694080&amp;s=gateway&amp;sr=8-3

I am not an expert nor have I done this before. But I have a habit of reading a book from prologue, and one of the books that promises to teach you this is uCOS (Micro C OS NOT MUCOUS). There are a series of books written by the same author, you can give it a try maybe. You can find it here.

Download this book called "The C Programming Language" It's really helpful.

Also, today I started a blog to write about arduino and this class. I'm gonna take it and I will try to keep posting stuff I learn in the class :) http://projectswitharduino.blogspot.com/2014/01/embedded-systems-by-edx.html

Ohh I see, this one looks nice with several options to choose from and low prices, though I am unsure since there is a lack of reviews and a documentation..

This might interest you: ARM Microcontrollers: Programming and Circuit Building Volume 1

And the accompanying YouTube series.

uCOS-II (MicroC/OS-II). There is a book, written by the author of the code, that describes the design and implementation of the real-time kernel. 634 pages.

https://www.amazon.com/MicroC-OS-II-Kernel-CD-ROM/dp/1578201039

Joseph Yiu from ARM wrote a series of books for Cortex-M0, M3, M4, explaining some basic concepts. Here's a reference to M3/M4 book:

https://www.amazon.co.uk/Definitive-Guide-Cortex%C2%AE-M3-Cortex%C2%AE-M4-Processors/dp/0124080820

Get to know OOP if you aren't familiar with it.

Personally I use W3schools to get going with specific languages. It's simple to follow and it teaches you the basics. But if you already know the basics of C++ then maybe Real-Time C++ or reading about design patterns can help you.

I scoped it out to check voltages, and its a 3.318v signal and its a nice clean, sharp signal, so all good there.

I've breadboarded the chip and hooked it up to a bus pirate, and I read the JEDEC ID just fine, 0x9D 0x60 0x18. Here's the schematic for the chip. Again, I've got HOLD held high with the pullup, #WP held high by the MSP. Unfortunately, my last non-committed MSP died earlier this month, so I can't simply replace the bus pirate with that and test my MSP code on it.

The traces are less than an inch long, but after looking at the board files, our hardware guy threw the SOMI trace underneath CLK and SIMO (45 degree angle difference). Its a 4-layer board, standard board/layer thicknesses. I scoped it looking for crosstalk, and there's nothing, that SOMI line is stuck at 0v while I'm spamming the Read JEDEC command

If you want to really learn git, I highly recommend this free book https://git-scm.com/book/en/v2

When I started a new job using git 7 years ago having never seen it before , I read the book on the train to and from work in my first week. Now I give internal git training.

I went through this book for an independent study for my Master’s degree. It balances theory with practical application.

It won’t show you exactly what you’re trying to do, but it’ll help get you started with some of the other tools people are mentioning. I’d recommend the third edition, if you can get your hands on it. The second edition is okay, but doesn’t have Yocto or Raspberry Pi stuff.

Get one of these:

https://www.amazon.com/All-Serial-Adapter-Converters-UART/dp/B017SK2T1M

USB in, I2C/SPI/UART out at 3.3VDC or 5.0VDC.

Thanks to all of the expert answers I recieved. Love reddit for this. I choose this because it is so inexpensive and get 3 for $20. It says it is arduino compatible and comments support that.

How are they making a profit?

https://www.amazon.com/Development-Microcontroller-Integrated-Antenna-Amplifiers/dp/B09GK74F7N/ref=sr_1_1_sspa?crid=S9D1FASDOD5C&amp;keywords=3+Pieces+ESP+WROOM+32+ESP32+Development+Board+2.4GHz+WiFi+Dual+Cores+Microcontroller+Integrated+with+Antenna+RF+Low+Noise+Amplifiers+Filters&amp;qid=1669550110&amp;s=electronics&amp;sprefix=3+pieces+esp+wroom+32+esp32+development+board+2.4ghz+wifi+dual+cores+microcontroller+integrated+with+antenna+rf+low+noise+amplifiers+filters%2Celectronics%2C173&amp;sr=1-1-spons&amp;psc=1&amp;spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUExSkxJOVdEQ05ZS0JMJmVuY3J5cHRlZElkPUExMDI1ODU0M09BNUlTR0lYWTY0RyZlbmNyeXB0ZWRBZElkPUEwMDczMjA2MjJNR1U1NU5ZNFdLVyZ3aWRnZXROYW1lPXNwX2F0ZiZhY3Rpb249Y2xpY2tSZWRpcmVjdCZkb05vdExvZ0NsaWNrPXRydWU=

I want real self driving car, radar, obstacle, line finding one. I ordered a 32bit arduino compatible from amazon ,posted the like. Do you think this will work for full self driving car?

https://www.amazon.com/Development-Microcontroller-Integrated-Antenna-Amplifiers/dp/B09GK74F7N/ref=sr_1_1_sspa?crid=S9D1FASDOD5C&amp;keywords=3+Pieces+ESP+WROOM+32+ESP32+Development+Board+2.4GHz+WiFi+Dual+Cores+Microcontroller+Integrated+with+Antenna+RF+Low+Noise+Amplifiers+Filters&amp;qid=1669550110&amp;s=electronics&amp;sprefix=3+pieces+esp+wroom+32+esp32+development+board+2.4ghz+wifi+dual+cores+microcontroller+integrated+with+antenna+rf+low+noise+amplifiers+filters%2Celectronics%2C173&amp;sr=1-1-spons&amp;psc=1&amp;spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUExSkxJOVdEQ05ZS0JMJmVuY3J5cHRlZElkPUExMDI1ODU0M09BNUlTR0lYWTY0RyZlbmNyeXB0ZWRBZElkPUEwMDczMjA2MjJNR1U1NU5ZNFdLVyZ3aWRnZXROYW1lPXNwX2F0ZiZhY3Rpb249Y2xpY2tSZWRpcmVjdCZkb05vdExvZ0NsaWNrPXRydWU=

The commodore did not store analog data on the tape, it was digital data, off topic but a fundamental difference with sampling true analog data. Many ADC interfaces are glue in easily to standard interfaces.

>What I'm wondering is whether or not there's already a chip that is solely designed for being fed a series of bytes and it will output a series of tones

I'm starting to suspect you don't understand how sampling theory works, there is no "codes to tones". Why do you need anything other than an ADC if your purpose is storage?

Why doesn't this solve your problem:

Amazon.com: Riptunes Portable Cassette Recorder Player, Tape to USB Audio Music Digital Converter, Retro Classroom Shoebox Cassette Player and Recorder USB Player, Cassette-MP3 Converter with Built-in Microphone : Electronics

oh man an rPi is way overkill for this - that's like flying a plane to your neighbor's house.

it would be pretty trivial to just pipe UART traffic over a bluetooth-serial link. OP could also log to an sdcard (or spi flash on a board otherwise providing that bluetooth radio) for times when there is no connected recipient.

you could start with something pre-built like this: AmazonSmile: Comimark 1Pcs RS232 Bluetooth Serial Adapter Communication Master-Slave Module 5v Mini USB : Electronics

then consider spinning your own design with an sdcard/spi-flash/other-nvm and some logic to transfer cached logs when your device (e.g. laptop or phone) comes into range and connects via BT.

[This course, Embedded Linux Step by Step Using Beaglebone Black, has the same exact content as Mastering Embedded Linux Programming 2nd edition.

I knew it was a rip off because I had purchased the textbook, and then I couldn't finish it (because it's a textbook). When I saw the course, I downloaded that, and then realized wait a second, this is exactly the same as the textbook!

I didn't finish the course either, hah. I had a lot of things on my plate at the time, and I just gave up on the embedded linux.

I liked this one:

https://www.amazon.com/gp/product/3662478099/ref=ppx_yo_dt_b_asin_title_o07_s00?ie=UTF8&amp;psc=1

Here's a pretty good book on the subject

&#x200B;

https://smile.amazon.com/Programmable-Controllers-Sequential-Publishing-Electronics

https://training.ti.com/tiva-c-series-workshop

https://www.amazon.com/Tiva-ARM-Programming-Embedded-Systems/dp/0997925922

the first two links are in my personal google. hope this helps get you started ;-)

Grab one of these cheap USB logic analyzers. They are great for quickly identifying and solving SPI, I2C, UART, and other protol problems.

https://www.amazon.com/dp/B077LSG5P2/ref=sspa_mw_detail_0?psc=1&amp;pd_rd_i=B077LSG5P2&amp;pd_rd_w=Db15f&amp;content-id=amzn1.sym.2f503b7e-c035-44fd-a779-e3947a660943&amp;pf_rd_p=2f503b7e-c035-44fd-a779-e3947a660943&amp;pf_rd_r=7EXY3EQWQWD3SPY5YH2...

I've got a book suggestion for you. There's probably some better ones out there but it's the one I happened to read recently.

Make: AVR Programming

I think it's exactly what you're talking about doing and does a decent job of holding your hand to get you started while still showing you exactly what's going on.

The way things are explained in the book easily translates to using other AVR chips.

Just for the record, the device meant here is probably the ultra-cheap 8-channel, 24-MHz sampling rate logic analyzer. It can be purchased for as little as $10 with cables. Surprisingly this thing actually works with the open-source PulseView software.

I have several, from super cheap ones, to expensive ones, and a few ancient ones (I have a working tektronics 503, mostly cause its pretty). Anyways, my favorite is this one from dream source labs dscope, but I find myself using the logic analyzer more often dslogic. Pretty good quality stuff from what ive noticed so far, and they do have cheaper options if you dont need significant sampling rate.

If you are coming from C/C++ (or really any software programming language) verilog can take some getting used to. Aside from the language/syntax difference, there is also a big difference between software running on a chip and how and FPGA operates.

Alchitry has some really good tutorials which will help with concept and syntax. You can use one of their dev boards or pick up something like the ICEStick . I would recommend just getting the Alchitry Cu which has the same chip as the ICEstick.

Alchitry also promotes 'Lucid' which is a language they developed to make FPGA development easier. I'm sure its fine and makes some thing more convenient, but I would recommend sticking with their Verilog tutorials. Verilog is well established in the industry and learning it will help you a lot more in the FPGA world.

Quick win : https://www.udemy.com/course/raspberry-pi-full-stack-raspbian/ . I mentioned doing this during an interview and was surprised by how well it was received. I didn't even put it on my CV because I thought it was too simple.

Not so quick win: this book .

We used this book in our embedded linux uni course. It gave me solid basics and was fun to read/follow.

These two things were all I had related to linux and were enough to land a job.

&#x200B;

usb 422 converter: https://www.amazon.es/Cicony-Converter-Adapter-Supports-Windows/dp/B082PPDNBH/ref=asc_df_B082PPDNBH/?tag=googshopes-21&amp;linkCode=df0&amp;hvadid=511107426202&amp;hvpos=&amp;hvnetw=g&amp;hvrand=10637600906761526998&amp;hvpone=&amp;hvptwo=&amp;hvqmt=&amp;hvdev=c&amp;hvdvcmdl=&amp;hvlocint=&amp;hvlocphy=1005424&amp;hvtargid=pla-1330148232881&amp;psc=1

in the usa amazon sells these as d-tech, what matters is the 422 converter is a generic ftdi-chip inside which is widely supported by linux

This! u/AngryCodeMonkey42, The Clean Coder has a whole chapter on how saying "no" is often the most professional thing you can do. It might be worth a read if you have a hard time with this.

Of course, it's often not constructive to simply say no. More often, you'll want to confirm priorities, present tradeoffs, and foreshadow outcomes when communicating with stakeholders. e.g.:

• "Here's what I'm currently working on and I'm expecting to have it completed in two weeks. If you need me to stop working on that and prioritize this other thing, I can do that, but it means you won't have what I'm currently working on for about six weeks. Is this new task worth deferring delivery of this other work?" * "Without help, I can't stay on top of both project management and delivery of my tasks. This means that I'm going to have to simply throw new requests into a backlog, prioritize them as I see fit, and deliver them when I can. Are you okay with that uncertainty? If you need a better sense of when features will land, then I'm really going to need another developer and/or a project manager."
• "When requirements trickle in like this, I have to keep majorly restructuring the code. The architecture is getting messy and this is going to move slower overall than if we stopped and spent a few weeks better defining the product and writing down requirements before resuming the work."

An alternative idea, SPI/I2C to UART bridge ICs exist such as this which would allow you to have extra UARTs on an otherwise maxed out device. 3-4 is far more common than 5, so this may be an easier option than looking for alternative GPS receivers

Really similar situation and the new dev recommended this book:

https://www.amazon.com/Real-Time-Efficient-Object-Oriented-Microcontroller-Programming/dp/3662478099

It’s been really rewarding to pick up C++17 (I last did C++ in 2014 to 2016) and you can wrap the C libraries in C++ and pick up a ton of nice features on the way.

I know you're asking for help on this solution, but I would really advise getting a cheap st-link or jlink clone. You're giving yourself such an uphill battle for something that already has enough challenges in an of itself.

These things are like $10 on amazon, and just a couple if you buy somewhere like aliexpress.

There are many ways to implement a singleton in C++ so you should be able to find examples just by Googling. As far as learning about more design patterns u/JuSakura42 shared a link to this book which describes helpful design patterns in detail with examples. (That is the Amazon link to buy the book but you can find copies of it online)

I faced these same questions few years ago... maybe this book can help you as helped me before:

https://www.amazon.com/Design-Patterns-Embedded-Systems-Engineering/dp/1856177076

This book brings in the table what is the purpose of the desing patterns and how we can use in our embedded software development. =D

Regarding your questions:

1. Try to avoid creating global variable... I mean some cases you will create it, but try to avoid... creating global variables make your code non reentrant and "sometimes" can be a problem when you are dealing with a preemptive tasks. Summarizing... try to avoid global variables when you are creating features in the application layer.
2. I try to avoid the singletons... but almost of the case ,this is not possible in my point of view... manly when we are talking about low level device drivers. =(
3. Yes, there are many of them... for exemple, I really like the Debounce Pattern, the Observer Pattern and the Hardware Proxy Pattern... but you can check a lot of other examples in the book that I mentioned previously.

I friend suggest me to read this book when I had the same issue:

https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/0984782850

&#x200B;

Maybe, that helps you as helped me. =)

This book by Grenning is what made me switch from C to C++ for my projects. Having a test harness in CppUTest gave me the confidence that I was doing things right. It’s not comprehensive, but it was a game changer for me.

https://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=mp_s_a_1_4?crid=27HW6XCXAEXBY&amp;keywords=pic32&amp;qid=1656897061&amp;sprefix=pic32%2Caps%2C240&amp;sr=8-4

Unfortunately, the width requirement appears hard to fulfill. Have you considered looking at spy cams? Those are geared towards being small but I have no idea if there are ones that can be controlled remotely.

I'm refering to products like https://www.amazon.com/Magnetic-Waterproof-Detective-Security-Cameras/dp/B07W12WJC3 - I know they're not meant to be dev platforms but like I said, it appears to be difficult to find a suitable dev platforms fitting that width requirement.

Sounds like you might like:

https://www.amazon.co.uk/Beginning-STM32-Developing-FreeRTOS-libopencm3/dp/1484236238

But it does expect you are comfortable with the GNU/Linux ways of gcc and Makefiles. Though I recommend you get so anyway.

Googling around, it seems that book is also available in Chinese as well. You can have them purchase that with the English version too so they can read at the same time and get the necessary vocabulary in English.

OP does not seem dead set a logic analyzer, which is why I suggested it after seeing the $300 logic analyzer they are considering. This scope is only $100 more and much more helpful for other things if they do not have one.

Your budget is a huge factor. You can spend $150 or $150k. I am a CS guy and I basically just need to know general timing of things, and I don't need exact and I dont need huge amounts of bandwidth. I would suggest a 4 channel scope. I bought this one for $500 for my personal scope and I am happy. It can also do some logic analysis/bus decoding.
https://www.amazon.com/gp/product/B0771N1ZF9/ref=ppx\_yo\_dt\_b\_search\_asin\_title?ie=UTF8&amp;psc=1

It is a powered usb 3.0 hub. It is called a Vantec 7-port USB 3.0 Aluminum Hub. (Amazon).

It says data/Battery charging so I'm surprised it caused an issue. I'll check out the thunderbolt though it's well above the 60$ I paid for the one I have. Thanks.