Blog for my various projects, experiments, and learnings
May 13, 2019

Making Pretty(ish) Reference Images for Microcontrollers

Random

When you want to pick a microcontroller for a project, it can be useful to have a bunch of quick references to find the smallest/cheapest one that will fit the parts you want to use. Usually the information is freely available in datasheets, but those are usually PDF files with pinout/peripheral information spanning several pages.

So I’ve been playing with ways to partially automate the process of generating some nice reference images. I’m not exactly happy with what I have yet, but it’s not the sort of thing that merits spending a ton of time on, and I think I scripted away enough of the tedium that it isn’t too frustrating to make these sorts of tables. You wind up with reference images like this:

STM32L031Gx Pinout

STM32L031Gx Pinout / Peripherals

Honestly, this post would be sort of moot if I could find nice CSV files or spreadsheets of STM32 pinouts and peripherals (see below). Maybe other vendors distribute information in that format, but I couldn’t find many for ST’s chips. And that means that I ended up with a sort of convoluted process.

A fragile Python script runs the pdftotext utility to convert an STM32 datasheet into a pinout table containing peripheral information. The automatic formatting doesn’t include table cell boundaries, so I couldn’t figure out how to put all of the peripherals associated with a pin on the same line quickly; someone needs to manually perform that step before running a second Python script which generates LaTeX files representing formatted peripheral tables. The PDF files generated by pdflatex can then be imported into Inkscape, where the table columns can be connected to the pins on an image of the chip’s outline. So, let’s get started!

Note: I ended up finding a better way to parse STM32 datasheets using a project called Tabula – see this newer post for more information. My first attempt presented in this post ended up working pretty poorly, but that’s life for you. Sometimes it takes a few tries to find a good solution.

Step 1: Parse the datasheet.

The closest thing I could find to a table mapping each pin on an STM32 chip was the table presented in their datasheets. Here’s a link to the datasheet for the chip corresponding to the image at the top of this post. As of the time of writing, the pin definitions can be found in Table 15 (“Pin definitions”), under Section 4 (“Pin descriptions”). ST has been adopting a more modern style in some of their newer documents, but hopefully they’ll keep the datasheet styling the same for awhile.

I wrote a quick Python script to run pdftotext with some formatting options, and parse the output into a semi-finished table; you can find it in this GitHub repository. The syntax is very simple: python3 pin_extract.py datasheet.pdf. The script takes the formatted output from pdftotext and formats it into a CSV-style table using ‘#’ characters as delimiters. But unfortunately, pdftotext intersperses peripheral definitions on different rows from the actual pin names in a way that is difficult to automatically parse:

...
PH1-
-#-#-#-#-#-#6#6#I/O#TC#-#-#-
OSC_OUT
4#D5#4#4#4#4#7#7#NRST#I/O#-#-#-#-
LPTIM1_IN1,
-#-#-#-#-#-#1#1#PC0#I/O#FT#-#EVENTOUT,#-
LPUART1_RX
-#E1#-#-#-#"0"#8#8#VSSA#S#-#-#-#-
5#C4#5#5#5#5#9#9#VDDA#S#-#-#-#-
LPTIM1_IN1,
TIM2_CH1,#COMP1_INM6,
6#E5#6#6#6#6#-#-#PA0-CK_IN#I/O#TC#-#USART2_CTS,#ADC_IN0,
TIM2_ETR,#RTC_TAMP2/WKUP1
COMP1_OUT
...

I couldn’t find a better/easier way to pull tables out of PDF files offline, but suggestions are certainly welcome. You could probably figure this out by having special rules for power supply pins and common cases which span multiple lines like the oscillator and RTC pins, then looking for peripheral lines which don’t end in a comma. But it would be tricky, because there are two separate columns holding potential peripheral mappings and not every pin has an entry in both of them.

Step 2: Clean up the auto-generated output.

In lieu of a good automatic solution, I decided to take a few (okay, several) minutes per datasheet to manually collect the stray peripheral definitions into one column per pin row. It’s not perfect, but it’s also not too bad; the end of a peripheral cell is usually marked by the lack of a trailing comma. Anyways, I try to end up with something like this:

...
-#-#-#-#-#-#6#6#PH1#I/O#TC#-#OSC_OUT
4#D5#4#4#4#4#7#7#NRST#I/O#-#-#Reset
-#-#-#-#-#-#1#1#PC0#I/O#FT#-#EVENTOUT,LPTIM1_IN1,LPUART1_RX
-#E1#-#-#-#"0"#8#8#VSSA#S#-#-#Analog ground
5#C4#5#5#5#5#9#9#VDDA#S#-#-#Analog power supply
6#E5#6#6#6#6#-#-#PA0-CK_IN#I/O#TC#-#USART2_CTS,ADC_IN0,LPTIM1_IN1,TIM2_CH1,COMP1_INM6,TIM2_ETR,RTC_TAMP2,WKUP1,COMP1_OUT
...

The first script briefly describes this format when it finishes running, but who am I kidding? These scripts are too hack-y to be user-friendly, and I’m sorry about that.  But once you have the file in the correct format, you can run: python3 pin_ingest.py mid_datasheet.txt [pin_column].  Most STM32 datasheets provide pinouts for several very similar packages – pick the ‘pin_column’ ID which corresponds to the one that you want to generate tables for, starting from zero for the left-most one.

This second script parses the formatted output into a LaTeX file with the chip’s pin:peripheral mappings sorted into a format that I hope is easier to read – you can run pdflatex file.tex to convert .tex files into PDFs. If you get errors about missing modules, you may need to install the full “texlive” packages:

Example LaTeX table render

Example LaTeX table render

The colors are based on a peripheral’s number – 1 is green, 2 is pink, 3 is blue, 4 is red, 5 is yellow, 6 is orange, and then it wraps around. Some special cases like power, reset, and oscillator pins also get colors, to avoid having the ‘Other’ row be all grey.

That PNG image is pretty low-resolution, but Inkscape can import the actual PDF file as a vector object. The script generates two tables, each with half of the pins available on the package; you get a better aspect ratio if you put a stylized image of the chip between two tables, instead of putting it above one very wide table.

Step 3: Format SVG file

Once you have PDF tables of the chip’s pin:peripheral mappings, you can turn them into SVGs by importing them into Inkscape. Simply open the PDF file, and Inkscape will ask you how you want to import it. De-select the “embed images” and “[font]” options, then hit ‘Ok’. I don’t think the detail slider makes much difference for a text table.

Once you import both tables, you can copy them into a document containing an outline of the chip package. I made the QFN28 image shown here by overlaying silver rectangles over a black square, grouping them, and then rotating the group by 45 degrees. You may also need to set your document’s background color to white if you export it in a format that supports transparency, such as PNG:

Blank pin map

Blank pin map, without lines or labels

Once you’re happy with how the tables are aligned, it just takes another few minutes to draw lines from each ‘pin’ on the package to the corresponding table column. You can hold the ‘ctrl’ key while using the pen tool in Inkscape to snap your lines to 15-degree increments. Then I usually add a ‘title’ on top of the chip package, and a bit of large text to mark the pin number for each table column:

STM32L031Gx Pinout

STM32L031Gx Pinout / Peripherals – can you spot the difference?

Conclusions

So, that’s a first attempt at making almost-automatic STM32 peripheral pinout images. I didn’t go into much detail on the Python scripts, because they aren’t very interesting or well-written. They mostly just run shell commands and parse files, and they don’t do much error checking. I might get around to fixing that if I end up making a lot of these, but there are only so many hours in a day. You can find them in this GitHub repository, and I’m sorry that they aren’t in better shape.

Also note that there is an error-prone manual step in this process, so let me know if you see any discrepancies with the datasheets. I’m also sure that trying other datasheets will turn up plenty of other bugs in the scripts, and the scripts won’t work with grid-based pinouts like BGA/WLCSP packages because they’ll try to cast the alphanumeric pin names into integers. I can’t really spend much time patching corner cases in this skeletal logic, but it was a fun chance to try a little bit of design. I don’t get many opportunities to try to make things that look nice, in case you couldn’t tell.

Anyways, here are a few other PNGs that I made in the same way. With any luck, it won’t take much longer to make a bunch more, including QFP packages and more complex chips with more peripherals:

STM32L031Fx

STM32L031Fx pinout

 

STM32F031Gx

STM32F031Gx pinout

 

STM32F031Fx

STM32F031Fx pinout

Leave a Reply

Your email address will not be published. Required fields are marked *

Related posts:
October 25, 2019 Circuitry, Random, Talking to Hardware

Simple USB / Serial Communication with the CP2102N

Several years ago, a company called Future Technology Devices International (FTDI) sold what may have been the most popular USB / Serial converter on the market at the time, called the FT232R. But this post is not about the FT232R, because that chip is now known for its sordid history. Year after year, FTDI enjoyed their successful chip’s market position – some would say that they rested too long on their laurels without innovating or reducing prices. Eventually, small microcontrollers advanced to the point where it was possible to program a cheap MCU to identify itself as an FT232R chip and do the same work, so a number of manufacturers with questionable ethics did just that. FTDI took issue with the blatant counterfeiting, but they were unable to resolve their dispute through the legal system to their satisfaction, possibly because most of the counterfeiters were overseas and difficult to definitively trace down. Eventually, they had the bright idea of publishing a driver update which caused the counterfeit chips to stop working when they were plugged into a machine with the newest drivers.

FTDI may have technically been within their rights to do that, but it turned out to be a mistake as far as the market was concerned – as a business case study, this shows why you should not target your customers in retaliation for the actions of a 3rd party. Not many of FTDI’s customers were aware that they had counterfeit chips in their supply lines – many companies don’t even do their own purchasing of individual components – so companies around the world started to get unexpected angry calls from customers whose toy/media device/etc mysteriously stopped working after being plugged into a Windows machine. You might say that this (and the ensuing returns) left a bad taste in their mouths, so while FTDI has since recanted, a large vacuum opened up in the USB / Serial converter market almost overnight.

Okay, that might be a bit of a dramatized and biased take, but I don’t like it when companies abuse their market positions. Chips like the CH340 and CH330 were already entering the low end of the market with ultra-affordable and easy-to-assemble solutions, but I haven’t seen them much outside of Chinese boards, possibly due to a lack of multilingual documentation or availability from Western distributors. So at least in the US, the most popular successor to the FT232R seems to have been Silicon Labs’ CP2102N.

It’s nice to have a cheap-and-cheerful way to put a USB plug which speaks UART onto your microcontroller boards, so in this post, I’ll review how to make a simple USB / UART converter using the CP2102N. The chip comes in 20-, 24-, and 28-pin variants – I’ll use the 24-pin one because it’s smaller than the 28-pin one and the 20-pin one looks like it has some weird corner pads that might be hard to solder. We’ll end up with a simple, small board that you can plug into a USB port to talk UART:

CP2102N Testing

Drivers for the CP2102N are included in most popular OSes these days, including Linux distributions, so it’s mostly plug-and-play.

It’s worth noting that you can buy minimal CP2102N boards from AliExpress or TaoBao for about $1, but where’s the fun in that?

read more
August 14, 2019 Random, STM32 Baremetal Examples

New 8-pin ARM Core: the STM32G031J6

It has been about nine months since ST released their new STM32G0 line of microcontrollers to ordinary people like us, and recently they released some new chips in the same linup. It sounds like ST wants this new line of chips to compete with smaller 8-bit micros such as Microchip’s venerable AVR cores, and for that market, their first round of STM32G071xB chips might be too expensive and/or too difficult to assemble on circuit boards with low dimensional tolerances.

Previously, your best bet for an STM32 to run a low-cost / low-complexity application was probably one of the cheaper STM32F0 or STM32L0 chips, which are offered in 16- and 20-pin TSSOP packages with pins spaced 0.65mm apart. They work great, but they can be difficult to use for rapid prototyping. It’s hard to mill or etch your own circuit board with tight enough tolerances, and it’s not very easy to solder the chips by hand. Plus, the aging STM32F031F6 still costs $0.80 each at quantities of more than 10,000 or so, and that’s pretty expensive for the ultra-cheap microcontroller market.

STM32G031J6 schematic

Pinout and minimal circuit for an STM32G031J6 – you only really need one capacitor if you have a stable 3.3V source.

Enter the STM32G031J6: an STM32 chip which comes in a standard SOIC-8 package with 32KB Flash, 8KB RAM, a 64MHz speed limit, and a $0.60 bulk price tag (closer to $1.20-1.40 each if you’re only buying a few). That all compares favorably to small 8-pin AVR chips, and it looks like they might also use a bit less power at the same clock speeds. Power consumption is a tricky topic because it can vary a lot depending on things like how your application uses the chip’s peripherals or what voltage the chip runs off of. But the STM32G0 series claims to use less than 100uA/MHz, and that is significantly less than the 300uA/MHz indicated in the ATTiny datasheets. Also, these are 32-bit chips, so they have a larger address space and they can process more data per instruction than an 8-bit chip can.

Considering how easy STM32 chips are to work with, it seems like a no-brainer, right? So let’s see how easy it is to get set up with one of these chips and blink an LED.

read more
July 22, 2019 Automotive, Random

Mounting Solar Panels to a Car

As someone who likes both electronics and the outdoors, sometimes I get anxiety about a lack of electricity. It would be nice to go camping somewhere away from it all, and still be able to charge things and run some lights, a display, maybe a small cooler. I’m sure some of you are rolling your eyes at that, but I’ve also been wanting to play with adding aftermarket indicators to old cars, like backup sensors or blind spot warnings, and it’d be nice to run them off a separate battery to avoid the possibility of accidentally draining the car’s battery overnight.

Since low-power solar panels are fairly cheap these days, I figured that it might be worth buying a few to mount to my car’s roof. And since my car is technically a pickup, it was very easy to put the battery in the bed and run the wiring through the canopy’s front window:

Picture of the solar system's general setup

I’ve secured the battery a bit more since taking these pictures, but this is the basic idea – it’s pretty simple.

If you have a different kind of car, I’d imagine that you could just as easily put the battery in your trunk, but you might need to drill a hole for the wires if you don’t want to leave one of your windows cracked open.

I guess that a lot of this guide won’t apply exactly to your situation, because you’ll have different dimensions to work with, different limitations, and probably different solar panels. But I hope that laying out each step that I took and what worked for me might be helpful – your basic approach could probably look very similar.

And before we go any further, please keep your expectations in check. These panels can only produce up to 100W in direct sunlight, which is nowhere near enough power for something like an electric vehicle. So read on if this sounds interesting, but the car still runs on gas. We’re not saving the world here.

read more