Book Review – The Works: Anatomy Of A City

Cover Photo
If you can’t walk past a hole in the street without leaning over the edge to see what’s down there, then this book by Kate Ascher will tickle your fancy. It tells the hidden story of New York’s infrastructure covering everything from airports to sewage.

Road Junction Layout Types

It’s light enough to be an easy read without getting too bogged down in the details and it’s well illustrated throughout. Personally I would have preferred a bit more detail on the engineering side of things which I think could have been brought in at the expense of some of the more New York specific historical stuff. Definitely an interesting read though.

Build A Computer From Scratch (Kinda Sorta)

I’m currently part way through a fantastic course on hardware design. It’s called Nand2Tetris and walks through building a simulated computer from the very simplest components (individual transistors) right through to a fully functioning computer. There’s a subreddit available if you want to chat with some fellow learners and a TED talk covering the course and some of the educational ideas behind it.

Everything runs in a simulator so there’s no actual hardware to buy or break or futz about with (which you may or may not find attractive) and this means you can focus on the underlying theory and understand what’s going on rather than getting bogged down in implementation details.

Still early days (I’m busy building some of the more complex components from basic logic gates at the moment) but it’s very good so far. No previous experience is required, but if you have none, be prepared to do some fairly serious thinking and maybe a bit of background reading along the way.

Update 2016-03-26:
All done now. I really liked this course. It had great pacing and a really good overall shape that kept my interest all the way through. There was plenty of detail without any tedious busy-work and it covered an awful lot of ground without feeling overwhelming at any point. While this little short course in no way represents the realities and complexities of a real world project it did provide a great insight into what kinds of issues are involved in computer design. The projects all required some thought but built on previous knowledge very well and there was a definite sense of accomplishing something really quite significant for the relatively small amount of effort involved. 10/10 would recommend.

Hacking Lego Motors

Lego Technic Power Function motors are nice and easy to hack for robotics projects – in large part because they come with a built in gearbox so you get nice amounts of torque at low speeds right out of the box.

Here’s a quick breakdown of what you need to know. The tl;dr is that you apply a 9V PWM signal to the two inner cores of the ribbon cable. The outer two cores are not connected.

I’m using the M Series 8883 motor but there are plenty of alternative choices available. I’ve not tried them but I would assume they all use the same pin-outs.

The motor is supplied attached by a four-way ribbon cable to a lego electrical connector:

Motor and Connector Combinaton
Motor and Connector Combinaton

You can either snip this cable in the middle and solder the individual cores or you can sacrifice a simple lego PF extension cable instead and leave your motor assembly intact.

The Lego PF system uses a standard pin-out system across all the products but note that for our purposes here we only need the C1 and C2 lines (the 0V and 9V lines are not connected inside the motor).

Here’s a photo of the motor end showing the pin-outs:

Motor End Pin Assignments
Motor End Pin Assignments

And here’s the pin-outs for the connector end. Which you might need if you’ve just cut your motor cable in half without making a note of the cable orientation…

Connector End Pin Assignments
Connector End Pin Assignments

If you’re interested in the internals, undo the small crosshead screw

Underside showing housing retention screw
Underside showing housing retention screw

then prise off the housing using a small flat-bladed screwdriver trying not to stab your fingers and thumbs in the process

Housing retention tabs
Housing retention tabs

Once that’s off you can pull off the gearbox (which itself comes apart very easily to reveal a set of three planetary gears):

Gearbox removal
Gearbox removal

Finally you can slide off the inner housing to reveal the motor itself and the small smoothing capacitor.

Internals
Internals

You can then see that the outer two cores (0V and 9V) are not connected to the motor internally. So, you control the motor by putting 9v on C1 and 0v on C2 to spin the motor anti-clockwise as seen from the outside, or alternatively put 0v on C1 and 9v on C2 to spin it clockwise as seen from the outside. To control the speed, apply a 0 to 9V PWM signal of the required duty cycle on the logic high control line. In terms of current draw, my M series motor pulls about 70mA when free running and up to about 500mA when I really load it hard. Bottom line – you need a controller circuit to run this, you can’t just hook it up to a micro-controller’s digital out lines.

Pre-assembled Test LEDs

Here’s a nice little idea I saw somewhere a while ago and have just got round to making. It’s just an LED in series with a 470Ω resistor connected to a pair of 0.1″ pitch posts. Whenever you need to quickly check a signal on a breadboard you can just plug one of these babies in and you’re done.20160220_065025

Baby’s First Scope

Much as I’d love to have a proper oscilloscope I’m wise enough to know that spending a couple of hundred quid on a cheapo version is probably a bad idea. This is a tool that warrants some significant investment. Or alternatively pretty much none.

I’ve just bought and built a little Jyetech DSO138 kit oscilloscope and whilst the specs are pretty pitiful, for £20 it’s a pretty good piece of kit.

Assembled Scope

The main features are as follows:

  • Analog bandwidth: 0 – 200KHz
  • Sampling rate: 1Msps max
  • Sensitivity: 10mV/Div – 5V/Div
  • Sensitivity error: < 5%
  • Vertical resolution: 12-bit
  • Timebase: 10us/Div – 500s/Div
  • Record length: 1024 points
  • Built-in 1KHz/3.3V test signal
  • Waveform frozen (HOLD) function available
  • Save/recall waveform

So, this thing is not going to cut it for high performance professional applications but if you’re learning electronics and playing with RC circuits and 555 timers then it’ll definitely get the job done for you.

Building the kit requires just basic soldering techniques but some of the parts are quite small, and there’s a lot of them, so it’s not a kit for a first time soldering experiment. It also comes in two flavours, one with the surface mount components already done and one where you need to solder them yourself. Surface mount soldering is a challenge so avoid this version if you’ve never done it before.

The Parts

While I could go into great detail about calibration and how well it responds and all that jazz, it frankly doesn’t matter. If you’re buying this kit, and you have any kind of common sense, you’re not looking for or expecting that level of sophistication. At the end of the day it lets you see reasonably robust, reasonably slow signals in reasonable situations. Job’s a good ‘un.

Why Should I Not Use Pointers?

So if pointers are so great, why not only use pointers? For two reasons, both of which are consequences of the fact that pointers are a method of indirection. Indirection is, at heart, adding a step to the set of steps needed to get at the information you need. This makes the process of getting that information more complicated.

With that complexity comes, firstly, increased risk – you have to manage memory yourself and this is fraught with peril and requires both experience and discipline. The object has to exist somewhere for a pointer to have something to point to, so you now have three things to manage – the pointer, the pointee and the relationship between them.

Secondly, the added complexity of indirection brings inefficiency. This can be inefficiency in terms of CPU cycles or in terms of memory usage. Pointers are often an unnecessary overhead e.g. for(i=0; i<10; i++) would be overly verbose if written using pointer notation. If you’re just dealing locally with simple built-in types that don’t take up much space then there’s often little to be gained by using pointers. It’s only when you start trying to pass things around, particularly large things, that the overhead of indirection becomes smaller than the cycles or space wasted by not using it.

Avoid Passing Large Chunks Of Data

Because of C’s pass by value semantics, passing data into functions using parameters requires pushing and popping that data onto and off the stack, byte by byte. Using return values to pass data out of a function back to the callee also requires copying the data onto the stack.

If you’re just passing or returning an int, then this is no big deal, but if you’re passing big data structures then all that copying can soon mount up.

The solution is to pass pointers into the function instead:

Using a pointer means passing only a few bytes rather than the whole structure. For a large array for example, instead of saying “here’s the contents of the array”, pointers allow you to say, “here’s where you can find the array already in memory”.

Why Does My Function Not Update My Variable?

So, as a result of some aberrant brain misfiring you’ve decided to start learning to code in C. You pretty quickly come across the idea of functions and your mind is blown.

Then you try to write a function and all is not well. Not well at all. In fact things are looking a bit peaky. You’re not getting the output you expect. Again. Gah. Why was it that you chose C again?

After a stupidly long time spent debugging you finally narrow down the problem to what is obviously nonsensical behaviour. C is clearly broken and you’ve just discovered a fatal flaw that has gone undetected in it for the past fifty years.

This classic and frequent problem encountered at some stage by pretty much all newbies (unless of course they cheated and read the manual) is pretty much universally heralded by “WTF is my function not updating my variable?”

C passes parameters by value – it makes local copy variables of parameters passed into functions. Passing in a pointer means you get a copy of the pointer but that copy is still pointing to the original memory. Pointers are a way to bypass C’s ‘pass by value’ mechanism. Sometimes I want changes I make to be reflected in the source of the data so I need to use reference semantics through pointers. Sometimes I want to manipulate data independently of the original data so I use copy or value semantics. The difference may appear subtle but it is important – a classic and frequent problem encountered by newbies is “Why does my function not update my variable?”

Pointers As Function Parameters

Suppose you’re writing a function to double a given number. You might naively assume that this would be a reasonable solution:

If you run it you’ll find number remains unchanged. This is, you might be surprised to discover, by design. It’s down to C’s pass by value semantics.

Instead, use referential semantics as follows to allow the doubleIt function to have access to the number variable.

If you run this you’ll find this function works as you would hope and does indeed double the number passed to it.