Posts

Winding down, switching gears – Feb 7, 2018 – Let me get right to the point: the scheduled daily weekly posts on this JeeLabs weblog are coming to an end. I’m going to move away-and-onwards from the “blogosphere”. There are several reasons for this decision. A central one is my desire to spend (even) more time reading and tinkering, but also less time talking and writing. The web has become an amazing (infinite!) knowledge resource. Call me crazy, but I still want to learn more - just for the sake of learning!
Data structures for JET, cont'd – Dec 27, 2017 – I made some good progress on the design of an early prototype for last week’s JET data structure design. So far, it’s all working out well (I’m coding this in C), with some useful refinements: the gadget + wiring configuration can be serialised to a binary format, this can be used as data exchange format when sending a setup to a µC there is now also an extension to the GC’d memory manager, which allows storing structures compactly in ROM
Data structures for JET – Dec 20, 2017 – Another post about the JET project. This time around, I’m trying to come up with simple data structures to get the job done, i.e. supporting a PureData-like dataflow engine, able to fit in very small µC setups. That means minimal redundancy, given the limited amount of RAM. One useful trick is to store int indices where possible, instead of 4-byte pointers to the various items. Apart from processing dataflow messages, I also want the whole setup to persist across power cycles, i.
Garbage collection for JET – Dec 13, 2017 – The JET project is based on a dataflow engine, which needs to run on a variety of hardware, in particular fairly low-end µCs. But dataflow requires passing messages around, and I want these messages to support a variety of data structures, from simple integer values to small vectors, and preferably also strings. The messages will have varying sizes and they need to be produced and consumed dynamically, with different recipients and lifetimes.
Signed and encrypted email – Dec 6, 2017 – It’s surprising that S/MIME is not more widely used. It offers authentication, so that you can be sure the email comes from the person that email address belongs to, which will kill all (spear-) phishing attacks (as long as the originating account is safe). And it offers secure end-to-end encrypted email, once you have a signature from the person you want to email to. Which means even a Gmail mailbox won’t be able to read the email, if you use an email client on your laptop or mobile device instead of webmail.
My new (old) Linux laptop – Nov 29, 2017 – I’ve had this really nice laptop sitting around for quite some time now: It’s a dual-core i7 with SSD and USB3, and quite up-to-date still by today’s standards. The matte 1920x1080 display is really nice (I totally don’t like the high-gloss reflective screens that all MacBooks now have). Trouble is, this thing runs Windows (it was acquired for exactly that reason: to have a Windows fall-back option for some funky hardware I use - albeit only occasionally).
Duplicacy with Wasabi – Nov 22, 2017 – No, this is not a recipe for a meal… I’d like to describe the backup structure now in place here at JeeLabs, which has been running for a few months. It’s working out nicely for a personal + family setup. There are several moving parts involved: a central Core i3 server, running 24⁄7 behind a FritzBox 7490 router Caddy is the public HTTPS server w/ automatic Let’s Encrypt certificates Nextcloud is used as DropBox-like sync server, as well as Calendar + Contacts server - i.
TFoC - A compiler in 256 LoC – Nov 15, 2017 – (This article is part of the The Fabric of Computing series: in search of simplicity) The previous TFoC post was about a truly minimal setup, capable of just very simple computation. This time, let’s go all out and look into a 2-pass compiler for a reasonably high-level language, and what it takes to create a complete environment. The language I’ll use for this is called BCPL. Here is an example program:
TFoC - A minimal computer – Nov 8, 2017 – (This article is part of the The Fabric of Computing series: in search of simplicity) With today’s programming languages, it’s easy to ignore what goes on inside. Maybe you’ve never even bothered to find out. The trouble is that there are only so many hours in a day. As long as the chip is usable from a high-level language, who cares? Well… I do. It’s fun to open up the hood and figure out how things are built and configured internally.
Documentation, moi? – Nov 1, 2017 – For years, my weakest spot has always been documentation, and it’s been sticking out like a sore thumb. For all the code I’ve been slinging into this world, paid and unpaid, open and closed, documentation has been: Incomplete! Inaccurate! Disorganised! Out-dated! Confusing! Terse! Unfocused! Being a “starter” and not a “finisher”, and knowing that work on documentation tends to come last, it has become a … mess: an ageing wiki on Redmine and another one for hardware a bunch of docs made with Doxygen outdated HouseMon & Tosqa stuff a (newer) area for embello and flib The same holds for bug/issue trackers, but luckily that situation has now been more or less consolidated into just a few on GitHub.
SMA Solar readout - part 3 – Oct 25, 2017 – (Part 3 of the SMA Solar readout series) With everything working as intended, it’s time to wrap things up. As this unit only has an LCD sticking out and no other controls (i.e. It Should Just Work when powered on), I decided to 3D-print a custom enclosure: I have no 3D-design skills, but OpenSCAD makes it easy to create a simple 3D model: As you can see, it’s just a rectangular block “minus” some other rectangular blocks …
SMA Solar readout - part 2 – Oct 18, 2017 – (Part 2 of the SMA Solar readout series) Here is the hardware, with its three main components - LCD, µC, and Bluetooth: The bottom is wired up using my favourite one-off soldered-kynar-wire technique: The cutout leaves the BT module’s PCB antenna exposed for 2.4 GHz RF signals. There’s not much to it, really. So let’s move on to the software side of things… The first challenge, as always with a new board, is to get Mecrisp Forth uploaded into its flash memory.
SMA Solar readout - part 1 – Oct 11, 2017 – This is the first post of a 3-part series about reading out an SMA solar inverter over Bluetooth and displaying some readings every few seconds. Long-time readers may remember the Solar at last weblog post from several years ago and the SMA Relay, based on a JeeNode v6. The Bluetooth readout code was derived from Stuart Pittaway’s Nanode SMA PV Monitor code. This project is for a friend who’s birthday is coming up shortly, and who has the same SMA 5000TL inverter as I do - although it can probably be used with other models.
New hardware at JeeLabs – Oct 4, 2017 – I’ve been upgrading some of the hardware here lately. The Odroid XU4 (web server) + Odruid U3 (home server) + CHIP (PiHole) setup was working ok, but I was growing a bit tired of multiple systems, with different OS versions, each needing to be kept up to date, backed-up - etc, etc… Server Or maybe it was because I came across this neat range of Intel-based “NUC barebones” systems, and was looking for an excuse?
Enabling USB on a Blue Pill – Sep 27, 2017 – As you may have guessed from my last post, I’ll be using the Blue Pill STM32F103 µC board for some JET engine experiments. It’s available on eBay, etc (for less than $3). With the USB console working very nicely in Mecrisp Forth now, this board plugs right in - no USB-to-serial adapter needed. There’s just a li’l problem: getting started! The trouble with these F103 boards is how to get Mecrisp on there in the first place.
Bridging MQTT to a µC – Sep 20, 2017 – As part of the bigger JET story, I need to tie microcontroller nodes into MQTT, with the data flowing in both directions: As shown above, the idea is to use Folie for this, but that’s still a way off and I don’t want to mess with it right now. So instead, I decided to create a little stand-alone bridge to perform this task and connect it to this: It’s a simple Go application with no more than a few dozen lines of code.
Cold storage with Btrfs – Sep 13, 2017 – Although external 3.5” disks are no longer much in use here (too noisy, power hogs), I still have a bunch of 500G and 750G drives, as well as a <cough> “huge” 2T drive. They are still useful for keeping old junk files around, off-line. But hard drives fail, and when not used for a long time, they can even refuse to spin up. Bye bye, old data … Losing that data would not be the end of the world (everything of real value is still on my laptop, with triple rotating backups), but for nostalgic reasons I’d still like to hang on to it.
Reducers and transducers – Sep 6, 2017 – As part of becoming more familiar with the Clojure programming language, I recently decided to immerse myself in “Functional Programming” (FP), “Immutability”, “Pure Functions”, and such. It’s been around for decades, but I’ve always shied away from it: too mind-bending / impractical / esoteric. No more: I’m taking it in as fast as I can … To be clear: Haskell and its monads are still way beyond me. But Clojure offers just the right mix of FP and immutable-vs-mutable state for my limited mind to understand why it makes sense and how to use it.
JET today - there's a lot to do! – Aug 30, 2017 – Sooo… with all this talk about Unicorns and Ambitions, it’s now time to walk the walk. I’m focusing my efforts on 3 repositories: JET is the over-arching collection where all the pieces of JET come together. Most of my time will probably go into the new JET/Web front end, built using Lein + ClojureScript + Reagent + Re-frame. Folie is the interface between MQTT on the server and various hardware devices.
The Ambition of JET – Aug 23, 2017 – The JET project is a collection of ideas and some experimental code to try and realise that elusive Unicorn from my last post. A picture explains best what JET is about: There are three sub-systems involved: The web browser acts as a front end and user interface for everything. You launch it when you need to see, adjust, or extend the current setup. The server is the always-on part of the system, powered up 24 / 7.
Chasing the Unicorn – Aug 16, 2017 – No, not that legendary creature - nor this … Although I admit that there’s something mythical about what I’m describing here. I’m talking about the new design for JET. My goal for oh so many years has been to create a development environment that scales across everything I want to develop software for. From the tiniest µC to the ever mightier web browser. With potentially a whiff of FPGA thrown in, as well as quite a range of Linux-based server functionality.
Diving into ClojureScript – Aug 9, 2017 – In my post on multi-platform development recently, I mentioned Clojure (CLJ) as one of the languages which can be compiled to JavaScript - then it’s called ClojureScript (CLJS), although they are almost identical. Having spent a fair amount of time recently reading half a dozen books, viewing tens of tutorial & conference videos, and scanning hundreds of web pages, I’ve been massively impressed by its concepts as well as its implementation - not only of the language itself, but especially the Reagent wrapper around ReactJS and the Re-frame library.
Browser-side programming – Aug 2, 2017 – It’s been a while since I did any browser-side programming. Even though I’ve been meaning to dive back into it for ages (the reasons for which will become clear in an upcoming weblog post). As we all know: Browser + programming => JavaScript While JavaScript is an amazing language, and also works impressively well on the server with NodeJS, I’ve never grown used to it. There’s only so much you can do before hitting callback hell, which even promises can’t really solve, IMO.
Closures versus Objects – Jul 26, 2017 – For a recent project I’ve been working on, I had to deal will lots of small components, each with somewhat different behaviour, and had tried several times (unsuccessfully) to come up with a good design for them. Solving such puzzles tends to depend surprisingly deeply on the programming language used: in C, you’d need to create an ad-hoc object system and muck around with function pointers. In Java and C++ you’d set up an elaborate class hierarchy.
Another pile of books – Jul 19, 2017 – Here are more books I’ve been reading recently, of the “techie” variety and a bit closer to the usual topics on this weblog. For electronics, there’s really not much that can compare to “The Art of Electronics” by Paul Horowitz and Winfield Hill - 2015, 1225 pages, ISBN 9780521809269: It’s not a book to read from front to back, but it really covers just about anything you might want to know about electronics.
A different mindset – Jul 12, 2017 – One of the things I get to do on vacation, and especially while traveling by train, is reading (e-)books - tons of them, in fact. I tend to read a lot all year round, technical articles, textbooks, techie weblogs, world news, and of course code… masses of code. But on the road (track?), I prefer a different mindset, reading (i.e. devouring) thrillers, and … stuff that gives me new perspectives.
A whiff of Denmark... – Jul 5, 2017 – The past few weeks, I’ve been vacationing in Denmark. Now that Liesbeth is no longer tied to her fixed job schedules, we try to take our summer break before everyone else does in July and August. What luxury! This year, we decided on going by train to Denmark, biking and walking around on a lovely small island called Ærø (pronounced a bit like “air-eh”, it rhymes with “turn”), where we relaxed and saw things like this beautiful little beach house near Marstal, where apparently people now get married:
UT61E 4½ digit multimeter – Jun 28, 2017 – Ah, gadgets… can’t have too many of ‘em! It’s hard to think of anything more useful and relatively low-cost for the electronics lab than the venerable digital multimeter. It’s good to have at least two (some people say four: V & I for in-/out-measurements). They don’t have to be identical. In fact, the one I use most is the Voltcraft VC170 as it’s very small and does everything I need.
Low-ripple HP power supply – Jun 21, 2017 – I got a power supply from eBay a while ago: That’s an HP 6255A: 2x 0..40V @ 1.5A, max 80V in series. But the interesting spec is its very low noise: <0.5 mV and <0.2 mA. These supplies are very clean - and it’s all done with old-school linear regulation. So there can be a lot of heat to get rid of: That back section is painted in RED for a reason: it contains some resistors which act as energy radiators.
Quad 18650 power supply – Jun 14, 2017 – Might not have been such a great idea to 3D-print this DIY supply I made in red: (it does look slightly alarming, I’m afraid) This is a little portable power supply I made a while back, with four very common type-18650 cells (widely available from eBay, despite today’s air shipment regulations). It has the following properties (“specs”): adjustable voltage from zero to ≈ 13V maximum current 3A’ish (see below) with (slow) USB charger built in built with low-cost parts from eBay tape + hot glue to keep it together I’m tired of wires running all over my desk - this is one way to try and cut down on some of that while tinkering with electronics.
Hello Pi-hole, goodbye ads! – Jun 7, 2017 – It’s that time of year again: this is the start of “summer mode” for the JeeLabs weblog. Instead of weekly article series, there will be just one post per week, covering a somewhat wider range of topics than usual. This week, I’d like to report on a very nice little gadget to block most adware and even entire sites from all machines on the local LAN and WLAN network here at JeeLabs:
Revisiting the JET design – May 31, 2017 – There’s not much point sprinkling wireless nodes around the house without also a solid central infrastructure to collect data and manage the outbound control requests. Some readers may remember HouseMon and its successor project, called JET. While minimal, I’ve been running the JET “hub” here for a few years, to keep logs and to publish all collected packets to MQTT. Recent experience with Folie has adjusted my views about the main JET architecture, so this week is about the changes I have in mind and how to take JET further again:
2.4 GHz with a JeeNode Zero – May 24, 2017 – The JeeNode Zero has always had two footprints for radio modules on its PCB. Apart from an RFM69 (or RFM12), you can also mount an RFM70, 73, or 75 on there: (this is the older “v1”, the new “v4” is blue) RFM7x offers a new trade-off (lower range, higher speed) and uses the 2.4 GHz band: “around and between” the WiFi channels. In recent days, I’ve been able to get a first preliminary “RF73” driver going, so that’s what this week’s episode will be about:
Going through the motions – May 17, 2017 – The last word in last week’s introductory weblog post was “flow”. Let’s talk about that for a moment: what is it like to develop a Forth application for an embedded µC, and in particular a remote node? Think, upload, rinse, repeat - Wed Multi-platform development - Thu This is the setup I use a lot: a Blue Pill F103 connected via both serial and USB, as well as a JeeNode Zero (v3) - both with RFM69.
Some Mecrisp Forth utilities – May 10, 2017 – This week, I’m going to demonstrate some tools from the Mecrisp Forth distribution. A different prompt, math functions (even without hardware floating point), random numbers, call tracing/profiling, and ad-hoc patching for debugging - it’s all there: Simple Mecrisp Forth utilities - Wed Let’s trace, profile, and patch - Thu Generated code & performance - Fri Development in Forth is radically different from working with C and C++ programs:
Back to Forth explorations – May 3, 2017 – Now that the EZ-Retro project is beginning to wind down, I’ll start exploring Forth’s features and behaviour a bit more again. One of the distinguishing features of a fully self-hosted system like Mecrisp, is that it uses available µC memory in specific ways: The other news for this week is further improvements for Folie and the USB console, so I’ll expand on that as well: Mecrisp Forth’s memory use - Wed Folie is growing up… slowly - Thu F103 + USB = Swiss Army Knife - Fri As always, these articles are published on separate days of the week - this keeps me on my toes, and makes it more interesting for you as well, I hope.
Just a bunch of opinions – Apr 26, 2017 – This week, I’ll report about some progress on the next EZ-Retro “v2” PCB and build (which isn’t quite right yet, unfortunately). But first, a topic which has been keeping me busy lately… typing and the keyboard: No, not the above Simplified Chinese one: The limits of Mac and Mouse - Wed Why Vim is very different - Thu Taking it further with i3 - Fri EZ-Retro v2, now with a PCB - Sat Troubleshooting the EZ-Retro - Sun As the title of this post says, these are all just very personal opinions of course, so please take with a grain of salt and brush it off as random rants when you don’t agree with some, or even any, of this…
Circular motions – Apr 19, 2017 – Just back from a few days in Paris, visiting friends (a bit south of Paris, actually), but we did manage to squeeze in a stroll in the Jardin du Luxembourg - with memories of a (brief) childhood there, bringing my sailboat to the pond, always hoping that it wouldn’t get trapped under the fountain… Once back, I fell into all the procrastination traps there are - yak shaving, bikeshedding, and other rabbit holes.
EZ-Retro Z80 - part 2 – Apr 12, 2017 – Getting CP/M working on this two-chips-plus-a-blue-pill setup took more time than I thought, especially on the software side. This week, I’ll turn Forth into a peek-and-poke monitor for the eZ80, describe how to bootstrap the initial code, build a minimal BIOS for CP/M, add a µSD card socket with SPI request bus, and finish off with a FAT-file mapped jukebox style floppy disk setup. Let’s get started, this will be a long episode!
EZ-Retro is a Z80 running CP/M – Apr 5, 2017 – And now something completely different! I’ve always been fascinated by those 8-bit computers that started it all. As a teenager, I spent many hours reading about them, but never could afford a Z80 system capable enough to run CP/M, for example. While BASIC and games were never my thing… Floppies were totally out of reach for me. Later came MS-DOS and the PC clones, and things changed. But so did the fun: these were no longer systems to tinker with, all I did was get expansion cards and insert ‘em.
SD cards, interrupts, and DMA – Mar 29, 2017 – This week is another potpourri of code for the STM32F103, the purpose of which will become clear next week… suspense! SD cards and µSD cards have a ridiculous amount of storage in a very small package. All solid-state, no moving parts, very quick to read and write, and easily accessed from a µC through just 4 I/O pins. Next on the menu: an exploration into how hardware interrupts and Mecrisp’s multi-tasker can be combined, as a convenient and robust way to deal with interrupts.
Keeping busy (in Forth) – Mar 22, 2017 – Serial ports, radio packets, I2C devices… it adds up when you’re trying to keep many activities going at once. Luckily, there are some nice packages for Mecrisp Forth to help with this… This week, I’m going to look into multi-tasking, timers, and how this impacts ultra low-power use in battery-powered nodes: Let’s try out the multi-tasker - Wed Sometimes, timers are easier - Thu Stay busy, but also sleep a lot - Fri For now, I’ll be using this test setup:
No milk today... – Mar 15, 2017 – Yikes. I’ve been felled by some bad stomach cramps and fever these past couple of days. Hence no articles this week - my apologies! The blog will resume next week, stay tuned.
Bring in the Pies! – Mar 8, 2017 – For production, fast re-flashing and testing of each JeeNode Zero is going to be a must. This week’s episode will be about speeding up the uploads, but also several ways to debug and test any STM32 board: Let’s dive in - one article per day, as usual: Faster uploads through SPI - Wed Every possible connection - Thu Setting up the Pi software - Fri The approach described here will work on any Raspberry Pi, even the very early “A” units with a 26-pin header & 256 MB RAM.
A wireless rotary encoder – Mar 1, 2017 – This week, I’ll be playing around a bit with a rotary encoder, wireless, and an OLED: But first, a brief tale of a belated little bug which caused a few surprises… Post-mortem of a bug - Wed Connecting a rotary encoder - Thu Cutting the rotary cord - Fri Making an always-on device - Sat Several years on a coin cell? - Sun The latest news is that the backlog of new JeeNode Zero rev4’s has been sent out - \o/
The JeeNode Zero rev4 – Feb 22, 2017 – It’s official: the first batch of JeeNode Zero rev4’s has been assembled, pre-loaded with software, and tested. Currently in transit from NL to the UK shop. It’s real now: There are a number of articles this week about getting started, with a look under the hood of the uploading and testing process: Getting started with a JNZ - Wed Installing more drivers in flash - Thu Setting up a remote node - Fri How all those JNZs are tested - Sat As usual, these articles are spread out over the week and published on successive days.
Various JNZ developments – Feb 15, 2017 – While waiting for the next JeeNode Zero revision, I’ve started on some examples and documentation for this new fun ecosystem. So there’s a bit of everything this week: Analog over wireless - Wed Sending multiple values - Thu A new documentation site - Fri The JNZ rev4 PCBs are in! - Sat The assembly of this new batch of JeeNode Zeros will be done next week - component placement and reflow are all going to be done manually for now, so there’s a lot of pasting, tweezering, and testing ahead.
The upcoming JNZ rev4 – Feb 8, 2017 – Now that the JeeNode Zero rev3 has been out for a few weeks, I’ve made a few more changes before it goes into production: I’m calling it “rev4” for now, but expect it to be virtually identical for the final release. A few design changes in rev4 - Wed Making the silkscreen useful - Thu A board made for tinkering - Fri Prototype PCBs have been ordered and should arrive here any day now.
Various shades of Forth – Feb 1, 2017 – This week’s episode will cover a variety of aspects related to Mecrisp Forth: Using Linux i.s.o. a SerPlus - Wed Forth over USB on STM32F103 - Thu Performance and I/O toggling - Fri As always, these posts are spread out over several days, so don’t despair if you click a link early on and see a server 404 error…
Let's have some fun with a JNZ – Dec 28, 2016 – Since the JeeNode Zero adopts a new µC architecture, a new layout, a new runtime library, a new programming language, and new drivers, there’s a lot of work ahead to describe all the parts and how to use them. It will take quite a while to do this in a thorough and systematic manner, so for the time being, my approach is to select and highlight the essentials, then gradually expand on all the aspects and implications this has for putting these nodes to real use:
The upcoming JeeNode Zero – Dec 21, 2016 – Lately, I’ve been keeping busy with a brand new board. It’s called the JeeNode Zero: Shown here is the “rev3” prototype, and it’s starting to shape up nicely. Sooo… without further ado, let me tell you more about it: Working on the JeeNode Zero - Wed Some specs and comparisons - Thu This node speaks Forth (and C) - Fri Taking the JNZ rev3 for a spin - Sat JNZ testing and availability - Sun This isn’t about being the first or cheapest “node” out there, in fact this isn’t about any <insert-your-favourite-superlative-here>.
Interactive development – Dec 14, 2016 – Most readers will be familiar with this view: Now that you’ve seen how to build software and run it on the Blue Pill in the traditional way, I am going to switch gears radically: Stop staring at that screen! - Wed Peeling off layers of complexity - Thu Polish notation and tiny words - Fri Let it burn, then press CTRL-C - Sat Making an LED blink (and fade) - Sun Cutting the serial cord, sort of - Mon As always, these articles are published on successive days of the week instead of all at once.
Getting started with STM32 – Dec 7, 2016 – ARM Cortex microcontrollers are incredibly powerful 32-bit computers - many not larger than the size of a fingernail, and able to sleep with just a few µA of current draw. There’s a whole bunch of cheap little boards on eBay so you don’t even have to get your soldering iron to have a lot of fun with ‘em: But there’s a catch: you also need a way to connect to them, and you need the proper toolchain to write code for them and upload it into the chips.
Blu-Ray safety copies – Nov 30, 2016 – Having been bitten by data loss occasionally during the past decades (several of them dumb “operator error”, I must admit), I’ve adjusted my backup strategy a few times. Since I live in an “all-Mac” world (plus a bunch of RasPi/Odroid Linux boxes), I’ve been adopting other solutions than some people out there, I suppose. Data storage requirements are fairly low here at JeeLabs. I don’t keep a video collection (I don’t see the point, we rarely watch a movie more than once).
A fast µC to FPGA bus – Nov 23, 2016 – For reasons which will become clear later, I’d like to exchange data quickly between an STM32 µC and an FPGA. SPI is a serial bus, which can be pushed to several dozen Mbit/sec - but what if we want more? Suppose we could “map” the FPGA into the STM32’s memory space and then simply read and write bytes? No handshaking, no interrupts, no polling. One advantage of such an approach, is that it could transfer data really quickly through DMA - without tying up the µC’s CPU at all.
So many memories – Nov 16, 2016 – An EP4CE6 FPGA has 30 KB of built-in “Block RAM” memory. Fast, but limited in size. With SDRAM, you can have megabytes more, but it’s not quite as fast and harder to interface to, due to the periodic refreshes. Another option is normal static RAM. Low-cost chips are available in various sizes and speed grades, e.g. this 512 KB chip on eBay. SRAM still needs some glue logic to get the details right, but the result is predictable timing.
Tying into SDRAM – Nov 9, 2016 – Synchronous Dynamic RAM is perhaps the most common form of random access memory - it’s large (MBs, vs SRAM’s KBs), it’s fast (supporting 100 MHz and higher), and it’s low cost due to the widespread use in PCs and laptops for the past few decades. But SDRAM chips are notoriously hard to use, compared to SRAM: they’re dynamic and need special periodic “refresh” cycles to maintain their contents. They also use a multiplexed row/column address to keep the chip’s pin count low.
Composite video from FPGA – Nov 2, 2016 – Last week’s setup was just for warm-up – I wanted to understand the signal generation before bringing it over to an FPGA. Here is the same signal, generated by the same µC, but passing its data through the FPGA: We’re now all set to turn those code loops into raw gates and counters. As expected, the FPGA is much faster and easily able to generate single-pixel lines on the screen:
Composite video from ARM – Oct 26, 2016 – Some weblog posts tend to take me further away from the usual topics. No worries… it’s just that I want to explore some “outer edges” to better understand complexity & speed trade-offs between µCs and FPGAs. So… let’s generate a video signal with a µC! This is the HyTiny-based STM32F103 RF Node Watcher I used before, re-purposed here to generate a composite video signal. Black-and-white composite video is very easy to generate – it needs just two output pins and two resistors.
Debugging an FPGA via a µC – Oct 19, 2016 – When trying out things in Verilog, one of the struggles I have is understanding what my “noob” code is doing. There’s no such thing as a printf here, obviously. There’s simulation, but that only goes so far when tying into the real world, and there are LEDs and 7-segment displays, which are trivial to attach to some internal signals. But that’s not enough: I want a transcript of a series of events, to see what happened, in the proper context and sequence.
PDP-8/L & DF32 disk on FPGA – Oct 12, 2016 – As final entry in this PDP-8 saga (for now), I’d like to present an FPGA implementation of a small but very functional setup by Ian Schofield of a PDP-8/L with serial console and a whopping 32-kiloword disk drive. All available for $25K at the time (PDF). Ian’s project is for the Cyclone III of an old’ish Nios II Embedded Evaluation Kit. Luckily, the DE0-Nano has enough on-chip BRAM memory to take its place.
STM32F103 emulating a PDP-8 – Oct 5, 2016 – Note: these weblog posts now appear at a leasurely once-a-week pace. Although the summer vacation time is now over, I have decided to stick to this schedule for a while: more time to think and prepare new posts. The following exploration falls squarely into the “simply because I can” category. With last week’s implementation of a low-end PDP-8, it’s not hard to take this “let’s emulate a PDP” theme onto other platforms.
TFoC - PDP-8 in 256 lines of C – Sep 28, 2016 – Always in search of the essential “fabric” of computing, I decided to create yet another PDP-8 emulator. In plain C, and in as few lines of code as possible - without resorting to obfuscated C. It ended up being 256 LOC. The PDP-8 was kicked into the world in 1965. It’s an atractive target, because its instruction set is minimal, with quite a number of applications available for it. My goal was to implement enough of the core to support FOCAL-69, a BASIC-like programming language from DEC, which supports interactive editing and floating-point, all in 4K 12-bits words of memory.
Diving deep into SPI – Sep 21, 2016 – As a somewhat more substantial exercise to learn Verilog, I thought I’d write an SPI master controller - should be easy, right? The Serial Peripheral Interface bus can deal with high speeds (at short distances), only uses 4 I/O pins, and it looks like quite an elegant bi-directional transfer mechanism: Two shift registers, connected in a circle, with bits rotating through (MSB to LSB). The devil is in the details, though:
Running a simulated FPGA – Sep 14, 2016 – Who needs real hardware? One of the very nice things you can do with Verilog (and VHDL), is to use it as basis for a simulator. Especially with synchronous designs, which do all their work in lock-step with a central clock, simulators can provide a good insight into what’s going on without having to load the design onto real silicon. Verilator is a great tool for this, and does something really clever: the Verilog code is first translated into C++, which you then include in a small main loop of your own, compile, and run - preferably on a modern laptop or desktop machine.
I never had an Intel 8080 – Sep 7, 2016 – … although I spent months tinkering with a Z80 chip in a previous life - long, long ago. But with an FPGA, that can change, at least in the virtual sense: there are several “soft cores” implementing an 8080 chip in a HDL, including memory and peripherals. The light8080 project at OpenCores is one such implementation (in Verilog), and it’s quite an interesting beast because it uses a microcode architecture. Microcode is like “the lowest of low-level stored-program execution models”: it sits between machine instructions and the gates, registers, and memory comprising its implementation.
Let's build (half a) UART – Aug 31, 2016 – The problem with FPGAs is that they’re so low-level. It’s a bit like sitting on the floor with a huge pile of 7400 series chips, trying to make them do something … u s e f u l ? When starting from scratch (just for my own education and entertainment), one of the first things I’ll want is to hook up the FPGA to some nearby computer or µC. The one tool that comes to mind is a serial UART interface, so let’s try and build one.
PMOD connectors – Aug 24, 2016 – Last week’s post used the 12-pin “Pmod” connector on my FPGA board to generate the X, Y, and Z signals. Pmod™ is a simple header pinout standard (PDF) defined by Digilent. There’s a (free) license for this, but only if we actually call it Pmod. So I won’t - I’ll simply refer to the two variants as 6-pin and 12-pin headers… the 6-pin header is: IO1 IO2 IO3 IO4 GND +3.
Sweep, staircase, and blanking – Aug 17, 2016 – We’ve all seen images like this before: Well, maybe not consciously, but this is the way images are “painted” across the screen of a CRT in old TVs. A sweep from left to right, combined with a step-wise change in the vertical direction. The dotted curves joining the straight lines are the “flyback” of the electron beam moving to the next step. It’s also the basis of a Curve Tracer, used to plot the characteristics of semiconductors and other components: one variable is varied continuously, while another one changes in discrete steps.
VGA in Verilog – Aug 10, 2016 – Verilog is a Hardware Description Language - you can “write” logic circuits in it. It’s very intriguing due to its built-in parallelism and the way an actual circuit can be inferred from a high-level behavioural description. While googling around, I found a very simple VGA video signal generator in Verilog on the TinyVGA.com website. This generates an analog VGA signal with the help of a few resistors, which can be viewed on any VGA monitor supporting the industry-standard 640x480 layout.
CPLDs and FPGAs – Aug 3, 2016 – It’s vacation time - I’m having fun doodling with logic devices and gate arrays… have been messing about with them before, when duplicating Grant Searle’s neat Z80 setup. This time I want to write some code myself. There are zillions of FPGA boards, so here’s what I’ve narrowed it down to: From left to right: MAX II CPLD - with 240 logic elements (LEs), 1K of flash memory, and 80 I/O pins - this eBay board is $7, but you also need this $3 USB Blaster to program it
TFoC: FPGA & Forth = VGA – Jul 27, 2016 – (This article is part of the The Fabric of Computing series: in search of simplicity) Here is a fun project, created from start to finish by Matthias Koch, as part of his Mecrisp implementation of Forth: What you’re seeing is a Nandland Go Board running Mecrisp-Ice, generating a VGA 512-colour video signal on a 7” LCD display. In itself, this is no big deal. The generated pattern is a 16x16 expanded pixel image, and 640x480 displays are pretty basic by now - although they’re fine for presenting text-mode information and retro games.
The disconnected life – Jul 20, 2016 – On those recent travels across Scandinavia, I had a chance to reset my expectations of what life is like when not “attached to internet” all the time. Quite unlike what I’d imagined, I can tell you. First off, I was in fact online far more often than I originally had planned, despite having only WiFi connectivity at my disposal (only an iPad, no smartphone, no mobile roaming). Whoa… hotels, café’s, even the trains - WiFi everywhere!
Scandinavia by rail – Jul 13, 2016 – It will not have been obvious from this weblog, since new posts are now automatically published each Wednesday at midnight, but these past few weeks I’ve been on vacation, travelling across Germany, Denmark, Sweden, and Norway - by train, via the same Interrail arrangement I used at the age of 16, eons ago… Some amazing experiences - from a train-on-the-ferry (!) between Hamburg and Copenhagen, to beautiful single-track trips across mountains, forests, rivers, and lakes (no fjords, we weren’t that close to the sea).
Mecrisp on other platforms – Jul 6, 2016 – We’ve already seen that Mecrisp Forth is also available for the Nandland Go Board FPGA board. But Mecrisp Forth can in fact be used on several other platforms. For one, there’s the MSP430 version (which like the Go Board, is a 16-bit version, not 32-bit as on ARM). Here’s a build using the MSP430G2553 chip, with 16K flash and 512 bytes of RAM: This one communicates at 9600 baud by default, and has about 5 KB flash free for user code.
Keeping track of time – Jun 29, 2016 – One of the things I’d love to do is measure the AC mains grid frequency with fairly high precision. We know that it’s kept at 50 Hz long term, so that old mains-powered alarm clocks, etc. can keep track of time by simply using AC mains as their input time source. But at the same time, there’s a well-known effect with generators, which causes them to slow down when the load is high and speed up when the load is low.
Convolution, anyone? – Jun 22, 2016 – Right now, the JeeLabs Energy Monitor only tracks and reports three mains pulse counters here at JeeLabs. The smart meter’s P1 serial data source will be added soon, but there have been issues with reading it out with only a 3.3V power source - some more experimentation is needed to sort this out. The next task will be to read out 3 current transformers using the STM32F103’s 12-bit ADC, as well as the AC mains signal, to be able to perform lots of multiplication w/ sums and estimate the real and reactive power consumption for each channel.
Forth on Nandland Go Board – Jun 15, 2016 – After a recent excursion into FPGAs, and in particular Z80 + CP/M emulation, I’ve been tracking developments and keeping tabs on what’s being going on in both FPGA- and Retrocomputing-land. FPGAs are amazing chips. The interest in these universal chips is increasing, not in the least due to IceStorm - an open-source toolchain to perform the complex task of turning a high-level logical description of the chip into an actual “bitstream” which can be loaded into an FPGA.
Thoughts about app structure – Jun 8, 2016 – These are some ideas about how to structure the flash and RAM memory for applications built on top of Mecrisp Forth. First off: 64 KB of flash memory turns out to be plenty for very substantial applications. All of the current JeeLabs Energy Monitor code easily fits within 64K (even though the Olimexino has 128K). And that includes the RF69, OLED with graphics, ADC with DMA, pulse counters, DCF decoding, as well as the core hardware abstraction layer, clock and time management, SPI and I2C drivers, timers, PWM, RTC, interrupt-based UART with ring buffers, and the multi-tasker.
Standalone USB firmware – Jun 1, 2016 – Announcement: As of today, the JeeLabs weblog is switching into lower gear, as we move towards the Northern hemisphere’s summer recess. Instead of a weekly post plus several articles, there will be just one single post (on Wednesdays, as always). This week continues where I left off the last time. The USB driver is now good enough to run stand-alone on a board like the HyTiny: No more serial USB interface adapters, this now talks serial directly over built-in USB.
Tying up several loose ends – May 25, 2016 – This week is yet another mixed bag of topics, all related to either the JeeLabs Energy Monitor, or taking the STM32F103 platform further with Mecrisp Forth. It might not look like much from afar, but there’s substantial progress under the hood: Parsing P1 smart meter info - Wed The need for multitasking - Thu Using a buffered serial console - Fri USB serial in Forth, progress! - Sat Here’s the setup I’ve been using during the development of the USB driver:
Working on JEM – May 18, 2016 – The JeeLabs Energy Monitor prototype is progressing nicely - once I figured out that I had my numbering of the Arduino analog pins 0..5 reversed… doh! Here is what’s on the menu for this week: Tracking pulses w/ interrupts - Wed Frequency aliasing in ADCs - Thu Simple variable packet data - Fri It turns out that this little STM32F103 µC ARM chip in the Olimexino board I’m using has plenty of power to perform an amazing number of tasks in parallel: acquiring four ADC channels at 25 KHz each, keeping track of the exact timing of three pulse counters, driving an OLED display, sending out packets over an RFM69 link, and more…
This week's potpourri – May 11, 2016 – This week will be a hodgepodge of topics which I’ve been working on recently: a hardware interaction which kept me really puzzled for quite some time, a delightful excursion into the deeper innards of the STM32F103 µC, and an exploration into the raw performance of ARM chips and Forth: When an input pin isn’t one - Wed Great ADC/DMA performance - Thu Some µC speed measurements - Fri As always on this weblog, each article this week is released on successive days, to let me stay - slightly - ahead of the game.
Upstairs, downstairs – May 4, 2016 – It turns out that tinkering and development is hard when the signals to be measured are located far from my desk and electronics workbench. The meter cabinet is located downstairs next to the front door, while my lab / playground is three half flights up (we live in a split-level house). While bringing a laptop down for software development and upload would be easy, taking the scope down there and leaving it all hooked up for days on end… not fun.
Going 32-bit, at last – Apr 27, 2016 – Given last week’s mishap, and the resulting damage to the main metering JeeNode, it’s time to start creating a new setup. While I’m at it, I’ll throw a few new measurements into the mix and will also try to improve on the robustness and autonomy of it all: Energy monitor requirements - Wed Powering from an AC source - Thu Reading out the pulse counters - Fri This is just a start, there are lots of different angles, each of them probably a project in itself.
Water damage – Apr 20, 2016 – We recently had a small water leak in the kitchen - leading to a 3-hour server outage for JeeLabs. Very early in the morning, so very few people will have noticed it - other than an ever-vigilant fellow named Ard… Some “interesting” things happened, so I thought it’d make a nice topic for this blog: Water and electricity don’t mix - Wed And then the JeeNode stopped - Thu A new design, moving to 32-bit - Fri As always, the articles in this week’s series will be published on three successive days.
Real op-amps – Apr 13, 2016 – Operational amplifiers are the work horses of analog. The standard notation for it is: There are lots of low-cost op-amps available these days. Easy-to-use 8- or 14-pin chips, with 1, 2, or 4 op-amps in a single package. The principle of an op-amp can be described concisely as (see Chris Gamell’s website): The op-amp always “wants” both inputs […] to be the same value. If they are not […], the op amp output will go positive or negative, depending on which input is higher than the other.
Analog Explorations – Apr 6, 2016 – There are many projects going on in parallel here at JeeLabs at the moment. One reason is that I’m simply always chasing new butterflies… ehm, I mean areas of technology. Another one is that sometimes I get stuck, and decide to put things away for another time (this works remarkably well), and yet another is that there are some directions I’d really like to explore more deeply, but which are going to be such a large topic, that I just need to find a suitable “way in”, to see where it leads to and figure out how to structure the stories.
From Zero To Wireless – Mar 30, 2016 – This week, I’m going to set up a wireless node from scratch, using an STM32F103 board, RFM69 radio module, serial USB interface board, and very simple software: The result is a node with all the software needed to send / receive RF packets, with a complete Forth system on board, ready with drivers for digital and analog I/O, PWM, I2C, and SPI. Let’s get going - 1 article per day, as usual:
And so Forth... – Mar 23, 2016 – This week’s episode will be a short one, as I try to push though some issues and prepare for greater things to come. First, a little progress report on getting USB going in Mecrisp Forth on the STM32F10x series µCs. This has been evolving nicely, but there are still some important hurdles to overcome - not all USB-related, actually. USB on STM32F10x µCs - Wed The second post is my little attempt to “explain Forth” to someone not familiar with it.
Where is this going? – Mar 16, 2016 – The last three weeks have been a deep dive into the programming language Forth on STM32 µCs. Results so far have been very encouraging, in terms of using Forth for programming ARM µCs in general. But what about JET, HouseMon, wireless nodes, ultra low-power, and all that jazz? Well, I think there’s a very interesting opportunity here to bring several of these technologies together in the world of Physical Computing, and home monitoring & automation.
Dive into Forth, part 3 – Mar 9, 2016 – The Forth adventure continues… this is part 3 of a series about Mecrisp Forth on ARM STM32F103 µCs - an amazing environment for interactively trying out the hardware in this well-established chip series. As you’ll see, there’s quite a bit to explore… This week highlights the capabilities and performance levels achievable with such a (fairly low-end) microcontroller, especially once you start enabling things like hardware interrupts, ADCs, DACs, timers, and DMA.
Dive into Forth, part 2 – Mar 2, 2016 – Switching to Mecrisp Forth implies starting from scratch as far as low-level access is concerned. There’s no C “runtime library” to fall back to, everything will have to be implemented in Forth. This week, I’ll describe some of the steps taken so far to make that happen: Buffered serial port interrupts - Wed Much faster SPI with hardware - Thu Talking to a 320x240 colour LCD - Fri The source code is available on GitHub.
Dive into Forth – Feb 24, 2016 – In 1965, computing history was made when DEC introduced a new computer, called the PDP-8 - oh, wait, that was last week’s post. But it applies here too: 1968 was the year when Charles Moore invented Forth, a stack-based programming language. This week is about exploring the Mecrisp implementation of Forth, which runs on a range of ARM Cortex microcontrollers: As a language it’s quite fascinating, but as a programming context, Forth is actually in a league of its own - an amazing fit for µCs!
The PDP-8, half a century ago – Feb 17, 2016 – In 1965, computing history was made when DEC introduced a new computer, called the PDP-8. It was the start of a long series of incrementally improved models, later to be followed by the even more successful and ground-breaking PDP-11 series, and then the VAX. It’s a fascinating story, because so many technological trends of that time have shaped what we now use on a daily base, from laptops, to mobile phones, to watches.
Day-to-day JET practicalities – Feb 10, 2016 – Here’s a “JET” engine, for your amusement: This week, I’m going to go into the practical aspects of the JET project: for production, i.e. the always-running hub + MQTT server, and for development, i.e. what is needed to work on this software and take it further. As you’ll see, these end up at two extremes of the spectrum: a tiny setup with minimal dependencies is enough for production, whereas development requires a slew of tools (albeit standard and well-supported), and a hefty machine if you want a snappy development cycle.
Let's talk about the 'N' in WSNs – Feb 3, 2016 – The acronym “WSN” stands for Wireless Sensor Network. Ok sure, we all have one or more wireless sensor nodes, JeeNodes or whatever, and they probably work nicely. But how do we manage them? What about code revisions? Let’s go into this for a moment. Because the usual approach of: “a sketch, an upload, and off you go” doesn’t really scale well. How do you manage all those nodes, which may be different in functionality, in their hardware, or even just be different models or revisions of the same type?
What's in a hub? – Jan 27, 2016 – The restart of the JET project is progressing nicely. This week’s episode is about installing a first version as a basic-yet-functional new core system and describing / documenting some of the central features being built into the hub. So here goes, one story per day, about what JET/Hub is all about: An introduction to JET/Hub - Wed Connecting to serial ports - Thu Timestamps and logging - Fri How to install JET/Hub - Sat Hub configuration guide - Sun Using the built-in database - Mon Yes, that’s a lot of articles for one week.
Overcoming JET lag – Jan 20, 2016 – Long-time readers of this weblog know that the topics here have always been all over the map - electronics, digital design, embedded firmware, but also trying out new stuff, getting organised, re-thinking software development, and more. This week is no exception… I’d like to revisit the design of a long-term home monitoring and automation system for use here at JeeLabs. If you’ve been keeping count, you could call it “HouseMon IV”, but I’m going to stick to the name “JET” for this project.
Arduino shields... or not – Jan 13, 2016 – Once upon a time, when the Arduino was still young, someone made a mistake with the headers on its PCB, placing one of the headers off the standard 0.1” placement grid - as used by just about everything else in the electronics prototyping world. The result is history: Arduino shields always have one header on a 0.06” offset, instead of 0.1”. The big irony is that this mistake now benefits the Arduino world, since it uniquely differentiates it from everything else.
Getting (a bit more) organised – Jan 6, 2016 – More spring cleaning. This has been keeping me busy for a couple of days, so I thought I might as well write about the issues and solutions I’ve found for them: Sh(r)edding those CDs & DVDs - Wed Squashing tons of source code - Thu Keeping track of lab supplies - Fri Probably the world’s most famous cluttered workbench is by the late Jim Williams: But where the human mind thrives on rich visual context, somehow that doesn’t seem to carry over to bits and digital storage!
Turning the page on 2015 – Dec 30, 2015 – As the last few days of 2015 pass, I’d like to reflect on the recent past but also look forward to things to come. For one, the JeeLabs weblog is now thriving again: the new weekly post-plus-articles format has turned out to suit me well. It keeps me going, it’s oodles of fun to do, and it avoids that previous trap of getting forced into too-frequent daily commitments. Apart from a summer break, every week in 2015 has been an opportunity to explore and experiment with physical computing topics, several ARM µCs, and various software ideas.
Tying up 2015's loose ends – Dec 23, 2015 – As the end of 2015 is approaching and now that the new server setup has been completed, it’s time to clean up some remaining loose ends. Spring cleaning is early, here at JeeLabs! Next week will be a good time for reflection and my new year’s resolutions. For now, I just want to go into some topics which didn’t seem to fit anywhere else. In daily doses, as usual: Getting the most out of rsync - Wed Temporary post-HouseMon script - Thu Great visibility, no cloud in sight - Fri I’m pleased with the new Odroid XU4 server so far.
Switching to a new server – Dec 16, 2015 – As you may know, the various websites here at JeeLabs are served locally. Houten offers very fast Fiber-To-The-Home connections, my ISP (XS4ALL) is excellent, and I don’t see the point of putting everything in the cloud. Sure, it’s a bit more work to keep going, but this way I can delude myself into thinking that I am “the master of my own universe” … This Mac Mini server has been doing all the work for several years now:
A diversion into FPGAs – Dec 9, 2015 – Last week’s exploration of “processing with limited computing power” a few decades ago has led me into another direction which turned out to be mesmerising and addictive… All due to a chip called a Field Programmable Logic Array, which usually looks like this: That’s a lot of pins - large FPGA’s can have over 1,000 pins, in fact! What are they? What’s the point? Why are they so hard to use?
A fingernail vs a moon lander – Dec 2, 2015 – Small microcontroller chips, modern laptops/desktops - the range of computing power is enormous nowadays. So enormous, that it can be pretty hard to grasp the magnitude. This week, I’m going to do some explorations, using a HY-Tiny board with an STM32F103 on it. Or to be put it differently: a fairly low-end but popular 32-bit ARM Cortex M3 µC, running at 72 MHz, with 128 KB flash and 20 KB RAM.
Pi-based STM32F103 development – Nov 25, 2015 – There are many ways to experiment with embedded development, which is what the Arduino IDE really is all about. But before diving more into using the Arduino IDE with STM32 µCs, I’d like to mention another option, based on a Raspberry Pi (A+, B+, or 2): It’s called the ARMinARM board, by a company called OnAndOffables: a board with an STM103RE, sitting on top of the RasPi, with lots of connections to communicate through.
Programmer PCB Triple Play – Nov 18, 2015 – To follow up on last week’s upload articles, I’m going to turn a couple of these boards into Black Magic Probe programmers: From left to right: an STM Nucleo F103RB (any Nucleo will do, though), a board from eBay (many vendors, search for “STM32F103C8T6 board”), and Haoyu’s HY-TinySTM103T. And let’s do it right, with a couple of custom PCB’s - here are three versions (the first one will keep its original firmware, actually).
Talking to an STM32 – Nov 11, 2015 – When dealing with ARM µCs and boards based on them, there’s always one big elephant in the room: how to upload software to them, and how to talk to them via serial or USB. The available options, choices, trade-offs, and even just their properties can be staggering. This week’s article series is about what the problem is, an overview of the many different ways to address them, and how to get started with the minimal fuss and/or minimal cost.
The world of STM32 – Nov 4, 2015 – As announced last week, I’ll be switching (pouring?) my efforts into a new series of µC’s for a while, so there’s quite a bit of work ahead to get going, and I really don’t want to dwell too much on the basics. The whole point is to get further, not redo everything and get nowhere! So for this week, there will be a whole slew of posts. As usual, each next post will be ready on successive days, as I figure it all out and try to stay ahead of the game :)
Making a sharp turn – Oct 28, 2015 – During my tinkering over the past two weeks, I hit a snag while trying to hook up the LPC824 µC to the Arduino IDE. Nothing spectacular or insurmountable, but still… This week, I have two articles for you, explaining what this is all about: Serial uploads vs flow control - Wed Revisiting existing chips and code - Thu Warning: there are going to be some changes w.r.t. where I’ll be going next…
IDE w/ LPC824, part 2 – Oct 21, 2015 – Let’s get that upload going. Remember, this is about adding a “hardware platform” to the Arduino IDE so it can compile and upload files to a Tinker Pico, based on the LPC824 µC. There are two parts to this: 1) getting all the IDE setup files right so that it knows how to compile & upload, and 2) implementing pinMode(), digitalWrite(), etc. so they can be used with LPC824 microcontrollers in the same way as with ATmega’s and other µC’s.
Arduino IDE w/ LPC824 – Oct 14, 2015 – What will it take to support the LPC824 µC, i.e. the Tinker Pico, from the Arduino IDE? As the Arduino IDE has been evolving and growing over the years, more and more µC platforms have been added - both officially and unofficially - after the initial ATmega µC’s. One of the earlier ones was Energia, which was created as a fork to support TI’s MSP430 chips, but as the IDE matured, it has become easier to support several other architectures in the mainstream build as a simple add-on, such as ESP8266 and STM32.
Meet the Tinker Pico (again) – Oct 7, 2015 – It’s time to get some new hardware out the door, which I’ve been doodling with here at JeeLabs for quite some time, and which some of you might like to tinker with as well. The first new board is the Tinker Pico, which was already pre-announced a while ago. Here’s the final PCB, which is being sent off to production now, soon to appear in the shop: As before, each week consists of one announcement like this, and one or more articles with further details, ready for release on successive days of the week - three in this case:

(see the Archive for older entries)