Swiss Micros DM41 Quick Reference

Now that I’ve been using the excellent Swiss Micros DM-41 calculator a while, there are a few things I still tend to forget that are either different than the HP-41CX, or things that are the same that I just never did often enough. The HP-41CX Quick Reference Guide (if you can find one) is really handy, and I’m lucky enough to have an original printed copy in my notebook’s pocket. But there are some specifics to the DM-41, notably the power-on key assignments, that are helpful to have handy.

And thus is born my DM-41 Quick Reference Guide, available under a Creative Commons Share Alike Attributions (CC-BY-SA) license.

DM41 Quick Reference

It’s formatted to print for trifold to business size, so you can slip it in the business card elastic holder of the DM-41 flip cases.

You can download and make your own from this PDF. I’ve done a limited print run on card stock; if you’re interested in getting one by sending me a SASE, do let me know by email or Twitter (@kf6gpe).

Edit 20-Aug-2017: Updated to indicate that the cards are available for an SASE.

Some notes on the Swiss Micros DM41 series of calculators…

I have a long relationship with Hewlett-Packard portable computing devices; my first experiences programming were on my father’s HP-65, and later the HP-41CV his employer loaned him for his daily work. I had a microcomputer shortly after encountering the HP-65, but learning keystroke programming greatly aided my understanding of assembly language — although I didn’t really recognize that until much later. I later graduated to an HP-28S and then an HP-48SX. In recent years, I have used various HP emulators on the portable devices I use for over ten years; I keep falling back to Free42, because it runs almost everywhere in one port or another. I’ve played with others, and i41CX is what I run on all my iOS devices.

Much has been written about the fine craftsmanship and quality of these early devices — both their physical and electronic design, and the decisions made about their man-machine interfaces. I think exposure to this at an early age definitely has influenced my interest, desire, and recognition of fine design in modern computing products, especially mechanical interactions. I won’t add much here, except that though the bulk of my computation needs now are either so simple that I can do them in my head or on a slide rule (which, yes, I have one on my desk at work) or require real computation to set up, there is still a place for me to use a calculator. It is still faster for me to do some things with a calculator than add formulas to a sheet as I’m analyzing data; once I know what the data is telling me through this exploration, I can then put together the formulas and provide a reasonable presentation. I think because of my upbringing and training, there is something about the cognitive process of using a physical calculator — much as there is in writing with pen and paper instead of typing, a subject much discussed elsewhere.

I have just acquired a Swiss Micros DM41, their small replica of a HP-41CX calculator. It was a bit of an impulse purchase; I have a working HP-41CX I use occasionally, but don’t take it from the house because I am worried about breaking it or having it stolen (my first one was stolen, in 1988). But I had heard good things, and also wanted to support the effort overall — both by encouraging the good engineering of low-volume products for enthusiasts, and in the hopes that by supporting Michael Steinmann and his company that we’ll see other interesting things (the work on the DM42 is an excellent example of this).

I won’t say much about the HP-41 series of devices, but instead provide links to hpmuseum.org and hp41.org. There remains an avid user community, and almost all of the original programs that were published in one way or another can be found on the internet. Many remain useful today. There is also a lot to reflect on when considering the culture of information sharing about calculators and calculation programs in the 1980’s and 1990’s, and blogs and enthusiast sites today about things like iOS and Android, or any programming language, especially the small, up-and-coming ones. More on that in a future blog post, perhaps.

I would like, instead, to capture a few specific things about the DM-41 series (I will refer to both the DM41 and the DM41L as the DM41, because the features I’m discussing apply to both device) that are available from various forums and the Swiss Micros site, but necessarily in one place, both for future users and for future me.

The DM41 is a faithful emulator of the original HP-41CX microcode, running on a low-power ARM processor, with a good mechanical keyboard and dot-matrix LCD display. Battery life and CPU speed is of course drastically better, although the memory remains the same (319 registers plus the stack, or just a touch over two hundred bytes), and at present there’s no way to mount external ROM modules, either as physical hardware or as memory dumps. The DM41 is keystroke-programmed in FOCAL using Reverse Polish Notation, which you either love or will never fully understand. (Contrariwise, it wasn’t until I was about thirty-five that I was able to use an infix calculator with any fluency for more than one operation at a time.) Because the calculator is actually an emulator running the original microcode, synthetic programming is supported. Craftsmanship is excellent — I would not say it is a replica that is identical to the original, but carries the same quality and respect for engineering. The display is good, the keys clicky and reliable (although on the DM41L, take a bit more pressure than on an HP product, but I am told that they break in), and the mechanical design sound. There are two variants of the DM41; the DM41L is in “credit card” format, which is the one I bought, and the other in the HP Voyager format. My only complaint, which is my fault, is that the smaller format is almost too small for my big fingers to use. Had I actually held a credit card and thought about it before ordering, this would not be a surprise, so I fault myself, not Swiss Micros. And having something this small means it’s very easy to carry. Because the physical layout is landscape instead of portrait, the keys are laid out differently; this is a bit of problem for my muscle memory, and my first hour with it recalled my “button paralysis” when I switched from the HP-41 to the HP-28, or the HP-28 to the HP-48, or later picked up Dad’s HP-42S to do something with him in his lab and couldn’t find anything. I have not confirmed this, but it seems that some of the alpha keys are mapped differently, too, or else I have forgotten the mappings for the special alpha characters. Unlike the HP-41CX, there is no shortcut sticker on the back of the DM41L, which is probably a good thing, because it would be very small.

First, without further ado, power-on key sequences for the current (v23) firmware:
Keys Function Description
[ON]+[A] time and date
[ON]+[C] serial console switch to serial console (see below)
[ON]+[E] show information firmware version & battery voltage
[ON]+[CHS] LCD settings change LCD contrast with buttons [R/S],[3],[2],[.]
[ON]+[8] change speed toggle between 12MHz and 48MHz
[ON]+[9] key test key test similar to the one known on the other models
[ON]+[STO] -1h set the clock -1h: daylight saving and changing timezones
[ON]+[RCL] +1h set the clock +1h: daylight saving and changing timezones

Second, here’s how to use the USB port to capture RAM dumps. The original HP-41 series had both card reader and HP-IL accessories for disk (then, “disc”) and tape storage; over the years this has been used to get software off of these devices in a variety of formats. The DM41 series has a miniUSB port, and connecting it to a computer — Mac, Windows, Linux, or even Android with USB-OTG — with the serial mode active gives you the ability to exchange full RAM dumps between the DM41 and the connected computer. Setting up a Mac, PC, or Linux is straightforward, and you can find instructions here. For Android, you can use DroidTerm and a USB-OTG cable. I had it running with my Macbook in about five minutes; most of the time was spent digging around for a USB-C to USB-A adapter.

Once you connect the calculator and terminal (38400/N/8/1, please!), and bring up the calculator in serial mode by pressing C (SQRT) and power, you should see the DM41 prompt in the terminal display. From here, you can enter ‘?’ to get help.

There are two commands you’ll use for memory dumping — ‘s’ dumps the contents of the RAM and pertinent registers to the terminal, ‘l’ takes a similarly formatted RAM dump and replaces the contents of the dump with the calculator. The RAM dump is formatted as printable text; you can copy it and paste it into a text editor. Do yourself a favor — if you’ve spent any time at all programming yours, do a RAM dump now and copy the results to a text file, because it’s easy to forget to do that and later lose the calculator contents while experimenting with uploading other programs. (I speak from experience.)

Where things get interesting is the combination of software available on the web at sites like hp41.org and the programming tool Swiss Micros provides. In this web page, you can paste a well-formatted HP41 FOCAL program listing (no line numbers, though) in the right hand window, and press “encode”, and get a RAM dump you can transfer to the calculator. Even more interesting, you can also install programs you find over the internet that have been saved in the the .raw file format using the programming tool. (You can find .raw files in a lot of places on the Web; a good place for many of the applications that have been written over the years is the library at hp41.org, which only requires free registration). To transfer a .raw program to the calculator, download it to your PC, go to the programming tool, click “choose file” in the raw box, choose the file, and then “decode raw”. Copy the memory dump in the left hand window, go back to your terminal program connected to the DM41, and type ‘l’, and paste in the memory dump.

Because you’re transferring an entire memory dump, if you want to install more than one program, you need to do this:

  1. Make sure the alphanumeric labels in the program are unique.
  2. Make sure you have enough memory for the combined programs.
  3. Concatenate all of the program listings (without line numbers) together in one listing in a text editor, with END statements between each program..
  4. Copy the combined listing and paste it into the code box on the programming tool.
    Press “encode”.
  5. Copy the resulting memory dump and load it into the calculator as usual with the ‘l’ command.

I’ve done this to load the base conversion programs and the phase-of-the-moon program found on hpmuseum.org and the HP-41 User Solutions: Calendars collection.

If you want to get a .raw file from a program you’ve written, it’s likely trickier; I’d start by getting a RAM dump, getting the listing from the programming tool, and then running it through something like the third-party HP User Code utility you can find floating around in a few places. I haven’t tried this, though. If you just want to get your program to another emulator, but you might have problems with the fact that most FOCAL listings include line numbers, and the listings provided by the programming tool do not.

I don’t know a lot about the DM41 memory format, even after looking at some posts on both the Swiss Micros and the hpmusem.org forums (the latter is especially recommended). What’s obvious, though, is that each row consists of four registers in hexadecimal (fifty-six bits per register, separated by spaces), and that it includes some, but not all, of the CPU registers. You’ll see the A, B, C, S, M, N, and G registers, but not the other ones. C is the processor store for the user-visible X register; S is the register holding the status flags. M and N are processor registers for interacting with the X register, as is G (a single-byte register used for alphanumeric mode, I gather).  (If you’re interested in the HP-41 internals, there’s a short summary of processor internals at http://www.hpmuseum.org/techcpu.htm, and of the HP-41 memory map at
http://www.hpmuseum.org/prog/synth41.htm). A quick forum post (thanks grsbanks!) helped me understand that the dumps don’t show anything that’s all zeros.

 

Edits 2017-06-24: Explained missing lines, removed registers not in the HP Nut CPU (I was conflating Nut and Saturn). Minor typo, link fixes.

Clojure, Windows 8.1, and Emacs…

Years ago, I wrote a detailed post on getting Lisp running on Mac OS X. It remains one of my most-read posts, which is kind of cool, although that worries me a bit; a lot has changed since then, and I have no idea if it’s still the way to do it.

I have recently decided to try some things in Clojure, and I decided to set up my Surface Pro 3 with Clojure. This turned out to be a bit more difficult than I expected, actually; there’s a pretty good description at clojure-doc.org, but it didn’t work out of the box for me. You can Bing or Google for people’s setups, and that lead me closer to getting it working, but it was still pretty fiddly. Anyway, here’s what I did.

Continue reading Clojure, Windows 8.1, and Emacs…

Book Review: Programming: Principles and Practice Using C++, 2nd Edition

I learned C++ the hard way: in the early 1990’s, the best reference was Ellis’s and Stroustrup’s The Annotated C++ Reference Manual. At the advice of a good friend, I bought a copy, read it cover to cover several times, and spent the next several years of my career banging my head against the wall in largely C-only development projects trying to get mindshare to do things in C++. As a result, I learned a lot of bad habits at first, and wasn’t always the first guy to pick up on then-new things like the Standard Template Library when it became available. Add my extensive experience with Qt, and my C++ experience is actually quite spotty — there’s definitely room for improvement.

As a result, I jumped at the chance to review Bjarne Stroustrup’s Programming: Principles and Practice Using C++, 2nd Edition (Amazon link). This is an entry-level textbook on programming in C++ for new software developers; its target is obviously an undergraduate class for computer science majors, rather than a reference for a seasoned software developer. (If you’re looking for C++ for the seasoned developer, check out Stroustrup’s The C++ Programming Language, 4th Edition.)

Programming: Principles and Practice using C++ is an excellent modern introduction to what it means to be a programmer, while teaching all of the essentials of C++ you’re likely to need for your first few years. It covers a lot — C++ syntax, data types, the basics of object-oriented design, generic programming through templates, testing, and many other topics. The book is chock-full of code, often showing the iterative nature of programming as Stroustrup lays out the requirements for a program, and then shows version after version that works towards meeting those requirements. It clearly demonstrates how good software developers should approach programming problems, and is as much a book about thinking about programming as it is a book about programming. Which is, I think, exactly what the neophyte needs.

Don’t look here for a lot of information about clever data structures or algorithms — and that’s a good thing. Stroustrup leverages the STL for that, and emphasizes something I think good programmers already have learned — the best code is usually the code you didn’t write. There’s short discussions about some algorithms, of course, as befits a book on programming, as well as the idea behind an algorithm. But, for example, instead of learning to program a red-black tree, Stroustrup points the reader towards the STL’s map, and leaves it at that.

It’s scrupulously up to date, too, covering relevant portions of the latest C++14 standard, as well as using C++11 everywhere — which is great, because most compilers are C++11 compliant anyway, and students should be able to compose and understand programs using the latest language features.

Refreshingly, the book includes not just a discussion of object-oriented programming through the classic example of graphical programming, but actually enables readers to do simple graphical programming through a library on top of FLTK. In discussing the design and implementation of the library, Stroustrup covers classic object-oriented programming, including decomposition, inheritance, and data hiding. While the example is old, Stroustrup’s coverage of it is refreshingly up to date and thorough,

The strongest parts of the book are probably on the topic of generic programming and testing: one of the multi-chapter examples is a re-implmentation of the std::vector class, including almost everything in the standard library. This is an excellent introduction to a number of topics, including API design, memory management, pointers, templates, and generic programming in general. A little later is an excellent chapter going over iterators, looking at iterators as a classic example in generic programming.

It speaks highly of the book that I learned a few things in my read of the book; in some cases it was clarifying the reason behind a lesson I learned in the school of hard knocks, which is great to see in an introductory book of this sort. It was also refreshing to see how programming is taught today, especially using a language as fundamental as C++ is in the industry. In hiring engineers, I worry about the large number of developers who start with Java and never really get back to the basics; Stroustrup covers the basics quite nicely (including a chapter on embedded systems programming) without writing a textbook that’s only about the basics.

I’d recommend this book strongly to anyone just starting out in software development, and with some caveats for developers who already have significant programming experience. I think there’s someone for everyone in it, although the high price means if you’re skilled at teaching yourself programming languages — or just want to brush up on C++11 and C++14 — this might not be the most affordable purchase, even if it is a great read. But as an introductory textbook, it’s hard to beat, giving you a firm start in the fundamentals of programming in today’s world.

Book Review: Responsive Mobile Design

When it comes to writing about food, some books marketed as cookbooks and really just catalogs of recipes, and other books are about food but have lots of recipes as well. Responsive Mobile Design (and at Amazon), by Phil Dutson, is a cookbook of the second sort, about responsive mobile design that has lots of recipes.

I never really did get the cookbook format for computer books; the few I’ve bought I’ve inevitably answer a few questions, but I never really read them cover to cover. Phil Dutson’s book is different — not only are there lots of clear examples and how-you-should-go-about-doing-this kinds of things, but there’s lots of information about responsive design, and modern design for the web in general. As such, it worked really well — Dutson introduces a topic, talks about it in very specific terms, and then looks at specific points that require closer attention with technical examples or pointers to frameworks. There are lots of examples, and lots of figures showing the output of the examples, so you can really see what he’s talking about.

The book begins with some general observations about web design and content, which though lightweight technically, are a welcome reminder that it’s all too possible to create a technically excellent site that wouldn’t interest anyone. From there, he moves on to discussing basic layout principles with grids, tables, and measurement, before getting into the details of media queries and typography. There’s a whole section (three chapters) on how to make multimedia responsive, and then five more chapters on the specifics of tuning the performance of mobile web site, looking at everything from server choices to optimizing JavaScript and measuring performance with modern browsers. Dutson provides a clear, engaging style throughout; I planned on pacing myself by reading a couple of chapters a night to let things sink in, and frequently moved on to a third or even fourth chapter before stopping.

I got a lot more out of the book than I expected, and I had pretty high hopes to begin with. If I had to name a fault of the book, it’s that I’m not sure how well it will age in some regards. Dutson is very good about discussing proposed standards and differences between browsers, which should hold up well. However, he often provides pointers to frameworks, and it’s not clear how many of these frameworks will be around or kept relevant in the two-to-four year lifespan of a printed book. On the other hand, having those pointers and a summary of what’s available is great — if you’re just getting started setting up a site, it’s nice to know the pros and cons of the various packages you can start with. So I think his decision was the right one, and it may mean a little more time with Bing or Google once the book’s been out for a while.

If you’re at all curious about what makes a modern web site tick, or if you’re presently engaged in working on responsive sites, this is definitely a book to have.

Another year, another book!

I’m pleased to announce that the second edition of my book Application Development with Qt Creator is now available from Packt!

This updates the first edition significantly, covering the latest and greatest changes in Qt Creator from Qt 5.x. In addition, I cover many of the fundamentals of software development using the Qt framework itself, including:

  • Drawing in Qt using both the widget and scene frameworks
  • Qt Quick
  • Multimedia programming
  • Sensors & location
  • Using Qt to develop software for mobile platforms like Android

If you’re interested in the best in cross-platform development frameworks for desktop and mobile platforms, Qt is where it’s at. With this book, hopefully I can help you speed your development effort along a little!