There are a few issues with using the SQM-LU in this way.

The sampling time of the SQM-LU can be between 1 to 10 seconds depending on the darkness of the sky. Used on a mobile platform on a typical road (60 km/h speed limit) a single reading may take up to 170 meters. This poses 2 problems. Firstly where do we define the reading to have been taken from, the center of the range of GPS coordinates sampled over this time would seem to be the best option here. Secondly, we have the possibility of sky brightness varying over this distance due to terrestrial effects; by that I mean oncoming headlights, houses, trees etc., which would skew the result towards a brighter value.

When climbing or descending the meter will not be pointed directly at the zenith. Provided the gradient was constant that would not be a problem, but that’s unlikely to be the case in reality, so the entire sample will not be pointed at the same point of sky. Roads tend to not be that steep in wicklow so the variance should not be much, but it would be there given the possible sample time.

The guide for the previous units whereby the initial result is best discarded should not apply to the SQM-LU. Given the constraints above it would be possible to take single readings every 200m or so. Stopping in lay bys etc. at best tends to give a resolution of 1km, the benefit being that you can pick good locations to sample.

Best practice for using the SQM is to take a set of readings and average them. Taking say, 4 readings, in the mobile set up could take approximately 700m. Interference from cars, trees etc. may pollute some results but these could be determined and disregarded. Determining the location is a bigger problem, as we would need to find the center of the used sample range, which will give us a point with a radius of 350m.

Thinking about these issues it seems that just stopping every kilometer or so and taking proper readings makes more sense, and does not involve spending €200 on a new device that while it seems like a good way to map large areas may not deliver adequate results in practice.

ffmpeg -i INPUT -acodec aac -ac 2 -ab 160k  -vcodec libx264 -vpre iPod640 -f mp4 -strict experimental -threads 0 OUTPUT

For other recipies, well, starting points anyway, see https://develop.participatoryculture.org/index.php/ConversionMatrix

The circuit between both approaches is roughly the same, I followed the circuit in the former. The modification allows the camera to be switched to a long exposure mode via a switch. The switch can be triggered over a serial port, so I added a USB to serial adaptor and a USB hub (both from ebay) to the unit to allow control from a computer and have just one cable coming from the unit.

As soon as you have some new astronomy kit to try out it inevitably becomes overcast, so no test images just yet however I’ve included some images of the construction.

The first batch contains titles like Personal Computer News and Your Computer from around 1981-1983. The second batch are mainly Amiga Shopper (and the odd CU Amiga and Amiga Format) from around 1994.

UPDATE: All gone!

Drop me an email if you are interested in them.

This was taken by attaching my Canon 400D to the scope. 1s exposure. Green channel extracted, a few tweaks, then coloured orange. The diagonal lines are from Nebulosity, which is image aquisition software that I’m trying out. The free to try version puts diagonal lines in the images.

It needs better focusing, and the red channel with the flares needs to be merged in, but I’m happy with it given its the first image of the Sun I’ve tried with this setup since 2006.

The solution seemed simple. Order a replacement seal. Fitting it however was a problem.

Indesit decided to make this model un-servicable. It’s not possible to get enough access to the drum to fit the seal without, well removing the drum. So what should be a 30 minute job took 4 hours. The case is welded together, and apparently the drum was lowered in in the factory.

Now I’m sure this makes sense for indesits sales and operations management. I assume it simplifies manufacturing, and makes it cheaper, by easily allowing the factory to assemble different machines on the same line by just changing the pre-made cases and drums. What it also does it creates a unit that for most people is un-serviceable, leading most likely to the machine being trashed and a new one being bought. Not great for the environment, not great for the consumer, but good for indesit.

So when this machine finally does pack it in an need replacing. I’ll be replacing it one that I can do basic maintenance on. Probably not an indesit if our current machine is typical of them.

• http://home.zonnet.nl/m.m.j.meijer/D_I_Y/spc900nc.htm
• http://www.yesyes.info/index.php/diy/philips-spc900-webcam-lx-and-ampoff-mod/
• http://stargazerslounge.com/astro-lounge/114129-pictures-taken-during-some-lx-mono-mods.html
• http://www.boltonastro.org.uk/Members%5FArea/Projects/spc880conversion.pdf

Now just to read through them all, order the bits I need, and do the mod. Simples.

Thankfully python allows to to add a method to a class on the fly:

>>> class test:
...     pass
...
>>> def foo(self):
...     print "hello, world"
...
>>> dir(test)
['__doc__', '__module__']
>>> test.foo=foo
>>> dir(test)
['__doc__', '__module__', 'foo']
>>> bar=test()
>>> bar.foo()
hello, world
>>>

Here we initially create an empty class ‘test’ and a function ‘foo’. Then add the function ‘foo’ to the class ‘test’, so that when we create a ‘test’ object, we can call the ‘foo’ method in it.

We use the same trick to add a unittest test to a unittest class:

>>> import unittest
>>> class mytest(unittest.TestCase):
...     pass
...
>>> def test_testcase(self):
...     self.assertEqual("hello","hello")
...
>>> suite = unittest.TestLoader().loadTestsFromTestCase(mytest)
>>> unittest.TextTestRunner(verbosity=2).run(suite)

----------------------------------------------------------------------
Ran 0 tests in 0.015s

OK
<unittest.runner.TextTestResult run=0 errors=0 failures=0>
>>> mytest.test_testcase=test_testcase
>>> unittest.TextTestRunner(verbosity=2).run(suite)

----------------------------------------------------------------------
Ran 0 tests in 0.000s

OK
<unittest.runner.TextTestResult run=0 errors=0 failures=0>
>>> suite = unittest.TestLoader().loadTestsFromTestCase(mytest)
>>> unittest.TextTestRunner(verbosity=2).run(suite)
test_testcase (__main__.mytest) ... ok

----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
<unittest.runner.TextTestResult run=1 errors=0 failures=0>
>>>

>>> list=['a cat','a dog','a yacht']
>>> string='a cat'
>>> if string in list:
...     print 'found a cat!'
...
found a cat!
>>>

But what if you need to search for just ‘cat’ or some other regular expression and return a list of the list items that match, or a list of selected parts of list items that match.
Then you need list comprehension.

>>> import re
>>> list=['a cat','a dog','a yacht','cats']
>>> regex=re.compile(".*(cat).*")
>>> [m.group(0) for l in list for m in [regex.search(l)] if m]
['a cat', 'cats']
>>> [m.group(1) for l in list for m in [regex.search(l)] if m]
['cat', 'cat']
>>>

Lets work through that. Firstly we’re going to use the regular expression library so we import that. re.compile lets us create a regular expression that we can later use for search and matching.

Now lets look at a simpler comprehension line:

>>> [m for l in list for m in [regex.search(l)]]
[<_sre.SRE_Match object at 0x10cfbb0a8>, None, None, <_sre.SRE_Match object at 0x10cfbb6c0>]

This is creating a list of the results of running regex.search() on each item in l.

Next we want to exclude the None values. So we use an if statement to only include the not None values:

>>> [m for l in list for m in [regex.search(l)] if m ]
[<_sre.SRE_Match object at 0x10cfbb6c0>, <_sre.SRE_Match object at 0x10cfd0be8>]
>>>

Lastly rather than returning just a list of the m’s, which are RE match objects, we get the information we want from them.

>>> [m.group(0) for l in list for m in [regex.search(l)] if m]
['a cat', 'cats']
>>> [m.group(1) for l in list for m in [regex.search(l)] if m]
['cat', 'cat']
>>>

Very useful if you have say a list of Solaris 11 package fmri’s and want to extract a set of package names based on a regular expression of their version number for instance

That’s a lot easier said than done in OSX Lion. For a start there does not appear to be a set of keyboard layouts to choose from.

Enter Ukelele. This tool lets you create custom keyboard layouts. All I actually needed to do was take the Logitech UK International keyboard and remap the | key as everything else was as I needed.

Now I can finally use my old Microsoft Wireless Keyboard 6000 with my Mac.