Jack Ganssle

I always refer to this multipart series on debouncing from one of the greats of embedded, (the now retired) Jack Ganssle https://www.ganssle.com/debouncing.htm

Be sure to read Jack’s mega treatise on low power hardware/software design if you haven’t yet. https://www.ganssle.com/reports/ultra-low-power-design.html One of the best practical EE essays I’ve ever read, and a masterwork on designing battery powered devices.

`wait_for_next_tick();` in any microcontroller-based embedded system will put the CPU to sleep, often lowering your overall power consumption from the mA range it uses while actively running, to the uA range. Some systems, like those based on coin cells, will completely shut down the chip, leaving only a single timer or input active, and when triggered will turn back on and initialise the entire CPU again to handle the input/timer. Some microcontrollers give you a small allocation of you can preserve under these conditions. That's how you get year+ runtimes on tiny batteries. Edit: if you want to nerd out on this, I would start with Jack Ganssle's excellent guide: http://www.ganssle.com/reports/ultra-low-power-design.html

A while back (I'd guess about 15 years ago, so suddenly I feel old), Jack Ganssle (http://www.ganssle.com/tem-subunsub.html) said he was selling his embedded tooling company, SoftAid because after doing it for so long, he had gotten tired of "pushing the same bits around." At the time, I simply couldn't understand that. Sure, I hadn't been writing code as long as he had, but I couldn't imagine enjoying anything more than that. I absolutely loved twiddling bits and watching mechanical systems do what my code told it to. Fast forward to now. I still really enjoy software/hardware/mechanisms/coding/design etc., but if I had to give it up tomorrow, I know I could find something I love just as much. It's a really big world and there are a lot of sandboxes to play in.

Well, they're all good rules, but nobody is going to remember them in the form of a cluttered bulleted list. Jack Ganssle is quoted repeatedly - his blog has a lot of good war stories that illustrate many of these points in much greater detail. http://www.ganssle.com/blog/index.html

When I saw the title I thought it would be the old Jack Ganssle article which is also worth a look if you're interested in this topic: http://www.ganssle.com/debouncing.htm

It's not a web site, but I would recommend subscribing to Jack Ganssle's Embedded News e-mail newsletter: http://www.ganssle.com/tem-subunsub.html . There are usually one or two job postings in each issue. Also check out the podcasts at Embedded.fm and TheAmpHour.com . They both talk about a range of embedded topics and occasionally mention job opportunities.

Jack Ganssle is an embedded guru and a great writer, check out everything he's written - books and online. Start here: http://www.ganssle.com/startinges.htm ("How to become an embedded geek") Get yourself a simple all-in-one hardware/firmware environment, like the one my company (Silicon Labs) makes: Look for the "MCUniversity Kit", it's $55, here: http://www.silabs.com/products/mcu/Pages/MCUniversity.aspx Or check out http://hackaday.com/2010/08/11/how-to-launchpad-programming-with-linux… for info about Launchpad, a cheaper, similar solution from TI. I've actually used Silicon Labs' MCU University kit, and I highly recommend it. I don't get any money directly from it, but Silicon Labs does pay my salary.

General computer hardware : http://www.behardware.com These are good ressources about embbeded systems and computer architectures: http://www.embedded.com http://www.ganssle.com http://www.professorandpat.org ( This one is more oriented for children learning so it's very easy to understand )

re embedded vs digital design Yeah, embedded was what I was talking about and trial&error was what I was worried about. What I've seen people write up is a lot more difficult than software in general. I remember one had severe application issues when it ran with instant on that were eventually resolved as the PLL's not synced up. They put a delay in to let them warm up. Program worked fine. Seen some stuff in immunity-aware programming talking of similar issues. A comprehensive, free collection of stuff like that with tips would be a boon to hobbyists and pro's alike. re book recommendations Thank you. I'm already on Ganssle's newsletter. Good stuff in it. I've been published in one or two. Ancient hardware factored into my recommendations for two: http://www.ganssle.com/tem/tem277.html http://www.ganssle.com/tem/tem262.html Ganssle confirmed that one SOC was taking the approach where it had a badass ARM Cortex plus a M0 for interrupts and such. It's claims were like a watered down version of Channel I/O. Cheap, too. :) Btw, here's your 1-bitter. The link saying datasheet and VHDL design has the PDF's and code. The manual might have tricks worth remembering on other architectures. http://www.linurs.org/mc14500.html re Bitsavers I already have over 10,000 papers from CompSci on my computer, a subset I read instead of skimmed. I keep planning to go through BitSavers to find more interesting stuff but afraid of accumulating useless junk. I just keep putting it off. I…

How are they poor choices? Methinks you're just looking in wrong places if they're languages you want to continue using at a job. Embedded is hot right now, so sign up for the Jack Ganssle's Embedded Muse Newsletter http://www.ganssle.com/tem-subunsub.html. The jobs are going to be mostly US based, but some place to start. And look for companies that you know are going to be using C/CPP from their products. Even if they don't have jobs posted, find someone on the engineering team via GH, FB, LinkedIn, their blogs, guessing their email address, conferences, where ever and email them a nice note talking about their products and how you'd love to work with them if they have a position open. If you can engineer a piece of code, I feel you can also socially engineer your way to a contact somewhere you want to work. Else if you really want to be some "rockstar" web developer (and I only ever use that term as a pejorative), then start using a relevant language, and learn how to talk to employers about how your deep C/CPP experience is actually an advantage that no other diploma-mill code-school grad is going to have. It's never more depressing then when you've hauled in a candidate for a review because they've got great past experience, but the candidate has zero ability to relate that experience to conversation at hand.

I recently started playing with MSP430's. They are fun devices and I think there are lots of possibilities with those. I have no real experience with other uC's so I can't say anything about others or compare. Having said that, here are some very basic impressions: TI's example code is often confusing and over-engineered. It is much better to find advice on blogs and forums instead. The community has some great individuals that will produce great examples and tutorials. Unfortunately, it is very far removed from places like GitHub. Almost all code is shared directly in the forums at 43oh.com. There are a couple of big projects surrounding MSP430's. Energia is, from what I understand, an Arduino-like IDE which lets you program at a much higher level, but at the cost of some performance. When you only have 512 bytes of RAM, it may or may not be an issue. Another one is BSP430 which is a lower level set of libraries. It promises much higher level abstractions at the cost of small performance penalties. I found the tutorials to be rather terse, but I may need to give it more time. Outside of those big projects, there is lots of duplication of effort. It is typical to see 3-5 different implementations of bit-banging UART drivers that are all slightly different. I am no exception, as I started writing my own little set of libraries for dealing with various peripherals. Lastly, a lot of the tutorials out there either use the register names directly (P2IE, P1SEL, etc) or…

I personally found Kent Beck's book very tedious and boring. In it , simple classes are bludgeoned into submission through the over use of tests. From Ganssle's article at http://www.ganssle.com/articles/deconstructing%20xp.htm "XP's motivating guru, Kent Beck, also has a new book out. Test Driven Development (Addison Wesley, 2003, ISBN 0-321-14653-0) focuses on XP's testing practice. I bought the book because I'm fascinated with testing. It's usually done as an afterthought, and rarely hits the hard conditions. Unit tests are notoriously poor. The programmer runs his new function through the simplest of situations, totally ignoring timing issues or boundary conditions. So of course the function passes, only to inflict the team with agony when integrated into the entire system. XP's idea of writing the tests in parallel with the code is quite brilliant; only then do we see all possible conditions that can occur. Beck argues for building tests first and deriving the code from these tests. It's sort of like building a comprehensive final exam and then designing a class from that. An intriguing idea. But X what if the test is wrong? Test driven development (TDD) then guarantees the code will be wrong as well. Worse, TDD calls for building even the smallest project by implementing the minimal functionality needed to do anything. Need a function to compute the Fibonacci series? Create the simplest possible test first X in this case, check to see that fibonnaci(0) is 0.…

I think it's a fitting analogy. Depends on the intended behaviour, really. That said, this is a good resource on the original meaning: https://www.ganssle.com/debouncing.htm

Jack Gansssle wrote the definitive guide on debouncing for embedded systems. https://www.ganssle.com/debouncing.htm

The Embedded Muse (by Jack Ganssle), twice(ish) monthly updates on Embedded Electronics parts, tooling, firmware, etc. Almost every topic you’d be into if you were trying to make or join an electronics startup. http://www.ganssle.com/tem-back.htm

For a second, I thought Jack Ganssle [1] got himself a hipster domain and started to do Python. [1]: http://www.ganssle.com/tem-back.htm

How low-level do you want to go? Jack Ganssle's The Embedded Muse is excellent if you are interested in embedded systems and microcontrollers: http://www.ganssle.com/tem-back.htm I also like Hackaday for hardware hacks (not necessarily just low-level stuff, but you can filter based on tags): https://hackaday.com/ Alternatively, mailing lists for big open-source projects like the Linux Kernel Mailing List, PostgreSQL, or ffmpeg-devel are very low-level (operating systems, database internals, audio/video codecs, and hardware/firmware discussions), but require a lot of technical background to understand: - https://lkml.org/ - https://wiki.postgresql.org/wiki/Mailing_Lists - https://ffmpeg.org/contact.html#MailingLists

not to my knowledge, but this newsletter is source of some nice info from embedded world: http://www.ganssle.com/tem-subunsub.html

There's some good info here if anyone is interested: http://www.ganssle.com/debouncing.htm

"If builders built buildings the way programmers wrote programs, then the first woodpecker that came along would destroy civilization." ~ Gerald Weinberg. For those who don't know what the quote is. I found it here[1]. [1]: http://www.ganssle.com/articles/programmingquotations.htm

Bingo. I never heard anything good about Ada until about the time that both C++ and Java were firmly entrenched. Jack Ganssle has advocated for Ada for a long time. http://www.ganssle.com/rants/ada.htm

"An analysis accomplished after the Challenger accident showed that the IBM-developed PASS software had a latent defect rate of just 0.11 errors per 1,000 lines of code—for all intents and purposes, it was considered error-free. But this remarkable achievement did not come easily or cheap. In an industry where the average line of code cost the government (at the time of the report) approximately $50 (written, documented, and tested), the Primary Avionics System Software cost NASA slightly over $1,000 per line." https://history.nasa.gov/sts1/pages/computer.html I should really link to this article as well: http://www.ganssle.com/tem/tem400.html#article2

Not sure if this is what you want, but it's a short read anyway; search for Second Sources: * http://www.ganssle.com/tem/tem288.html * http://www.ganssle.com/tem/tem289.html

The Embedded Muse http://www.ganssle.com/tem-subunsub.html Jack Ganssle has some really good content he's written for other publications as well.

Here is a good article for you to read written by a long time embedded systems guy directed at those looking to get into the industry: http://www.ganssle.com/startinges.htm

This is not bleeding edge stuff, some systems in the 70s with fraction of the RAM and CPU power had memory safety. Eg see here about running Ada on the same Cortex M4: http://www.ganssle.com/video/episode9-ada-on-a-microcontroller.html

Designing microamp-level systems can be interesting. From http://www.ganssle.com/rants/leaks_and_drains.html : I put one of the boards under a microscope and looked at some of the ancillary parts. There's a 22 uF decoupling capacitor. No real surprise there. It appears to be one of those nice Kemet polymer tantalums designed for high-density SMT applications. The datasheet pegs the cap's internal leakage at 22 uA. That means the capacitor draws a thousand times more power than the dozing CPU.

This is the third part of a discussion on the argument. 1st part: http://www.ganssle.com/tem/tem301.html#article2 2nd part: http://www.ganssle.com/tem/tem302.html#article2 Subsequent defence of the Apollo software mentioned: http://www.ganssle.com/tem/tem304.html#article2 http://www.ganssle.com/tem/tem305.html#article3

> momentary contact button is technically extremely simple Don't forget debounce. Debouncing can be tough. http://www.ganssle.com/debouncing.htm