|Real World Instrumentation with Python|
Author: John M. Hughes
A real world book on instrumentation is something that should be valuable - does it work out right?
The subtitle of this book is "Automated Data Acquisition and Control Systems" and it promises to be a "real world" look at the subject.
Chapter 1 sets the scene with an overview of the sort of thing that "instrumentation" covers and of course this outline makes it clear that it is a mix of electronics and programming. Chapter 2 covers essential electronics and it reads like a basic physics book with an introduction to circuit diagrams, Ohm's law, parallel and series and so on. Unfortunately the introduction is very thin with inadequate explanations. How can such a short chapter hope to introduce all of electronics - it is doomed to failure. The book should have either assumed a level of electronics knowledge or introduced only enough to understand what follows and not attempted a potted guide to all of electronics.
Chapter 3 makes the same sort of mistake but with programming and attempts to introduce the whole of Python at an elementary level. Notice that it is Python 2.6 that is used, not the new 3.x version of the language. Then Chapter 4 repeats the same mistake for C. If you already program then you might follow what the languages are all about. Of the two chapters the one introducing C works better because it is a more primitive language and closer to the hardware.
But why are we covering C in a book that claims to use Python?
The answer is that Chapter 5 explains how to use C to write extensions for Python. The idea is that you write C to interface with the hardware and then use Python to write more complicated programs. This is very reasonable but there is also the attitude that if you have gone to the trouble of learning and writing C why not stick with it? There is also the problem that no real examples of using Python in this way are provided.
Chapter 6 is very odd given its position in the book. It is a list of tools and equipment that you might like, ranging from screwdrivers to oscilloscopes and logic analyzers. This is only likely to be of interest in a very insubstantial way as it doesn't recommend what you need, nor does it explain how to use any of the tools. For example, if you decide that you need a scope it is up to you to figure out how to set the trigger control to get a synchronized display. This chapter is more or less worthless unless you like vicarious drooling over tools you might buy.
Next we move on to a theoretical consideration of interfaces - RS-232, USB and GPIB. The coverage is very theoretical and would be of no help in actually using any of the interfaces. It mostly just a list of what is available and their general characteristics.
At last at Chapter 8 we reach "getting started" - but this is just an overview of software development practices. It covers requirements driven programming, testing, code reviews, unit testing and so on. Again not deeply enough to really get on with it but enough to fill a chapter.
From theoretical software engineering we move to theoretical hardware engineering with a chapter on control systems. This has some simple equations but I'm not sure why because if you want to study control theory you need lots of equations. This is a very simple account of feedback systems but not enough to give you the confidence to design something. There is some Python code for a PID controller and some equations, but why? Why go into detail about a PID controller when the reader hasn't gone into sufficient detail of a simple first order feedback loop.
Chapter 10 pushes the theory on into simulation and using simulators. This chapter discusses building your own simulator, using gnuplot, serial terminal simulators but it still isn't really practical or real world.
Chapter 11 is on instrument data I/O and this is another recap of interfaces and buses. It is basically a list of what is available or what you might encounter. Then it goes on to consider pySerial, pyParallel, pyUSB and on to consider some very general strategies for performing I/O and the format of ASCII files, binary files, image files - anything but real world instrumentation. Chapter 13 is about the last straw for me as it explains user interfaces - console displays, ANSI VDU displays and GUI displays.
The final chapter is called real world examples which is a bit of a cheek in a book with "real world" in the title. What we have as examples are interfacing a digital multimeter using a serial connection. The example go on to use the D1000 series data transmitter and the LabJack U3 USB interface. For a book on "real world" this is a pathetic collection of examples.
If you are expecting a book in the mould of the recent crop of Arduino practical "real world" texts that have hit the market - think again. They mostly go at a speed and pace that this book simply can't imagine let alone aspire to. This is more like a classical approach to factory instrumentation where everything is bought "off the shelf" and software is just a set of modules. However it doesn't even do this job particularly well as it doesn't cover the standard factory instrumentation and control gear. It is as if it has all been simplified and reduced to a minimum cost, open source, DIY approach. But of course, this isn't how any modern DIY open source hardware/software person would do it today because they would simply get an Arduino or something similar and code in Processing or something similar.
This book does contain some useful pages but not that many. It fails to teach electronics or software except in the most hands-off and distant sort of way. If you want a theoretical account of the sorts of things you need to know to be involved in instrumentation then this might be a good choice, but if you want a real world approach you need to look elsewhere if for your "real world" is the DIY/hacker world or the more up-market factory/research instrumentation world.
|Last Updated ( Wednesday, 01 June 2011 )|