Journey's End

Thoughts on entropy, compression and predictors

2025-05-24T13:35:00+10:00

I will prefix this post by saying that none of the ideas here are new and its all well covered ground by now. Like much of this blog, I am mostly writing to clarify ideas and to serve as a reference for the future-me.

Entropy and Prediction

Entropy as considered in information theory, can be thought of as the number of possible values the each symbol can take on. A stream of perfectly random bits has maximal entropy because each symbol is equally likely to be a 1 or 0. If however we impose rules on such a binary stream, e.g. after 3x1s there must be a 0, then after a run of 3x1s, the next symbol must be a 0, and so the entropy of such a stream is reduced. This change in entropy can be considered information.

Viewed through this lens, entropy and our ability to predict the next symbol, based on what has come before, are related concepts. If we can perfectly predict the next symbol every time, then the entropy of the a data stream is the entropy of the predictor, i.e. how many bits do we need to make the predictions.

Compression and Predictors

To compress a data stream is to reduce the number of bits required to represent towards the limit dictated by the entropy of the data stream. This can be done by looking for repeated symbols and using more efficient encoding for those symbols as is typically done with Huffman codes. A further refinement of this technique is to use a predictor to predict the next symbol and encode the difference between the actual symbol that occurs and the predicted symbol.

To see why this is an improvement, consider a perfect predictor - the only symbol we would need to encode is 0 which makes for very high compression ratios. In practice this rarely happens, but predictors do generally reduce the number of possible symbols. Consider the sequence [10, 9, 8, 5, 3, 1]. This has 6 unique symbols we need to compress. However if we use a simple predictor that says "the next symbol is the same as the current symbol", then the difference is [10, -1, -1, -3, -2, -2], where we assume the first prediction is 0. This sequence of difference from prediction only uses 4 symbols and is easier to compress.

The use of predictors allows us to exploit correlation between symbols to achieve better compressions than simply using more efficient coding. Predictors can be continuously applied with a different predictor each time, to potentially exploit high levels of correlation. The use of predictors can be said to "decorrelate" the data because the ability to predict the next symbol in difference-from-prediction data stream is less than before. e.g. if we were apply the same predictor as before to [10, -1, -1, -3, -2, -2] we get [10, -11, 0, -2, 1, 0], and now we have 5 symbols instead of the 4 we started with, i.e. use of the predictor was detrimental. Where as the original data had elements that correlated to each other by difference of 1 or 2, the difference-from-prediction does not have this property. This also illustrates that the choice of predictor matters as a bad predictor can make things worse by trying to force correlations where non-exists.

Predictors can be specified ahead of time, or "trained" on the data and transmitted along with the compressed data so the receiver can decompress it.

Adventures in Compressed DNG

2025-05-24T01:41:00+10:00

I have been working with industrial cameras and frame-grabbers that simply gives me a dump of their sensor data. To make that data useful it needs to undergo demosaicing, ideally using one of the modern demosaic algorithms like RCD rather than simple interpolation or the rather outdated VNG. Unfortunately the latter are all that OpenCV supports.

To gain access to more advanced demosaic algorithms and sophisticated image processing functions like colour calibration, micro-contrast, dehaze, etc, I encoded the raw colour filter array (CFA) data into DNG using the PiDNG library. With compression disabled this library produces DNGs which is accepted by darktable. However if I enable compression darktable is unable to open it.

Running darktable from the command line, the following error is observed:

    71.5724 [rawspeed] (compression-test.dng) void rawspeed::AbstractDngDecompressor::decompress() const,   
       line 250: Too many errors encountered. Giving up. First Error: virtual Buffer::size_type   
       rawspeed::LJpegDecoder::decodeScan(), line 108: Unsupported predictor mode: 6

This suggests that the predictor used is not supported. By editing the source code of PiDNG, predictor was set to 1 which results in yet another error:

    10.7300 [rawspeed] (compression-test.dng) void rawspeed::AbstractDngDecompressor::decompress() const,   
       line 250: Too many errors encountered. Giving up. First Error: virtual Buffer::size_type   
       rawspeed::LJpegDecoder::decodeScan(), line 141: Maximal output tile size is not a multiple of LJpeg frame size

This error happens because PiDNG uses an optimisation trick to improve the compression ratio. Consider a typical CFA pattern:

RG
GB

The raw sensor data is essentially the above repeated horizontally and vertically:

RGRGRG
GBGBGB
RGRGRG
GBGBGB
RGRGRG
GBGBGB

Lossless JPEG compressed by using a predictor that uses previous pixel values, including those in the previous row. Such a predictor work better if correlated values are closer together. So instead of saving the image as-is, the DNG specification (as of 1.4.0) allows the image data to be stored as an image that is twice as wide but halve as high (preserving the total number of pixels):

RGRGRGGBGBGB 
RGRGRGGBGBGB
RGRGRGGBGBGB

In this new image, correlated pixels are closer together. e.g. the first red pixel had no immediate neighbours that was also red, but now it has an immediate neighbour in the next row. The rawspeed library however doesn't support this optimisation trick (or predictors other than 1), which to be fair is also useless with predictor 1, which only looks at the previous value on the same row. This trick is most useful with predictors that look at values from previous rows, e.g. mode 6 which is the default mode used by PiDNG.

With another modification to the PiDNG library that encodes the sensor data as a JPEG image of the original size, we were able to produce a losslessly compressed DNG file that darktable opens. The compression ratio isn't as good - 80% vs 75%. Hopefully darktable will gain support for predictors 2-7 and we can get better compression. In the meantime I cleaned up the changes to PiDNG and have submitted a PR which will hopefully be accepted.

Rant

DNG v1.4.0 was released in 2012, a time when DEFLATE compression in TIFF files was widely used yet for some reason the DNG specification restricts its use to floating point image data with estoic lossless JPEG, defined 20 years ago in 1992, being the only other lossless compression option. It is not until 2023, with DNG v1.7.0, that JPEG-XL is added for integer image data. Unfortunately JPEG-XL is exotic enough that darktable still doesn't support it in 2025. Why we couldn't have allowed Deflate for integer image data is beyond me. So much space could have been be saved.

Python One-liner for Local QR Code Decoding

2025-04-10T03:07:00+10:00

Because KeepassXC lacks the ability to decode QR code for TOTP setup and not all MFA implementations show the required secret in text format, I use the following snipet to read the QR code information locally:

  python -c 'from cv2 import QRCodeDetector; from PIL.ImageGrab import grabclipboard; import numpy as np; print(QRCodeDetector().detectAndDecode(np.array(grabclipboard()))[0])'

While there are many websites which can do the same, the TOTP secret is sensitive information that shouldn't be transmitted willy nilly to random websites.

You will need the following libraries installed: python-opencv>4, numpy, pillow. If you use uv then it is possible to have this as a nice script:

#!/usr/bin/env -S uv run --quiet --script
# /// script
# requires-python = ">=3.11"
# dependencies = [
#     "numpy",
#     "pillow",
#     "opencv-python>3",
# ]
# ///

from cv2 import QRCodeDetector
from PIL.ImageGrab import grabclipboard
import numpy as np

def main() -> None:
    im = grabclipboard()
    if im is None:
        print('Clipboard does not contain an image')
        return


    data, _, _ = QRCodeDetector().detectAndDecode(np.array(im))
    if data == '':
        # QR codes cannot encode the empty string (apparently)
        print('No QR code detected')
        return

    print(data)


if __name__ == "__main__":
    main()

Put this in your path somewhere and you can execute it like any other script and uv will handle installing depedencies etc.

PIO and Interrupts

2024-08-11T03:53:00+10:00

Introduction

I want to be able to raise system level interrupts from PIO programs and there aren’t too many examples of this, so here is my simple contribution.

PIO program

First, the PIO program, which simply waits for a pin to change and then immediately raises PIO IRQ 0.

.program irq_example
.wrap_target

wait 0 pin 0    ; wait for a 0 on IN pin 0
irq nowait 0    ; raise PIO IRQ 0

.wrap

Compile this with pioasm then #include the .h in your C program.

C Program

Interrupt Setup

There are four system level interrupts related to PIO: PIO0_IRQ_0, PIO0_IRQ_1, PIO1_IRQ_0, PIO1_IRQ_1. We shall use PIO0_IRQ_0.

First we attach an interrupt handler to PIO0_IRQ_0:

void isr(void) {
    // clear PIO IRQ 0 that was raised by irq nowait 0
    pio_interrupt_clear(pio0, 0);
}

irq_add_shared_handler(PIO0_IRQ_0,
                       isr,
                       PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);

It is important that pio_interrupt_clear() is called otherwise the CPU will lock up constantly executing the interrupt handler (aka ISR - interrupt service routine)

We then enable the interrupt:

irq_set_enabled(PIO0_IRQ_0, true);

Finally we configure PIO0_IRQ_0 to be triggered when PIO IRQ 0 is raised:

pio_set_irq0_source_enabled(pio0, pis_interrupt0, true);

The functions used above are described in the Pico C SDK documentation.

PIO Setup

The PIO program can now by installed the usual way by first setting up the state machine:

uint sm = pio_claim_unused_sm(pio0, true);
uint offset = pio_add_program(pio0, &irq_example_program);
pio_sm_config cfg = irq_example_program_get_default_config(offset);

Configure and connect GPIO to the state machine:

// connect GP 2 to IN of state machine
sm_config_set_in_pins(&cfg, 2);

// it is an input pin
pio_sm_set_consecutive_pindirs(pio0, sm, 2, 1, false);

// we want pull up on the pin
gpio_pull_up(2);

Now we are ready to start the state machine:

pio_sm_init(pio0, sm, offset, &cfg);
pio_sm_set_enabled(pio0, sm, true);

PIO ASM and PlatformIO

2024-08-11T03:25:00+10:00

Introduction

PIO

The RP2040 has two programmable IO (PIO) blocks, each capable of executing 4 programs in parallel. This allows the RP2040 great flexibility in mix and matching different protocols. Want 3x CANBUS and 1xSPI? RP2040 got you. Want 5xI2C instead? That’s cool too. It is a very flexible approach vs having hardwired peripherals and since PIO execute independently of the CPU, nicer and faster than using the CPU to do bitbang.

PIOs are essentially hyperspecialised CPUs and they have their own assembly language which is parsed by a program called pioasm, part of the pico-sdk. pioasm converts PIO programs in assembly into C-headers which can then be #included and used. Typically you have your PIO programs in a .pioasm file which is then transpiled into a .h file by pioasm.

PlatformIO

PlatformIO is a very nice platform for doing embedded development. It nicely packages up all the toolchains and dependencies for you and sets everything up all neat and tidy.

PlatformIO and `pioasm`

While PlatformIO knows how to compile C code, it doesn’t natively support pioasm, which means you need to remember to manually invoke pioasm before building with PlatformIO, or configure PlatformIO to run a pre-build step that runs pioasm against all .pioasm.

Alternatively, one can use make which I have opted to do since it feels natural - after all make is designed for this kind of work.

With the following Makefile, all .pioasm files are compiled into their .h counter-part prior to building the program. The Makefile wraps common PlatformIO tasks to provide additional convenience.

PIOASM=/path/to/pioasm

%.h: src/%.pioasm
        $(PIOASM) $< src/$@

build: pio_trigger.h
        pio run

upload: build
        pio run -t upload

This script assumes your source code is in /src and you have a copy of pioasm.

Building `pioasm`

Because I use the community developed arduino-pico core, a copy of pico-sdk was already available in $HOME/.platformio/packages/framework-arduinopico/pico-sdk/, including the pioasm source code. pioasm can then be built as follows (assuming you are on a unix-like):

cd $HOME/.platformio/packages/framework-arduinopico/pico-sdk/tools/pioasm/
mkdir build
cd build
cmake ..
make

This will produce the pioasm binary in the build/ directory. You can leave it there or move it.

Estimating a Supernova's Brightness as an Amateur

2024-01-23T12:11:00+11:00

Introduction

2023rve is the designation given to a Type II supernova discovered on 2023-09-08 by Mohammad Odeh from UAE. It appears to be part of NGC 1097, a galaxy 45 million light years away. Due to it’s brightness, 2023rve was visible to budget amateur astronomers/astrophotographers like myself.

Below is my first image of 2023rve.

This is a stacked image consisting of 64x60s exposures captured using an unmodified Canon 800D attached to an Evostar 72ED. I was and continue to be very excited about this image because supernovas occur but rarely and are generally out of reach for budget setups like mine. Catching glimpse of one is not unlike seeing an unicorn.

Light Curves

2023rve is a type II supernova, and its light curve will look like one of the following depending on its subclassification (II-P, II-L, IIn or IIb).

It occurred to me then that with sufficient images I can have a go at generating such a light curve and figure out what kind of supernova 2023rve is! This is a particular exciting idea to me because it takes supernovas from the realm of theory (knowing about them) into reality (studying them).

In the time since then, I managed 4 captures in total, including the one above, and this post documents my efforts in estimating the magnitude of 2023rve from my data and using that to construct a light curve.

General Approach

The idea is to calibrate my data, which are 60 second exposures of 2023rve, against stars of known visual magnitude. By comparing the pixel values that make up 2023rve vs these calibration stars, I can estimate its apparent visual magnitude. Then, making the assumption 2023rve is part of NGC1097, we can use the distance to NGC1097 to calculate the absolute magnitude of 2023rve and generate a light curve.

Identifying Stars

The first step is to find stars and their known magnitudes. While bright stars such as Rigel or Sirius have well known magnitudes, the stars in the vicinity of NGC1097 are less well known and unnamed. In order to look up stars in astronomical databases, we need their right-ascension (RA) and declination (DEC) coordinates. These coordinates serve the same purpose as GPS coordinates of latitude and longitude: they unique identify a position in the sky.

To locate our stars, I loaded my images into Siril and carried out platesolving, a method of locating images within the sky by looking at the pattern of the stars within the image.

Once platesolving is completed, I saved the file as a FITS file which embeds the coordinate information into the file metadata. I then open the FITS file in AstroImageJ and by manually adjusting the upper and lower limits on the histogram in the image viewer and zooming in, I am able to get a good view of NGC1097.

By right clicking on the image, a link to SIMBAD will open which allows all known stellar objects in the vicinity to be queried. Using this, three objects with known visual magnitudes were identified and annotated.

These are our reference stars and their visual magnitude is tabulated below.

Object	Vmag
CD-30 1031	10.3
TYC 7011-484-1	11.39
TYC 7011-1028-1	12.15

Measuring Brightness

In order to relate the brightness of these stars to the measure pixel values, I used AstroImageJ’s single-aperture photometry tool, which samples a central circular region and an annulus around it. The central circular region should just fit the star while the annulus should contain only background. The background pixel value is estimated from the pixels within the annulus and subtracted from the stellar pixel values. This value is reported as Int Cnts. This measurement was done on each of the reference stars and 2023rve, e.g.

Deriving Visual Magnitude

Tabulating the Int Cnts obtained across the 4 observations produces the following:

	CD-30 1031	TYC 7011-484-1	TYC 7011-1028-1	2023rve
2023-09-18	1.09E+06	4.54E+05	2.43E+05	2.77E+04
2023-09-24	1.09E+06	4.67E+05	2.60E+05	2.49E+04
2023-11-18	9.65E+05	4.32E+05	2.64E+05	1.20E+04
2024-01-22	1.14E+06	5.47E+05	2.73E+05	1.06E+03

It is quite pleasing that the Int Cnts values for the three reference stars are relatively stable, particularly as I am not using an uncooled sensor nor did I control for atmospheric conditions. Of the three reference stars, TYC 7011-1028-1 had the fewest saturating pixels and was the most stable over time, and was chosen as the reference against which to measure 2023rve’s brightness:

	TYC 7011-1028-1	2023rve	(2023rve) / (TYC 7011-1028-1)
2023-09-18	2.43E+05	2.77E+04	0.114
2023-09-24	2.60E+05	2.49E+04	0.096
2023-11-18	2.64E+05	1.20E+04	0.045
2024-01-22	2.73E+05	1.06E+03	0.004

By expressing 2023rve’s brightness in terms of TYC 7011-1028-1 I am implicit assuming the my sensor’s response is approximately linear for the brightness being measured.

Magnitudes are logarithms of ratios, so the brightness ratio in the table above turns into a difference in magnitude given by mag_diff=-2.5log10(x)) where x are the values in the final column. By adding this value from the visual magnitude of TYC 7011-1028-1 we arrive at an estimated visual magnitude for 2023rve:

	(2023rve) / (TYC 7011-1028-1)	mag_diff	Vmag
2023-09-18	0.114	2.355	14.505
2023-09-24	0.096	2.545	14.695
2023-11-18	0.045	3.355	15.505
2024-01-22	0.004	6.030	18.180

Verification

The estimated visual magnitude of 2023rve looks quite reasonable, but is it correct? Thankfully professional astronomers have made their own measurements which I have collected below:

Date	Vmag
2023-09-06	14.5
2023-09-11	13.9
2023-09-16	14.43
2023-09-24	14.390
2023-11-15	15.500
2024-01-06	16

Sources:

Compared against these, my visual magnitudes estimates compare quite favourably! I am pleasantly surprised how well things worked out. My last measurement, on 2024-01-22, stands out by how much it differs. It is also the measurement I have the least confidence in as by that point I could no longer reliably identify 2023rve in a single 60s exposure. I have some ideas here: take longer exposures or stack my exposures carefully (keeping values linear) and estimate from the stacked image.

Absolute Magnitude

The conversion to absolute magnitude is quite straight-forward as is the subsequent plotting.

Note that because I don’t know when peak brightness occurred, I am using days-since-discovery instead.

Type II Classification

I don’t think there is enough data yet to definitively say what subtype 2023rve is. More data points will decide the matter and I look forward to the next set of clear skies so I can continue this effort.

On NS*DateFormatters

2023-12-23T01:16:00+11:00

There now exists NSDateFormatter and NSISO8601DateFormatter and their behaviour when a timezone is not set is not the same: NSDateFormatter produces strings formatted for local time while NSISO8601DateFormatter produces string formatted for UTC.

As an example, given a date-time of 2000-12-31T23:00:00Z

NSDateFormatter with no timezone set and full styles:
Monday, January 1, 2001 at 10:00:00 AM Australian Eastern Daylight Time

NSISO8601DateFormatter with no timezone set:
2000-12-31T23:00:00Z

Note that NSDateFormatter "applies" my local timezone automatically whereas NSISO8601DateFormatter doesn't. Sidebar: it seems that while NSDate carries no timezone information, it is always interpreted as UTC time.

DIY EQMod Direct USB Cable

2023-10-27T04:34:00+11:00

I am in the process of resurrecting my Eq5 Pro so it is compatible with ASIAir Mini. The first step is to build an EQMod Direct USB cable. While it is possible to buy one pre-made, since I had all the parts I decided to build it myself.

Based on the reference document I need to make an single-ended RJ45 cable. I followed T-568A colour scheme:

Based on this colour scheme, the connection to a USB-UART adapter is as follows:

RJ45	Colour	USB-UART
4	Blue	Ground
5	Blue-White	RXI
6	Orange	TXO

Plug the RJ45 end of the cable into the hand-controller port on the control box and the other end into the ASIAir Mini. Then power up the ASIAir Mini as usual and use one of the 12V outputs to power the SynScan. Make sure to switch on the SynScan as it has its own power switch. After this select EQMod for the mount model and leave the baudrate at the default value of 9600. Tap the enable-toggle-switch and the ASIAir Mini will attempt to connect to the mount. After a successful connection you should be able to manually slew the mount in RA and DEC in Preview mode.

Update: I have to power up the SynScan after the ASIAir has fully booted (made it's beeping noises) in order for them to communicate successfully. If both are powered up at the same time, something goes awry and the ASIAir Mini will not be able to connect.

Build Log: SCD41 CO2 Sensor

2023-09-17T14:21:00+10:00

CO2 concentration is a proxy for how well a space, especially an enclosed one, is ventillated. To this end I build a quick-n-dirty CO2 sensor using a SCD41 breakout board from pimoroni and bits and pieces I had in the workshop.

Took the opportunity to practice making enclosures, especially for an irregularly shaped circuit. The enclosure was designed in FreeCAD by taking a picture of the circuit then importing it as a reference image. After correct for scale the designed enclosure was reasonable accurate, needing only some small tweaks to dimensions to correct forperspective distortion. The result was then 3D printed on my FF Creator Pro.

The enclosure provides openings for a button (currently unused), a "cage" for the CO2 sensor, display and micro-USB port.

In addition to practicing painting techniques, I also wanted to try new ways of "labelling" my projects. Water-slide decals are widely used in model kits, and it turns out you can buy blank sheets with which to make your own decals with! I picked a cheap'ish option off Amazon. Just search for "water slide decal clear laser". Once they arrived it was a simple matter of designing the decals in inkscape, printing it out and cutting them to size. To complete the build, a plastic primer was applied, followed by colour coats, then a clear coat was applied, followed by the decal, followed by 2 more layers of clear coat.

Overall quite happy with the outcome! Could have done more sanding before applying paint to hide the layer lines better and the a matte coat I think would have worked better. Nonetheless the decal idea worked out well and I think it will be my goto - a big improvement over permanent markers.

Notes on DietPi

2023-07-28T07:53:00+10:00

Recently decided to resurrect a RPI Model B (

Unexpected Latency in Tinyproxy

2023-03-28T20:58:00+11:00

I love tinyproxy, it is simple to setup and more than enough for my needs. Recently however I noticed that some clients were experiencing unexpected long delays when doing something as simple as curl google.com. After some sleuthing, I tracked it down to the fact I had

LogLevel Info

in my config. When this is set tinyproxy produces log entries such as

CONNECT   Mar 28 08:46:41 [7023]: Connect (file descriptor 7): [unknown] [123.123.123.123]

the [unknown] is due to tinyproxy attempting and failing to resolve the connecting IP into a hostname. It is this attempt to map IP to hostname that is causing the latencies observed. To resolve this I added offending IP to /etc/hosts

123.123.123.123 some-host-name

with the above entry the latency went away and the log entries now look like

CONNECT   Mar 28 20:39:49 [6879]: Connect (file descriptor 7): some-host-name [123.123.123.123]

Conda and Slow Proxies

2023-03-28T19:39:00+11:00

The default conda connect timeout is 9.15 seconds (no idea why this is, seems to have been the case from day one). If the proxy is slow, e.g. it is in another country or AWS region, this timeout can be triggered and conda will prematurely close the connection.

To diagnose this issue, attempt

curl https://repo.anaconda.com/pkgs/main/linux-64/current_repodata.json

with proxies enabled. If that works then increase the connect timeout as follows

conda config --set remote_connect_timeout_secs 30

conda should now be able to update and install new packages etc.

Installing python package arcgis in conda on Apple Silicon

2023-02-04T03:37:00+11:00

In order to install the arcgis package in conda, you have to specify the architecture osx-64 otherwise the package will not be found. This works because MacOS will capable of running x86_64 code on Apple Silicon processors - that is how efficient they are!

conda install -c esri/osx-64 arcgis

In fact to make everything else work you need to add the channels with architecture specified exactly, e.g. conda-forge/osx-64, esri/osx-64 and defaults/osx-64. Otherwise packages will be installed with a mix of architectures and appears not to be able to find each other.

Verifying Local iOS Backups

2023-01-10T14:40:00+11:00

Backups are a great idea, and encrypted backups are a even better idea. When backing up iOS devices on macOS, it is possible to set an encryption key to protect local files. There is however no straightforward GUI method to verify the encryption key.

Enter mvt:

conda create -n mvt python=3.10
conda activate mvt
pip install mvt
mvt-ios extract-key /path/to/backup

With the right password you will see

INFO     [mvt.ios.decrypt] Derived decryption key for backup at path /path/to/backup is:
                  "12345678901234567890"

Otherwise

CRITICAL [mvt.ios.decrypt] Failed to decrypt backup. Did you provide the correct password? Did you
                  point to the right backup path?

Build Log: ATTiny13 LED Dimmer

2022-12-26T02:27:00+11:00

Introduction

Bought some cheap USB driven warm-white LEDs off eBay for lighting display cabinets. Turns out it is just normal LED strips with a simple driver in the USB plug. Wanting to unify control of multiple LED strips into a single point I build a simple PWM based LED driver. It is neither constant current nor constant voltage - for the simple LEDs I have it is Good Enough (tm).

Build Details

Finished product first, this is the controller mounted on the back of the bookcase where the LED strips are mounted. 5V from a wall plug PSU enters on the left and the LEDs strips are wired in parallel on the right. The single button cycles between on and 3 levels of brightness, with max brightness consuming around 800mA.

With the lid off, the interior layout can be examined. Essentially a single strip board containing all components and socket hardware.

The strip board is very basic: decouple and smoothing capacitor on the top-right; ATTiny13 in the middle in a socket so it can be reprogrammed; BD135 NPN transistor lower middle with base resistor to turn the LEDs on and off; and some resistors detect button press. Could have used the internal pull-up resistors but the construction demanded that the button be wires on the high side.

This project was an opportunity to try a new way of encapsulating projects, namely by using PCB spacer to raise the strip board to top of the enclosure and then constructing a lid to match the button's position. This worked quite well, especially here where the NPN transistor needed some room to dissipate heat. The spacer can be seen in the following photo. Note the vents built into it which line up with the case vents.

The initial case design had the vents (seen below) built in to reduce printing time, turns out they are also very useful for passive cooling of the NPN transistor.

In addition to the vents in the case, vents were also added to the lid to aid cooling after observing that the case as a whole was warm to touch. The goal is for the whole system to operate without fail for the ~8hr period it is designed to operate for before turning itself off due to idle timeout.

Code and CAD

The ATTiny13 was programmed using AVR ISPmkII, PlatformIO and MicroCore. FreeCAD was used to design the enclosure, using the spreadsheet workflow to parameterise dimensions such as case thickness, inteference-fit-tolerance, etc.

To Improve

1. Clean up the vents in the case, possibly increase their size and the thickness of the case in that area so it is less flimsy. 2. Engrave into the case the LED and 5V labels. 3. Screw terminals would have been easier to wire up.

Exif Tag Types

2022-12-20T04:37:00+11:00

Went on a journey trying to figure out what valid exif tag types are, in both JPEG and TIFF files. In summary:

TYPE #	Name	Exif 2.32	Tiff 6.0	Adobe TN[1]
1	BYTE	X	X
2	ASCII	X	X
3	SHORT	X	X
4	LONG	X	X
5	RATIONAL	X	X
6	SBYTE		X
7	UNDEFINED	X	X
8	SSHORT		X
9	SLONG	X	X
10	SRATIONAL	X	X
11	FLOAT		X
12	DOUBLE		X
13	IFD			X

The last 3 columns indicate where the tag type is specified. e.g. Type #9-SLONG, is documented in both Exif 2.32 and Tiff 6.0, whereas type #11-FLOAT is only defined in Tiff 6.0.

[1] Adobe TN refers to "Adobe PageMaker® 6.0 TIFF Technical Notes".

FSCK'ing Veracrypt Volumes on macOS

2022-12-20T04:33:00+11:00

Due to unexpected power loss or disconnection of the underlying storage, the filesystem inside Veracrypt volumes is desired to prevent future data loss.

On macOS I tried using

diskutil verifyDisk /dev/diskXXX

This didn't work for some reason, most likely because of some interaction with veracrypt. Same results via Disk Utility application.

The Veracrypt GUI however offers a "check filesystem" option if you right click on a mounted volume. Unfortunately, as of version 1.25.9, it doesn't work out-of-the-box on macOS: it fails to find

/Applications/Utilities/Disk Utility.app

The cause is that from at least macOS 12, Disk Utility is located at

/System/Applications/Utilities/Disk\ Utility.app

There is a quick and dirty workaround

  cd /Applications/Utilities
  sudo ln -s /System/Applications/Utilities/Disk\ Utility.app ./

With the above symlink in place it is possible to perform filesystem verification and repair via the context menu items offered in the Veracrypt GUI.

TigerVNC and Systemd

2022-07-30T01:51:00+10:00

A quick systemd service definition file for tigervnc on Ubuntu 20.04

[Unit]
Description=tigervnc

[Service]
Type=forking
ExecStart=/usr/bin/vncserver -localhost no -depth 24 -geometry 1920x1080 -noreset
User=steve

[Install]
WantedBy=multi-user.target

Key components:

Type=forking so systemd correctly identifies the real VNC process, not the perl script that runs and then exits
-localhost no so connections from other computers are accepted. This is only needed if you are not using ssh tunneling.
User=steve so tigervnc doesn't complain about HOME not defined in the environment and uses my settings for auth and X session. Note that this is a strictly single-user setup.

Using SubShapeBinders and Assembly4

2022-07-21T16:09:00+10:00

Assembly4 and SubShapeBinders make it possible to assemble Parts, then using their position in the assembly to generate new Parts. However because new Parts depend on Parts in the assembly, if you try to add them to the assembly FreeCAD 0.19 will complain about cyclic redundancy, which makes sense.

To get around this, one method is to change the Bind Mode of the SubShapeBinders to "Disabled" which copies the geometry but unbinds it from the base object.

Kopia: Handling Directories That No Longer Exist

2022-07-21T16:05:00+10:00

Scenario

There exists a policy that snapshots directory ABC
Directory ABC now no longer exists
You want to keep existing snapshots
You want to stop kopia from attempting to take any more snapshots

In order to achieve (4):

Set the policy to manual only
Disable inheritance from parent/global policy

(2) is required as otherwise I find ABC's policy somehow inheriting the scheduling settings from the parent/global policy and thus is scheduled even though manual snapshots only is set.

To carry out the above steps:

KopiaUI:
Edit Policy
- Scheduling > Manual Snapshots Only
- Other > Disable Parent Policy Evaluation
CLI: set policy --manual --inherit false

Adventures with Astroberry/KStars/Ekos

2022-03-05T04:53:00+11:00

In astrophotography the combination of a goto mount, a camera and plate-solving is a powerful one. It allows you to do all kind of neat things, like polar-alignment without having a clear view of the south, extremely accurate goto functionality, and automated capture of multiple predefined targets.

There are roughly speaking three popular single-board-commputers (SBCs) that facilitate this: ASIAIR PRO, Stellarmate and and astroberry, in increasing order of technical complexity and reduction in price, with astroberry being free. Both Stellarmate and astroberry use the same underlying software, namely kstars/ekos and INDI Library.

Since both ASIAR and Stellarmate devices were out of stock, but Raspberry Pi 4s (rpi) aren't, I opted to try astroberry. Installation was straightforward, everything worked as advertised. To ease mounting I designed and printed an accessory collar that allows the rpi to be attached and removed easily.

Raspberry Pi 4 in custom case mounted the accessory collar.

The first issue with astroberry, and possibly also with Stellarmate, is that control is done via a remote desktop session over VNC. This isn't a problem other than the fact we are forced to use a desktop software on mobile device with very different aspect ratios and interaction paradigms. The end result is a very janky user experience. There are also concerns that, as the rpi uses passive cooling, it will quickly be thermally throttled, further degrading user experience unless one adds a cooling fan and heatsink.

So the next evolution is to run only the INDI server on the rpi and run kstars and ekos on a laptop, which provides a native desktop experience appropriate to the device and moves any heavy processing onto a more capable platform. This works, but does take away the main advantages of having a SBC, namely a small and light setup.

The next issue that arises is that of transfer time. Running kstar/ekos on a laptop means images captured by the rpi must be transferred before any additional algorithms, such as plate-solving, can run. With my Canon 800D it takes up to 15 seconds to transfer a single raw file over the built-in wireless. This is an unacceptable long amount of time.

The logical step is then to do away with the rpi altogether and run everything on the laptop I am using anyway. In this case a lenovo X220 with extended batteries. This works well, with transfer times of approximately one second.

As an aside, the default ekos layout doesn't do well on a display that is only 768px high, with many UI elements in the capture tab unusable. Setting ekos to have tabs on the left as opposed to at the top resolved this issue.

The current setup is thus:

Canon 800D with 200mm F/2.8L II
SmartEQ Pro+
Lenovo X220 with KStars/EKOS/INDI

Now if only the clouds would go away I can actually see how this performs in anger.

Astrophotography Notes: ISO, Light Pollution, Histograms

2022-02-22T14:32:00+11:00

ISO

I, like many people, thought that lower ISO means less noise. However this isn't true, at least not for modern camera. As a first order approximation, my understanding is that the signal path looks something like this:

Photons impact the sensor
Sensor generates electrical signal
ISO amplifier amplifies the signal
Readout electronics converts the signal into digital numbers
digital numbers recorded as a RAW file

Generally speaking there are two major source of noise:

Random noise inherent in the photons arriving at the sensor
Noise generated by readout electronics and quantisation noise in the ADC
1. aka readout-noise

We can express the signal-to-noise ration (SNR) of the RAW image as follows:

RAW_SNR = (ISO_gain * S) / (ISO_gain * N + N_readout)

Where S and N is the light signal and noise, and N_readout is the readout-noise. ISO_gain is the gain corresponding to the ISO value, but not the ISO value itself. e.g. ISO 100 doesn't not mean gain of 100.

Generally speaking S >> N, that is the light signal itself has good SNR.

In low light situations where S of a similar magnitude to N_readout, if we use a low ISO such that ISO_gain is 1, then

RAW_SNR ~= S / N_readout

as N_readout >> N.

By increasing the ISO such (ISO_gain * N) >> N_readout,

RAW_SNR = (ISO_gain * S) / (ISO_gain * N + N_readout)

~= (ISO_gain * S) / (ISO_gain * N)

~= S / N

That is, we approximately recover the original SNR of the signal which is the best that can be asked for without additional processing.

This bears out in practice. I took a series of images in low light with the same aperture and shutter speed, changing only the ISO. Each image was then digitally processed in darktable with exposure compensation so images are of the same brightness (i.e. 1 extra step of exposure for each reduction in ISO):

The improvement in image quality at ISO 6400 compared to ISO 400 is significant.

Light Pollution

With such high ISO, when I take pictures in my backyard in Bortle 7 skies, I get images that appear overexposed due to the high background brightness:

Single exposure, high background brightness

Histogram, plenty of room.

Previously I have viewed such images as "unusable". However upon looking at the histogram, it is clear that despite the background brightness, the majority of the signal is properly captured without clipping. Indeed, when post-processed in sirl, the final image does not suffer from the background glow:

So be not afraid of using high ISO in light polluted skies - as long as the histogram is not clipping the signal is there and can be recovered.

GDK/GTK Signal Handling Notes

2022-02-19T04:55:00+11:00

I recently tried my hands at implementing motion event support for canvas widgets in Toga on Linux, which uses GTK3 as its GUI back end. In the process I had learn to navigate GDK's event handling mechanics and documentation. This post is a summary of notes I made during the process.

### Basics

GTK widgets general signals, which you can be notified of if you connect() to the widget by specifying

1. the name of the signal 2. callback to invoke when the event occurs ### Event Names To find out what signals a widget emits you naturally look at the widget's documentation, e.g. for [DrawingArea](https://docs.gtk.org/gtk4/class.DrawingArea.html). However you will quickly realise not *all* signals are listed. The list does not include signals such as "draw" which is mentioned in [python-gtk-3](https://athenajc.gitbooks.io/python-gtk-3-api/content/gtk-group/gtkdrawingarea.html)'s documentation. The actual list of inherited signals can only be seen in the [documentation for Widget](https://docs.gtk.org/gtk3/class.Widget.html#signals). Why the disparity? No idea. ### Event Mask Not that widgets do not emit all possible signals, there is an [EventMask](https://docs.gtk.org/gdk3/enum.EventType.html) bitfield that determines which signals a widget will emit. It is not enough to simply connect() to a signal - you must also enable those events you wish to receive if not enabled by default via gtk_widget_add_event(). Note that the relationship between signal names defined and the event-mask required is not explicitly defined. It comes down to guessing the how they are related and trial and error.

Verifying GoTo Mount Settings

2022-02-09T06:16:00+11:00

I recently got a iOptron SmartEQ Pro+ mount and while setting it up I was confused over the time. Should it be local time and then I set the UTC offset in minutes? What do I do with the DST setting?

One way I found of checking whether my settings is correct is

Look up the altitude and azimuth coordinates of a bright star like Sirius using a planetarium app
Command the mount to slew to that star
On arrival the altitude and azimuth coordinates are displayed on the handset
Compare the coordinates shown on the handset vs coordinates obtained in step (1). They should match to at least the degree. If not the time and location setting is wrong.
Tweak settings and repeat from (2) onwards until there is at least degree level agreement between the mount and reference altitude and azimuth coordinates.

Goodbye SpiderOak

2022-01-02T08:57:00+11:00

I have been using SpiderOak One since Edward Snowden recommended it in 2013, almost a decade ago. I have over 1.5T of deduplicated data spread across 6 or so devices. This year, in 2022, I will not be renewing my subscriptions.

The main issues:

Lack of updates: the last update to SpiderOak One was in 2019-09. All recent updates have been for CrossClave. It is evident that One is no longer a priority.
Lack of speed: since day one (ha!) One has always been slower than competitors like Dropbox. In the beginning it wasn't so bad and one must makes some tradeoffs for the security offered. However in recent years this has not improved and setting up a new device takes days if it ever completes the initial synchronisation. Once setup the application is bloated, slow, generates massive amounts of local metadata.
Lack of control: One installations will randomly stall on sync or update because _another_ device has gone bad. This is not a great situations when I have devices spread across the city.

To replace SpiderOak One I am currently using:

Kopia for backup with de-duplication and client-side encryption. The target is backblaze b2.
Sync.com for file sync. Note that Sync.com doesn't provide the same security guarantees as Kopia or SpiderOak, but I am willing to trade that for a sync solution that is fast, quick and affordable.
1. There is no native linux client but the Sync.com client runs decently under wine and the performance on my slowest machines are acceptable.

Quick Survey of Some Lightweight Linux Distributions

2021-11-24T05:35:00+11:00

On an ASUS E203M

Busenlabs Lithium

Installed fine but kernel (4.9?) would immediately shutdown after decrypting the root volume due to incorrect thermal readings. Was not able to disable this via thermal.nocrt=1 boot param

AntiX 21

Live system did not have working mouse. Did not proceed to installation as I didn't want to be stuck with having to fix the mouse issue.

bodhi linux HWE 6.0.0

Mouse works in the live system, I like the Enlightenment lineage. No GUI setting to disable tap-to-click on the touchpad, resolved via synclient MaxTapTime=0 so not a deal breaker. However despite being lightweight there was noticable GUI lag when running the installer.

Q4OS Gemini, Trinity

I like the idea of Trinity Desktop and they are using a decently recent kernel as well (5.10). Installed fine but wifi doesn't connect to the 5G network. Worked fine on 2.4G. Had an annoying issue where Alt-Space didn't work, giving me ISO_Next_Group. Fixed it by setting via xkb options to use "both ctrl at the same time" to switch languages which then allowed alt-space to work as intended.

Systems feels really snappy and the retro look is not bad. Sticking with this one for now.

3D Printing at Home

2021-11-16T02:12:00+11:00

FlashForge Creator Pro

I finally got my own 3D printer, a FlashForge Creator Pro, during the EOFY sale. My choices were between the Creator Pro or the Up Mini 2 ES with the build volume of the Creator Pro being the deciding factor.

Had bit of a rocky start with bed leveling but nothing a bit of patience won't fix. It prints reliably now though I have plans for a semi-assisted bed leveling jig.

Designs

Over the past week I have worked on and off on an iPad mini holder to position it above my monitor so I can use it as a status screen or as a monitor to watch twitch while I am doing menial tasks.

I also made a small headphone hanger to save a bit of space.

Both of these designs were made in Fusion360, my first with the software. Normally I use blender because that's what I comfortable with but the Fusion brings a lot to the table and I will be using it going forward. It doesn't hurt that experience and skills with Fusion will be useful in an industrial setting.

Next on the list is some replacement end-stops for a wall hanging and a keypad bruteforcer.

The Subtle Poison of Religion

2021-11-16T02:10:00+11:00

On the 12th of November 2019, Nationals MP Barnaby Joyce said on TV that:

I acknowledge that the two people who died were most likely people who voted for the Green party, so I am not going to start attacking them. That's the last thing I want to do.

Why does the politics of the deceased matter and why would Mr. Joyce make such a speculation? I can't help but think that Mr. Joyce did it because, on some level, he thinks those people deserve it. I think this is the subtle poison of religion: that those who do not believe as I do deserve less than I do.

This idea is widespread across all variants of Christianity: you are saved if you believe in God and Jesus and the Holy Spirit but damned if you don't. You deserve salvation only if you Believe. It is this idea that motivates the Evangelicals: they must Save you by spreading their Belief so you, too, deserve salvation. It is this idea that underpins the prosperity gospel: those who Believe is deserving of wealth and therefore the harder you Believe, whether by praying harder or donating more to the Church, the more you deserve wealth. Conveniently if you are wealthy then obviously it is because you deserve it due to your faith.

Once learned and integrated into one's world view via religious instruction, this idea, that those who do not believe as I do deserve less, poisons the lens through which an individual interacts with the world. When a core part of your identify requires you to accept that, on the basis of belief alone, not everyone is equal, then it is a small step to thinking that those who hold different political beliefs deserve less then those whose beliefs align with yours. Maybe they deserve less sympathy. Maybe they deserve less government support. Maybe they deserve less compassion or concession. Whatever the case may be, on the basis of their political belief, they are Other and they are Undeserving -- and in politics this is a problem.

Some would claim that it is possible to separate one's religious beliefs from one's political actions. I reject such claims in the same way I reject any claims one can be racist and still be a fair judge. Some would claim that some people think thusly even without religion and I would agree. However some religions requires such thinking. Some would say not all religions features undeserving unbelievers and claim my title is inaccurate and I would concede their point but also point out that the major religions do not fall within this category.

How Not to Play with Programmable LED Strips

2019-12-13T14:38:00+11:00

You Need That Resistor

That resistor on the data line? Yeah you need it. Otherwise you might blow an LED which renders the entire rest of the strip useless. If that happens cut out the first LED and solder the power and data lines directly to the second LED.

You Want Shorter, Thicker, Wires

Using jumper wires, of the 300-for-\$5 variety is fine for a few LEDs. If however you have 300 LED drawing around 1A then those thin wires have non-negligible voltage drop. For me this was on the order of 0.7V or more. This means even though my power supply was putting out 5V the LED strip was only seeing 4.3V, causing flickering of the LEDs.

For any piece of wire the voltage drops increases with current simply because of V=IR. Thicker wires have less resistance per unit length and therefore less voltage drop per unit length.

T102HAAS.303 Considered Harmful For Linux

2019-06-24T02:20:00+10:00

`T102HAAS.303` Breaks Suspend

After upgrading my Asus Transformer Mini's BIOS to T102HAAS.303 suspend was completely broken. Closing the "lid" would cause some kind of suspend that cannot be disabled in software and from which Linux 4.15.0 cannot successfully resume from (actually it does resume but the display will stay blank).

This behaviour cannot be disabled in software by editing logind.conf or acpi-support or any of the solutions found on the web about disabling lid action. Messing about with acpi_osi didn't help either.

Downgrading from `T102HAAS.303`

If you are reading this after upgrading to T102HAAS.303 you probably want to downgrade. Unfortunately the firmware that ships with the computers, version 202, cannot be found on the Asus website. You can however find the 300 firmware if you click on "View all downloads" under the BIOS section. Download this file and put it on a FAT32 formatted USB drive then:

Reboot, hold then ESC to enter Setup
Find the Easy Update entry and press ENTER, starting the easy update program
Navigate to your USB drive, it will be FS0 or FS1
Locate the T102HAAS.303 file and press ENTER
When the dialogue complains that the build date is too old type the word risky on the keyboard
Select Yes on the dialogue that appears after
Wait for the computer to reboot

The key to this process is the word risky which is an undocumented feature that by-passes the build date check, allowing you to downgrade. You just type this in when the error dialogue appears, there will be no text box or anything.

Re-enabling Hibernation

Downgrading will re-enable Secure Boot, which disables hibernation on Linux. Just disable it and hibernation will work again.

Ubuntu 18.04 on Asus Transformer Mini (T102H)

2019-06-24T02:20:00+10:00

Installation

Create a USB drive with a single FAT32 partition then extract the installation ISO into it using 7z:

7z x /path/to/ISO -o/path/to/usb

Note that there is no space between -o and the following path.

Plug in the USB drive then turn on the T102H while pressing the ESC key. This will allow you to enter the settings menu and allow you to boot from USB. Select installation and follow the instructions until asked to reboot.

Xorg Setup

An immediate problem is that the display is portrait by default. Additionally the modesetting driver is used which has worse performance than the intel driver. Fix both of these issue by placing the following file in /usr/share/X11/xorg.conf.d/99-transformer.conf:

Section "Device"
 Identifier "i915"
 Driver "intel"
 Option "TearFree" "true"
 Option "DRI" "2"
 Option "Backlight" "intel_backlight"
EndSection

Section "Screen"
 Identifier "Screen0"
 Monitor "BuiltInLCD"
EndSection

Section "Monitor"
 Identifier "BuiltInLCD"
 Option "Rotate" "right"
EndSection

Section "InputClass"
 Identifier "BuiltInTouchscreen"
 MatchProduct "ELAN22A6:00 04F3:22A6"
 Option "TransformationMatrix" "0 1 0 -1 0 1 0 0 1"
EndSection

This sets the display driver to intel, rotates the monitor, and also transforms touchscreen inputs to match the landscape orientation.

i915

To further improve performance place the following into /etc/modprobe.d/i915.conf

options i915 enable_fbc=1 enable_guc=3 enable_psr=1 disable_power_well=0 semaphores=1

Backlight

Out of the box backlight doesn't work because of a module loading order issue [96571]. The easiest fix, found in the bug report thread, is to use dracut to remove the i915 module from initramfs so it loads after the PWM modules.

sudo apt install dracut
sudo dracut -f --omit-drivers="i915"
sudo update-grub

This issue may be fixed in a later release as the issue has been reported to Ubuntu.

After rebooting /sys/class/backlight/intel_backlight/ should exist, indicating that backlight control is available.

Keyboard Backlight Control

Unfortunately while we can now control the backlight using programs like xbacklight, the screen brightness keys (fn+F5 and fn+F6) don't work. We can get around this by binding control-F5 and control-F6 to trigger xbacklight -dec 20 and xbacklight -inc 20 respectively to decrement/increment screen brightness by 20% per keyboard press.

Airplane Mode

Similar to the backlight control buttons the airplane mode button also doesn't work. The following script uses rfkill to toggle bluetooth and wifi on/off, effectively implementing airplane mode in software. I haven't found a way to disable bluetooth and wifi in hardware.

#!/bin/bash

BLUETOOTH_OFF_BY_DEFAULT=1

n_devices="$(rfkill -n | wc -l)"
n_blocked="$(rfkill -n | grep -w blocked | wc -l)"

echo "$n_devices devices, $n_blocked blocked"

if [ "$n_blocked" == "$n_devices" ]; then
  rfkill unblock bluetooth wlan

  if [ "$BLUETOOTH_OFF_BY_DEFAULT" == "1" ]; then
    rfkill block bluetooth
  fi
else
  rfkill block bluetooth wlan
fi

Power Saving

It is a good idea to install tlp to improve the running time

TODOs:

Script and keybindings to rotate the screen and touchscreen
Pressure level with the pen

IPython Notebook on GPS Timing and CDMA

2018-08-05T14:59:00+10:00

In \[1\]:

    %matplotlib inline

    import matplotlib
    import numpy as np
    import matplotlib.pyplot as plt

# GPS Timing¶ Carrier-phase detection is suppose to yield better timing information than tracking the pseudorandom code stream. The reason for this is supposedly that the higher frequency carrier allows for more accurate measurements of the mismatch between the generated pseduorandom code stream and the broadcasted one. This increase in accuracy comes from sharper peaks in the autocorrelation function. Lets try this out:

In \[2\]:

    def corr(npoints, repeat):
        A = np.random.randint(0, 2, npoints)
        A = np.repeat(A, repeat)

        xcor = np.correlate(A, A, mode='same')
        plt.figure()
        N = len(A)
        offvec = np.arange(0, N)-N/2
        print offvec.size, xcor.size
        plt.plot(offvec, xcor, 'x-')




    # generate 5 points each repeating 20 times, a slow signal    
    corr(5,20)

    # a much faster signal
    corr(100,1)

100 100 100 100

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0Ai4ikhAK6iEhK/H+9IRbHPtu82AAAAABJRU5ErkJggg==)

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0Agg==)

It is clear that if you were trying to figure out the sample delay, you are much better off with the faster signal because the it is *very* obvious when you have the timing right. With the slower signal, you can be a little wrong and still get within a few pc of the correct correlation value.

# Code Division Multiplexing¶ Try out CDM for myself. It is important that -1,1 is used instead of 0,1 because multiplying by 0 is always 0.

In \[3\]:

    def gen_code(N):
        """
        Generatea a random array containing -1 and 1 of size N
        """
        out = np.random.randint(0, 2, N)
        out *= 2
        out -= 1
        return out

    def code_modulate(signal, stretch=5, carrier=None):
        signal = np.repeat(signal, stretch)
        if carrier is None:
            carrier = gen_code(len(signal))

        return np.multiply(signal, carrier), carrier

    sig_1 = gen_code(100)
    sig_2 = gen_code(100)

    out_1, c_1 = code_modulate(sig_1)

    # generate an orthogonal array by flipping every other element
    c_2 = np.array(c_1)
    c_2[::2] = -1*c_1[::2]
    out_2, _ = code_modulate(sig_2, carrier=c_2)

    out_comb = out_1 + out_2

    def plot_sig(s, title=''):
        plt.figure()
        plt.stem(s)
        plt.ylim([min(s)-0.5, max(s)+0.5])
        plt.title(title)

    plot_sig(sig_1, 'sig_1')
    plot_sig(sig_2, 'sig_2')
    plot_sig(out_comb, 'combined output')

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz%0AAAALEgAACxIB0t1+/AAAFpFJREFUeJzt3X2sZPV93/H3Z7PBtTc1xJa9YcEsdAmxTZU4WKEkKPKt%0A7RhIE5YklgNd6oe2wYqS1KEUAandvcj9w1blRLFwFK1KiWPVJYmTmsW1VUCwIFCT0tgOODxtug+G%0AXXud1sE8BKWY/faPmWVnZ++ce+bMuQ9w3y9pxMw5v/P7fc/vnJnPzjn3XlJVSJLWtnUrXYAkaeUZ%0ABpIkw0CSZBhIkjAMJEkYBpIkDAMJgCTXJdmx0nVIKyX+noHUjyRnA58A3gq8pqq+Z4VLklrzm4HU%0An+eBPwD++UoXIk3LMNCak+SaJE8keSrJw0n+cZLtST4z0ua9SfYl+eskH06yN8nbm/qtqseq6ibg%0AoSXfCalnhoHWlCRnAb8CvLWqXg1cAOwbrq5hmzcDnwIuA04GTgQ2LXux0jIyDLTWvACcAPzDJOur%0A6utVtXeszS8AO6vqf1TVd4F/t+xVSsvMMNCaUlX/G/h1YB74VpLPJjl5rNkm4PGRbZ4D/u+yFSmt%0AAMNAa05V3VxVPwmcNlz08bEm3wBOPfIiySuB1y5TedKKMAy0piQ5a3jD+ATg/wHPMbh0NOpzwM8m%0AOS/J9zL4FtG2/1cArxg8zSuG40irnmGgteYVwMeAvwYOAq8DrhttUFUPAb/G4MdEDwJPAd8C/q6p%0A4ySbGYTLgwxuRj8HPNJv+dLS6OWXzpLcCPwMcKiqfniB9W8DbgH2DBf9SVX9+5kHlpZBkg3Ak8CZ%0AVbV/peuRlkJf3wxuYvAjek3uqapzhg+DQKtakp9J8sphEHwCeMAg0MtZL2FQVfcCf7NIs/QxlrRM%0AtjK4RPQEsAX4RYAkX0zy9PAX1p4aeX7tShYrzaq3v000vF56a8Nloj9m8MY6AFw9vC4rSVoF1i/T%0AOH8OnFZVf5vkIuDzwFnLNLYkaRHLEgZV9czI8y8l+Z0kr6mqb4+3TeKfUZWkKVXVTJfi+/zR0jDh%0AvkCSjSPPz2Vweeq4IDiiqnxUsX379hWvYTU8nAfnwrlofvShl28GST4LzAGvTfJ1YDuDv/9SVbUD%0AeHeSX2bwJ36fY3gzTpK0OvQSBlX1TxdZ/ykGfwVSkrQK+RvIq9jc3NxKl7AqOA9HORdHORf9WnX/%0A28sktdpqkqTVLAm1im4gS5JeogwDSZJhIEkyDCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiS%0AMAwkSRgGkiQMA0kShoEkCcNAkoRhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQ%0AJNFTGCS5McmhJA80tPlkkt1JvprkLX2MK0nqR1/fDG4CLpi0MslFwJaq+kHgg8Dv9jSuJKkH6/vo%0ApKruTbK5oclW4PeHbf8syYlJNlbVoYUa7927n4985Pc4cOAwJ574FFXreeqpV3HKKeu44op3smPH%0AHQuu++hH388ZZzSVcWzf4/019TG+3ZF2k5bPsh+Tampbe1O70bHajjvNfLaZv7bHreux6lJvl/3o%0Ao/Y+zp8u/S1F7V3Os6Z2sx7fru+5tjW1nc8utU97Dvaiqnp5AJuBByasuxX4iZHXdwDnTGhbW7Zc%0AVfBMwb6CK4fPq+ChWr/+fRPWPVNbtlxVe/bsq0n27Nk30vd4f5P7OH67Qbu77753weV79uwb22aa%0A/Vi4puPH6tJudKx24043n23mr91x63qsmnQ5jrPv7zTHqsv506W/pai9y3nW1G7W49v1Pdeuprbz%0AOeu52fYcHHyUz/gZPmsHL3bUYxgc3dH5kefjr8fXDSZm27b5iRO+bVtTf5P7OH67QbvTT//5idsf%0Au800+9F2rC7tph93uvlsM39d53z6+trW23QcZ9/faY5Vl/OnS39LUXuX82y293Pz8e36nmtXU9v5%0AnPXcbHsO9hEGvVwmauEA8IaR16cOl03wH0ae3w/MDZ8fBjYMn29fYLsNHDx4eHIRB0a3H+9vch/H%0Abzdo9+STGyZuX0VDrU370XasLu1Gx2o37nTzufA2x7Zrd9y6HqsmXY5jm+271t7P+dOlv6Wovct5%0A1tRu4fqaNJ9nXdZNrqntfLY1/bm1a/joT58/WprhYyE7gfcCJDkPeLIm3C8YuBqYHz5+bGT5OuDZ%0AkdejzwevN22avEunnDK+/fjrhfs4frtBu5NOenbi9sdv0zTu4jUdP1bXdtONO918LrxN81y03Wb6%0A+trW23Qc22zftfb+zp8u/fVde9fzrPv7eVx/77nFa2o7n21Nf3zmOPoZeXWnMY8z61eLGkTkZ4GD%0AwN8BXwc+wOCnhq4YaXMD8FfAXzDhEtGw3dg1saZrpS+VewbT7MdS3jMYH2sl7hm0O27eM5jm/Flt%0A9wymOc8mtevj+HZ9zy1ek/cMluEB1J49+4bXxqq2bv31uvjif1MwuF529933TlzX5kCM9j3eX1Mf%0A49sdaTdp+fi6afZjUk1ta29qNzpW23Gnmc8289f2uHU9Vl3q7bIffdTex/nTpb+lqL3LedbUbtbj%0A2/U917amtvPZpfZpz8E+wiA1+ABeNZLUkZqSQfaNP19sXbtxJvc3zXZttu+6H23H6tKuy7hNusxf%0A1znvUt9ifU7bd9+193H+dOlvKWrvcp7N+n5uqqnre65tTX3U26W/Y+sLVTXpMn0r/jkKSZJhIEky%0ADCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNAkoRhIEnCMJAk%0AYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJGAaSJHoKgyQXJnkkyWNJrllg%0A/duSPJnky8PHh/sYV5LUj/WzdpBkHXAD8A7gIHB/kluq6pGxpvdU1cWzjidJ6l8f3wzOBXZX1f6q%0Aeh64Gdi6QLv0MJYkaQn0EQanAI+PvH5iuGzcjyf5apL/luTNPYwrSerJzJeJWvpz4LSq+tskFwGf%0AB86a1Hh+fv7F57t2zTE3N7fU9UnSS8auXbuAXYx8VM4sVTVbB8l5wHxVXTh8fS1QVfXxhm32Am+t%0Aqm8vsK6O1JTAkfJGny+2rl3dk/ubZrs223fdj7ZjdWnXZdwmXeav65x3qW+xPqftu+/a+zh/uvS3%0AFLV3Oc9mfT831dT1Pde2pj7q7dLfsfWFqprpUnwfl4nuB85MsjnJCcClwM7RBkk2jjw/l0EIHRcE%0AkqSVMfNloqp6IcmvArcxCJcbq+rhJB8crK4dwLuT/DLwPPAc8IuzjitJ6s/Ml4n65mWi6cfyMtH0%0AvEy0dLV7mai/2tu2Wy2XiSRJL3GGgSTJMJAkGQaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwk%0ASRgGkiQMA0kShoEkCcNAkoRhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEY%0ASJIwDCRJGAaSJHoKgyQXJnkkyWNJrpnQ5pNJdif5apK39DGuJKkfM4dBknXADcAFwNnAZUneONbm%0AImBLVf0g8EHgd2cdV5LUnz6+GZwL7K6q/VX1PHAzsHWszVbg9wGq6s+AE5Ns7GFsSVIP+giDU4DH%0AR14/MVzW1ObAAm0kSStk/UoXsJD5BIDtwK7AHFAAOdpm9PX4ujaa+ptmuzbbN9Xadl3TWF3adRm3%0ASZf56zrnXepbrM9p++679j7Ony79NVnO82zW93NTTV3fc21r6qPeafvbxeDzcX5+e2/j9hEGB4DT%0ARl6fOlw23uYNi7R50XxV52ISGN189PX4ujZ9NG3TdV0XXWrve9ymuW2qoe95bztW38exj3Zdxm1r%0Aqfdx1vq6antMV6qmpuWz1j6p3RyDxxHXX399tx0Z0cdlovuBM5NsTnICcCmwc6zNTuC9AEnOA56s%0AqkM9jC1J6sHM3wyq6oUkvwrcxiBcbqyqh5N8cLC6dlTVF5P8dJK/Ap4FPjDruJKk/qSW63tVS0lq%0Alpq8TORlIi8TdV/nZaLpa2pavlSXiY5vF6pqpjsX/gayJMkwkCQZBpIkDANJEoaBJAnDQJKEYSBJ%0AwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNA%0AkoRhIEnCMJAkYRhIkjAMJEkYBpIkDANJErB+lo2TfD/wB8BmYB/wnqr6zgLt9gHfAQ4Dz1fVubOM%0AK0nq16zfDK4F7qiqHwLuBK6b0O4wMFdVP2oQSNLqM2sYbAU+PXz+aeCSCe3Sw1iSpCUy6wf066vq%0AEEBVfRN4/YR2Bdye5P4kvzTjmJKkni16zyDJ7cDG0UUMPtw/vEDzmtDN+VX1jSSvYxAKD1fVvZPG%0AnJ+ff/H53Nwcc3Nzi5UpSWvGrl272LVrV699pmrS53eLjZOHGdwLOJTkB4C7qupNi2yzHXi6qn5z%0AwvqarSYY3Xz09fi6Nn00bdN1XRddau973Ka5baqh73lvO1bfx7GPdl3GbWup93HW+rpqe0xXqqam%0A5bPW3r5dqKpMvydHzXqZaCfw/uHz9wG3jDdI8qok3zd8vgF4F/C1GceVJPVo1jD4OPBTSR4F3gF8%0ADCDJyUm+MGyzEbg3yVeAPwVurarbZhxXktSjmS4TLQUvE83Wn5eJvEw0yzovE01fU9PytXSZSJL0%0AMmAYSJIMA0mSYSBJwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwkSRgG%0AkiQMA0kShoEkCcNAkoRhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJYsYwSPLuJF9L%0A8kKScxraXZjkkSSPJblmljElSf2b9ZvBg8DPAXdPapBkHXADcAFwNnBZkjfOOK4kqUczhUFVPVpV%0Au4E0NDsX2F1V+6vqeeBmYGtTv5dffj179+6fqpa9e/dz+eXXv7j9Pffc9+LrSy65kq1br16079E+%0AmrYZH6vtui7a9reU447Pxejcjo7VdAz6mPem/Z10vPs4jm376Fr7rOdP1/76rr1vk+prez4udU1t%0Az/0utXd9L82kqmZ+AHcB50xY9wvAjpHXlwOfbOir4JnasuWq2rNnX7WxZ8++2rLlqoJnCqrgoVq/%0A/n0jr68ceb5w38f3sfA2x7drt66Ltv0t/bhXNsztYKy77753kWMw27w3b9N0vPs4jm376FL7bOdP%0A1/76rr1vzfUtfj4uT01tz/3pau/yXhp8lM/4Ob5oA7gdeGDk8eDwvz870uaufsNgsMPbts23Okjb%0Ats2PTFQVjL8efb5w38f3sfA2x7drt66Ltv0t/bhNcztYf/rpP9+qXdd5b96mqY8+juNs7doeqy7H%0AsWt/fdfet+b6pj/Plqamtuf+0r+X+giD9S2+OfzUjF8+DgCnjbw+dbiswTwA9913F7t2vY25ubnm%0AAQ4cBjaMLBl/veHYDdjAwYOHF+lj4W2quq3r4viaFu6vbbvu4zbN7WD9k09uaNWu67w3b9PURx/H%0AcbZ2zbW3q2mSrv31XXvfms+L6c+zpalpMNbi5/5SvJfu57777mR+vtqWv6g+f7R00n2D+4Ezk2xO%0AcgJwKbCzuat54GrOP//tiwYBwCmnrAOeHVky+vr6sXUAz7Jp07G7fmwfk7c5fqx267po29/Sjjs+%0AFwuPddJJz7Zq13XeJ28zPtb1E54f21/749i2j661t6tpkq799V173ybX1+58XPqajo7VfO5PX3u7%0A99KPcf75b2d+fp75+fmp9mOiWb5WAJcAjwPPAd8AvjRcfjLwhZF2FwKPAruBaxfps6a97td8DXlf%0ATX89dPI2a++ewfhcLOU9gy7Hqul493Ec2/bRtfbVcM9g9tr7Nrm+dufj6rlnMH3tK3XPIIN+Vo8k%0AtW3bPB/96Ps544zNrbfbu3c/H/nI73Hw4GE2bVrHFVe8kx077uDgwcO8+tVPUbWep59+FZs2rZvY%0A92gfTduMj9V2XRdt+1vKccfnYnRuR8dqOgZ9zHvT/k463n0cx7Z9dK191vOna3991963SfW1PR+X%0Auqa2536X2qd9LyWhqpp+qnNRqzIMVltNkrSa9REG/jkKSZJhIEkyDCRJGAaSJAwDSRKGgSQJw0CS%0AhGEgScIwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNAkoRhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaB%0AJAnDQJKEYSBJwjCQJGEYSJIwDCRJzBgGSd6d5GtJXkhyTkO7fUn+IslXkvzPWcaUJPVv1m8GDwI/%0AB9y9SLvDwFxV/WhVnTvjmGvGrl27VrqEVcF5OMq5OMq56NdMYVBVj1bVbiCLNM2sY61FnuwDzsNR%0AzsVRzkW/lusDuoDbk9yf5JeWaUxJUkvrF2uQ5HZg4+giBh/u/7aqbm05zvlV9Y0kr2MQCg9X1b3T%0AlytJWgqpqtk7Se4CrqqqL7doux14uqp+c8L62QuSpDWmqha7XN9o0W8GU1iwkCSvAtZV1TNJNgDv%0AAq6f1MmsOyRJmt6sP1p6SZLHgfOALyT50nD5yUm+MGy2Ebg3yVeAPwVurarbZhlXktSvXi4TSZJe%0A2lbNj3smuTDJI0keS3LNSteznJKcmuTOJH+Z5MEk/2q4/PuT3Jbk0ST/PcmJK13rckmyLsmXk+wc%0Avl6Tc5HkxCR/lOTh4fnxj9bwXFw5/CXXB5L85yQnrJW5SHJjkkNJHhhZNnHfk1yXZPfwvHlXmzFW%0ARRgkWQfcAFwAnA1cluSNK1vVsvou8K+r6mzgx4FfGe7/tcAdVfVDwJ3AdStY43L7EPDQyOu1Ohe/%0ADXyxqt4E/AjwCGtwLpJsAn4NOKeqfpjB/c7LWDtzcRODz8dRC+57kjcD7wHeBFwE/E6SRe/Froow%0AAM4FdlfV/qp6HrgZ2LrCNS2bqvpmVX11+PwZ4GHgVAZz8Olhs08Dl6xMhcsryanATwP/cWTxmpuL%0AJK8GfrKqbgKoqu9W1XdYg3Mx9D3AhiTrgVcCB1gjczH8Ufy/GVs8ad8vBm4eni/7gN0MPmMbrZYw%0AOAV4fOT1E8Nla06S04G3MLjZvrGqDsEgMIDXr1xly+q3gKsZ/D7LEWtxLs4A/k+Sm4aXzHYMfzpv%0Azc1FVR0EPgF8nUEIfKeq7mANzsWI10/Y9/HP0wO0+DxdLWEgIMn3AZ8DPjT8hjB+d/9lf7c/yT8B%0ADg2/KTV9tX3ZzwWDSyHnAJ+qqnOAZxlcGliL58VJDP4lvBnYxOAbwjbW4Fw0mGnfV0sYHABOG3l9%0A6nDZmjH86vs54DNVdctw8aEkG4frfwD41krVt4zOBy5Osgf4L8Dbk3wG+OYanIsngMer6n8NX/8x%0Ag3BYi+fFO4E9VfXtqnoB+K/AT7A25+KISft+AHjDSLtWn6erJQzuB85MsjnJCcClwM4Vrmm5/Sfg%0Aoar67ZFlO4H3D5+/D7hlfKOXm6r6jao6rar+AYPz4M6q+mfAray9uTgEPJ7krOGidwB/yRo8Lxhc%0AHjovyd8b3gx9B4MfMFhLcxGO/bY8ad93ApcOf9rqDOBMYNH/dcCq+T2DJBcy+MmJdcCNVfWxFS5p%0A2SQ5H7iHwZ8Er+HjNxgcwD9kkPL7gfdU1ZMrVedyS/I2Bn/m5OIkr2ENzkWSH2FwI/17gT3ABxjc%0ASF2Lc7GdwT8Qnge+AvxL4O+zBuYiyWeBOeC1wCFgO/B54I9YYN+TXAf8CwZz9aE2v+i7asJAkrRy%0AVstlIknSCjIMJEmGgSTJMJAkYRhIkjAMJEkYBpIkDANJEvD/AaXk5peQHjgDAAAAAElFTkSuQmCC)

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0A+P96j4wSXE5pjAAAAABJRU5ErkJggg==)

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXkAAAEKCAYAAAD3tSVSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0AB2Gcz6IS3Kt+AAAAAElFTkSuQmCC)

In \[6\]:

    def code_demodulate(signal, carrier, stretch=5):
        y = np.multiply(signal, carrier)
        ysubs = np.split(y, len(y)/5)
        ysubs = map(sum, ysubs)
        ysubs = map(lambda x:max(-1, x), ysubs)
        ysubs = map(lambda x:min(1, x), ysubs)    
        return ysubs

    x = code_demodulate(out_comb, c_1)
    plot_sig(x, 'sig_1 recovered')
    plot_sig(sig_1, 'sig_1 expected')

    x = code_demodulate(out_comb, c_2)
    plot_sig(x, 'sig_2 recovered')
    plot_sig(sig_2, 'sig_2 expected')

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0AQmCC)

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0AGEiSMAwkSRgGkiQMA0kShoEkCfj/XAEQWOEINbsAAAAASUVORK5CYII=)

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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)

![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYMAAAEKCAYAAADw2zkCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0AAABJRU5ErkJggg==)

Perfect.

In \[ \]:

Reading Lecroy Binary Waveform in Python

2016-05-07T22:29:00+10:00

I needed to read Lecroy binary waveforms files recently, and the one python script I had found didn't read them properly due to improper handling of 16 bit samples.

I wrote an alternative lecroy.py that should be a drop-in replacement. It handles 16 bit waveforms and exports a LecroyBinaryWaveform class that also provides additional metadata. It supports saving to CSV for binary to text conversion.

Arduino-MK with Sparkfun Pro Micro 3.3V

2016-04-16T22:48:00+10:00

Arduino-Makefile needed coaxing to in order to compile code targeting the SparkFun Pro Micro 3.3V. A major source of headache is the requirement for BOARD_SUB which isn't documented and required diving into the source code, and also the fact the Pro Micro has 2 PIDs for each variant (5V and 3.3V).

Hope this will help someone in the same position as me. This makefile is meant for use on Debian Linux, with Arduino-MK installed via apt-get install arduino-mk.

MONITOR_PORT = /dev/ttyACM0

# this should point to where the sparkfun board definitions are installed
SPF_AVR_PATH = $(HOME)/.arduino15/packages/SparkFun/hardware/avr/1.1.3

# Use own arduino install which is way more advanced than the default 1.0
# installed by arduin-core
ARDUINO_DIR = $(HOME)/arduino-1.6.7

USER_LIB_PATH := $(HOME)/Arduino/libraries

# this is needed to stdint.h exposes needed #defines
CPPFLAGS += -std=gnu++11

# this is needed so we don't run into __cxa_guard_acquire issues
CPPFLAGS += -fno-threadsafe-statics


BOARD_TAG          = promicro
BOARD_SUB      = 8MHzatmega32U4
# also Arduino-mk isn't clever enough yet to properly extract PID from
# boards.txt, so we specify it here for now
USB_PID       = 0x9204
ALTERNATE_CORE    = promicro8
ALTERNATE_CORE_PATH = $(SPF_AVR_PATH)
BOOTLOADER_PATH    = caterina
BOOTLOADER_FILE    = Caterina-promicro8.hex
ISP_PROG           = usbasp


include /usr/share/arduino/Arduino.mk

Cheers,
Steve

Method Forwarding in Objective-C Pitfall

2016-04-12T20:01:00+10:00

A common pitfall of trying to use message forwarding in Objective-C is forgetting to implement

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector

in addition to

- (void)forwardInvocation:(NSInvocation *)anInvocation

Another problem is that sometimes calling objects will use

- (BOOL)respondsToSelector:(SEL)aSelector

to determine if your proxy object can respond to a particular selector. The problem is that even if you forward that selector, because the message isn't actually sent, the default implementation of respondsToSelector will return NO, causing the forwarding to fail. Therefore you should also override respondsToSelector.

Cheers,
Steve

Permission Denied When Programming Arduino Micro/SparkFun Pro Micro

2016-03-23T01:47:00+11:00

I recently started having trouble with Arduino 1.6.x not being able to program Arduino Micro or SparkFun Pro Micro, with avrdude complaining about permission denied when trying to open /dev/ACM0.

The usual solutions to this is to add oneself to the dialup group, or mess around in /etc/udev/rules.d/99-arduino.rules.

None of these worked for me. However Arduino is able to program the micros fine if I run it as root, which clued me into that fact that there is some finite time between the kernel creating /dev/ttyACM0 and udev rules having effect. Specifically, udevd is a userspace daemon, and therefore necessary runs sometime after the kernel as created the relevant device node.

The problem is thus: Arduino IDE opens /dev/ttyACM0 at 1200bps and immediately closes it. This is causes the ATmega32u4 to reset itself, causing the serial port to disappear. When the bootloader runs, it presents itself as a usb-serial device, and /dev/ttyACM0 appears again. Reappearance of /dev/ttyACM0 causes the Arduino IDE to launch avrdude, which immediately tries to open /dev/ttyACM0 and fails because udev hasn't had time to process all the rules and assign the correct permissions etc.

The solution then is to introduce a delay before running avrdude, or even better, let udev let us known when it is done, which is much more robust. This can be done using

udevadm settle -t 1

Which waits for the udev to "settle", and the -t 1 specifies a maximum wait time of 1 second.

I hit upon the idea of wrapping avrdude in a shellscript and then adding the above line before avrdude, and that was when I discovered that hardware/tools/avr/bin/avrdude is already a shellscript! This made things much easier.

My Arduino IDE's avrdude script now looks like:

$ cat hardware/tools/avr/bin/avrdude
#!/bin/bash

udevadm settle -t 1

export LD_LIBRARY_PATH="`dirname "$0"`/../lib/"
exec -a "$0" "`dirname "$0"`/avrdude_bin" "$@"

Programming of Arduino Micro and SparkFun Pro Mini is now flawless under Xubuntu 15.10.

Cheers,
Steve

Notes on Migrating a Linux Install

2016-03-23T00:42:00+11:00

Some issues I ran into when trying to move a Linux install from a 500 GB drive to a smaller 120 G SSD:

When duplicating the filesystem, make sure that /proc exists, otherwise when you boot the new drive the kernel will complaint that /proc is missing and it can't create the virtual file system
In grub-rescue, (hd0,msdos2) is /dev/sda2, and (hd0,msdos1) is /dev/sda1
When specifying initrd be sure not to accidentally select the vmlinuz image again
After you have fixed grub and find that booting is taking longer than expected, check that the UUID in /etc/initramfs-tools/conf.d/resume is the UUID of your swap partition. Check using sudo blkid

Thinkpad Mute Buttons and Xubuntu

2016-03-23T00:41:00+11:00

I recently acquired a used Lenovo X220 for use as a linux laptop, and needed the following in my openbox configuration XML to make the hardware speaker and mic mute buttons work:

  <!-- Modified for X220 -->
  <keybind key="XF86AudioMute">
    <action name="Execute">
      <command>pactl set-sink-mute 0 toggle</command>
    </action>
  </keybind>
  <keybind key="XF86AudioMicMute">
    <action name="Execute">
      <command>pactl set-source-mute 1 toggle</command>
    </action>
  </keybind>

Sources and sinks can be discovered using:

pactl list sources
pactl list sinks

For me there was only one sink, and two sources, the first of which is some kind of virtual source that monitors the microphone, while the second source is the microphone itself.

Something that is interesting is that both speaker and mic mute buttons have a central light that lights up when mute is active, and this seems tied to the hardware. This makes me trust that when the mute buttons are used they actually do something.

Hope this helps some people.

On the Use of I/Q Signals

2015-10-04T23:09:00+11:00

All signals are complex, that is they have the form of
$$x(t)=A\exp(i\omega t)$$
. I/Q presentation of a signal fully captures this by storing the real component in the I, the in-phase signal, and the complex component in Q, the quadrature signal.
When we force signals to be purely real, e.g. $\cos(\omega t)$, we taking the real part of $exp(i\omega t)$. Because we ignore the imaginary component, we lose information. Specifically, $\cos(\omega t)$ can be the real part of $\exp(i\omega t)$ or $\exp(-i\omega t)$. We don't know any more.
This ambiguity is present in the exponential form of $\cos$:
$$\cos(\omega t) = \frac{\exp(i \omega t) + \exp(-i\omega t)}{2}$$
. Note the presence of the two complex signals whose sum is always purely real as their imaginary parts cancel out. The real part of either complex signal will produce $\cos(\omega t)$.
This ambiguity is why when you multiply $\cos(\omega_0 t)$ and $\cos(\omega_1 t)$ you end up with $\cos[(\omega_0 + \omega_1)t]$ and $\cos[(\omega_0 - \omega_1)t]$. In other words, the frequency add as $\pm \omega_0 \pm \omega_1$, which produces 4 unique combinations that reduces to 2 because $\cos$ is even.
The result of multiplying real cosines produces two peaks in the frequency spectrum.
On the other hand, preserving the complex nature of a signal by presenting it as $A\exp(i\omega t)$ means that multiplying two signals together produces a unique result:
$$A_0\exp(i\omega_0 t) \times A_1\exp(i\omega_1 t) = A_0A_1\exp[i(\omega_0 + \omega_1)t]$$
. This is because there is no ambiguity as we have not thrown away any information.
The result of multiplying complex signals produces one peak in the frequency spectrum.
This is one of the advantages of working with I/Q data, which preserves the complex nature of signals, and allows us to frequency shift a signal through multiplication without also generating an additional unwanted image of the signal.

Cheers,

Steve

Simple FM Receiver with GNU Radio and RTL-SDR

2015-10-04T00:11:00+10:00

Introduction

I recently started playing around with software defined radio using a USB TV tuner dongle utilising the popular RTL2832U chipset. After playing around with software like CubicSDR and gqrx I was somewhat frustrated at the opaqueness of what is going on under the hood. As such I resolved to learn GNU Radio so I can do the signal processing myself. Starting with a basic FM receiver seems like a good idea, since one of my goals is to receive NOAA APT transmissions, which are FM modulated at 137 MHz.

## The Radio

The image below is the FM radio (source code) I built in GNU Radio Companion. GNU Radio Companion is part of GNU Radio that makes it pretty easy to graphically put together a custom signal processing chain and "make" a radio in software. I am not usually a big fan of graphical programming, but in this particular instance I have to admit the going was a lot easier than if I had to do this textually. There is built in support for documenting each block, which is nice, though I wish I had more control over the font used and the size of the text boxes.

| | |:--:| | | | FM radio created in GNU Radio Companion. |

It looks more complicated than it is. Basically, the output from the receiver, which is centred around the central frequency, is down-sampled from 2.4 MHz to 500 KHz, then low-pass filtered and then passed to a FM demodulator module. The output of the FM demodulator is then resampled to 48 KHz and piped to an audio sink, i.e. a sound card. All the extra stuff is are GUI controls and visualisations to aid in understanding and debugging. This is what it looks like running, tuned a local station at 99.1 MHz, which is BBC Radio 1. | | |:--:| | | | Radio in operation. Top-left: FFT of the signal from the receiver; Top-right: resampled signal; Bottom: Low-pass filtered signal. |

There is some rudimentary control over GUI position and size, but it is otherwise brutally utilitarian. However the resulting python file can be modified to fine tune appearances and such I believe. Nonetheless, it is very useful for figuring out where you went wrong.

Next Step

The current goal is to make a NOAA APT specific radio and keep trying for a clean image.

Cheers,

Steve

Porting Seeeduino Xadow to Arduino 1.6.3

2015-05-03T21:23:00+10:00

I bought a Seeedstudio Xadow recently, and to get it to work with Arduino 1.6.3 was bit of a pain. Long story short, you can find the necessary files along with pithy instructions at my github repo.

The most crucial difference between the files Seeedstudio supplied and what is needed is that when referencing the core and variant, you must specify the vendor ID, or Arduino 1.6.3 will assume that you have custom source files in the vendor directory. In other words, instead of

Xadow.core=arduino

You must write

Xadow.core=arduino:arduino

This bit of information, along with others, is documented on arduino's github wiki, in particular Referencing another core, variant or tool.

Cheers,
Steve

Producing Technical Drawings In Blender

2014-12-04T15:29:00+11:00

I do all my 3D design in Blender, producing models fit for 3D printing. It isn't as hard as it sounds as long as you keep to the following rules:

Keep consistent scale. For me that means 1 Blender unit = 1 mm
Use boolean operations on meshes, avoid editing meshes directly
This keeps things clean, modular, and most of all, ensures the resulting mesh is manifold, aka. watertight
Use Select Non-Manifold in edit mode to verify the correctness of the mode
Use Recalculate Normals before exporting

Sometimes the model is a prototype, that needs to be manufactured by hand, technical drawings of a model is required, as illustrated by the following screenshot.



Top is the model to be manufactured, bottom is a render of the model from the top in technical drawing style. In yellow are the necessary Free Style settings.

To achieve this look, you need to first set the camera to Orthographic mode, then enable Freestyle rendering in the render tab.



In orthographic mode moving the camera towards or away from the object has no effect on its size. Orthographic Scale is what you need to change to "zoom" in and out.



Freestyle rendering is needed.

Lastly, it is necessary to use a shadeless white material since we don't want lighting of any kind.



A white shadeless material removes the need for lighting, and thus eliminates shading in the resulting render.

Internal Edges

It is possible to make internal edges, such as the edge of a channel, show up in the render. This is done by changing the Visibility setting in the Freestyle Render Layer settings.

When rendering internal edges, sometimes undesirable edges will show up. These can be convinced to go away by experimenting with the Edge Type checkboxes.



QI range allows rendering of internal edges, while Edge Types allows elimination of undesirable internal edges.

Examples

Missing Features

Missing is the ability to add dimensions, that is something I haven't found a nice way of doing in blender, so for now it is added in post using Inkscape, or just by drawing on the printout.

Cheers,
Steve

Further Adventures in Python Optimisation

2014-09-12T15:55:00+10:00

Previously we found that PyPy achieves the best performance gain, executing fieldfunc_py in ~6 us. At the end of that article, I mentioned that the C implementation is up to 50x faster, managing the same calculation in ~0.12 us.

The naive conclusion is that the best thing is to simply call the C function to do the heavy lifting, achieving performance somewhere between PyPy and C. But nothing in life is easy...

Naive C Interfacing

The C code in the previous article was compiled using

gcc -O -shared -o c_fieldfunc.so -fPIC c_fieldfunc.c

The MagnetElement class was then amended to use the C function whenever possible:

class MagnetElement(object):
  def __init__(self, position, size, magnetisation, fieldcalcfunc=fieldfunc_fast_py):
    """ 
    position, and magnetisation are all expected to be numpy arrays of 3
    elements each.

    size is a single number, implying all elements are square
    """

    self.position = position
    self.size = size
    self.magnetisation = magnetisation
    self.moment = magnetisation * size * size * size
    self._fieldcalcfunc = fieldcalcfunc

    try:
      import ctypes
      cmodule = ctypes.cdll.LoadLibrary('c_fieldfunc.so')
      self._fieldcalcfunc = cmodule.fieldfunc
      self.fieldAt = self._cfieldAt
    except OSError, ex: 
      pass

  def _cfieldAt(self, p): 
    import ctypes
    def voidp(x):
      return ctypes.c_void_p(x.ctypes.data)
    field = np.array([0,0,0], np.double)
    self._fieldcalcfunc(voidp(p),
                        voidp(self.position),
                        voidp(self.moment),
                        voidp(field))
    return field

  def fieldAt(self, p): 
    """ 
    p is expected to be a numpy array of 3
    """
    return self._fieldcalcfunc(p, self.position, self.moment)

This however yielded a per-run time of ~28 us!! So clearly there is significant cost in interfacing. The most obvious of these is creating a new np.array each time, and defining and calling voidp.

A Better C Interface

Below is an improved version:

class MagnetElement(object):
  def __init__(self, position, size, magnetisation, fieldcalcfunc=fieldfunc_fast_py):
    """ 
    position, and magnetisation are all expected to be numpy arrays of 3
    elements each.

    size is a single number, implying all elements are square
    """

    self.position = position
    self.size = size
    self.magnetisation = magnetisation
    self.moment = magnetisation * size * size * size
    self._fieldcalcfunc = fieldcalcfunc

    try:
      import ctypes
      cmodule = ctypes.cdll.LoadLibrary('c_fieldfunc.so')
      self._fieldcalcfunc = cmodule.fieldfunc
      self.fieldAt = self._cfieldAt
      self._field = np.array([0,0,0], np.double)

      def voidp(x):
        return ctypes.c_void_p(x.ctypes.data)
      self._position_p = voidp(self.position)
      self._moment_p = voidp(self.moment)
      self._field_p = voidp(self._field)
    except OSError, ex: 
      pass

  def _cfieldAt(self, p): 
    import ctypes
    self._fieldcalcfunc(ctypes.c_void_p(p.ctypes.data),
                        self._position_p,
                        self._moment_p,
                        self._field_p)
    return self._field

  def fieldAt(self, p):
    """
    p is expected to be a numpy array of 3
    """
    return self._fieldcalcfunc(p, self.position, self.moment)

Now we are down to ~7 us, which is about what PyPy gave us. We are still slower, and more effort is involved compared to the installing PyPy + numpy. That said, this method has the advantage that it is compatible with existing Python and numpy installations, and can be used to optimise python code that uses parts of numpy that are not yet implemented in PyPy.

Summary

C interfacing needs to be done carefully to gain maximum benefit
Not quite as easy as using PyPy, but more compatible

Addendum

While we achieved performance similar to PyPy using C interfacing in this one function, PyPy is going to give faster performance across the entire program, while Python+C will only speed up this one function. In my particular case, Python+C is over all ~2x as slow as PyPy.

Cheers,
Steve

Adventures in Python Optimisation

2014-09-12T14:41:00+10:00

Recently I found myself looking at the following piece of code and trying to optimise it:

from __future__ import division

import numpy as np

MagneticPermeability = 4*np.pi*1e-7
MagneticPermeabilityOver4Pi = MagneticPermeability / (4*np.pi)

def fieldfunc_py(p, q, moment):
  r = p - q 
  rmag = np.sqrt(r.dot(r))

  rdash3 = rmag**3
  rdash5 = rmag**5

  rminus5term = r * moment.dot(r) * 3 / rdash5
  rminus3term = moment / rdash3

  field = (rminus5term - rminus3term) * MagneticPermeabilityOver4Pi
  return field

This, I have been told, computes the field at p due to a magnetic di-pole at q.

To profile this code I wrote the following function:

def profile(fieldfunc, dtype=np.double):
  def V(*args):
    return np.array(args, dtype)

  q = V(0, 0, 0)
  moment = V(1, 0, 0)
  p = V(10,10,10)

  def f():
    fieldfunc(p, q, moment)

  # force the JIT or whatever to run
  f()

  from timeit import Timer
  t = Timer(f)
  runs = 100000
  print fieldfunc.__name__,'per run', t.timeit(number=runs)*1e6/runs, 'us'

This yields a per-run time of ~22 us.

Optimise Python/Numpy

The first optimisation then is to write a better optimised version:

def fieldfunc_fast_py(p, q, moment):
  r = p - q
  rmag2 = np.dot(r, r)

  rdash3 = rmag2**1.5
  rdash5 = rmag2**2.5

  rminus5term = r * np.dot(moment, r) * 3 / rdash5
  rminus3term = moment / rdash3

  field = (rminus5term - rminus3term) * MagneticPermeabilityOver4Pi
  return field

The main difference is using np.dot() and avoiding np.sqrt(). Using ** is faster than using square root and multiplication. These changes gets us down to ~18 us or so, so slight improvement.

numba

Numba offers JIT compilation of python into native code, and is pretty easy to use and compatible with numpy. To use it the profile function was called as:

profile(jit(fieldfunc_py))
profile(jit(fieldfunc_fast_py))

Using jit without type arguments causes numba to infer the type. This yields per-run time of ~22 us for fieldfunc_py and ~18 us for fieldfunc_fast_py. There is no noticable speed up, in fact per-run times increased slightly. This is possibly due to the fact that the code is already pretty well optimised, and the extra overhead of interfacing between compiled code and the python runtime.

PyPy

PyPy is an altnerative implementation of Python that also uses JIT, but does it for the entire program. It is a little harder to use because it needs its own version of numpy, which is only partially implemented. For our needs this will suffice.

With PyPy, we see significant improvement. fieldfunc_py's per-run time went down to ~6 us, and fieldfunc_fast_py's per-run time went down to ~6 us also. This is a huge improvement.

Data Type Matters

The diligent reader may have noticed that profile accepts dtype as a keyword arguments. This was used to test the effects of using np.float32 vs np.float64. The following code was written:

for dtype in np.float32, np.float64:
  print 'With', dtype
  profile(fieldfunc_py, dtype)
  profile(fieldfunc_fast_py, dtype)

  try:
    from numba import jit
    print '==> Using numba jit'
    profile(jit(fieldfunc_py))
    profile(jit(fieldfunc_fast_py))
  except:
    pass

This yielded the following output using CPython:

With <type 'numpy.float32'>
fieldfunc_py per run 30.8365797997 us
fieldfunc_fast_py per run 27.7728509903 us
==> Using numba jit
fieldfunc_py per run 22.2719597816 us
fieldfunc_fast_py per run 18.1778311729 us

With <type 'numpy.float64'>
fieldfunc_py per run 21.8909192085 us
fieldfunc_fast_py per run 17.5257897377 us
==> Using numba jit
fieldfunc_py per run 22.4718093872 us
fieldfunc_fast_py per run 18.2463383675 us

Choice of data type has a significant effect, and it counter-intuitive: the larger data type is faster. Interestingly the same isn't true for PyPy, which outputted:

With <type 'numpy.float32'>
fieldfunc_py per run 6.29536867142 us
fieldfunc_fast_py per run 6.067070961 us

With <type 'numpy.float64'>
fieldfunc_py per run 6.28163099289 us
fieldfunc_fast_py per run 6.17563962936 us

Which is essentially the same.

How Fast Can It Be Done?

The final question is, how fast can this be done? Here is a naive C implementation:

#include <math.h>
#include <stdio.h>

typedef double dtype;

dtype vdot(dtype *u, dtype *v) {
  return u[0]*v[0] + u[1]*v[1] + u[2]*v[2];
}

/**
 * Computes w=u+v
 */
void vadd(dtype *u, dtype *v, dtype *w) {
  w[0] = u[0] + v[0];
  w[1] = u[1] + v[1];
  w[2] = u[2] + v[2];
}

/**
 * Computes w=u-v
 */
void vsub(dtype *u, dtype *v, dtype *w) {
  w[0] = u[0] - v[0];
  w[1] = u[1] - v[1];
  w[2] = u[2] - v[2];
}
/**
 * Computes w = x*u, returns w
 */ 
void vmult(dtype x, dtype *u, dtype *w) {
  w[0] = x*u[0];
  w[1] = x*u[1];
  w[2] = x*u[2];
}

#define MagneticPermeability          (4*M_PI*1e-7f)
#define MagneticPermeabilityOver4Pi   (MagneticPermeability/(4*M_PI))

void vprint(dtype *v) {
  printf("(%e, %e, %e)\n", v[0], v[1], v[2]);
}

void fieldfunc(dtype *p, dtype *q, dtype *moment, dtype *out) {
  dtype r[3];
  vsub(p, q, r);
  dtype rmag2 = vdot(r,r);

  dtype rdash3 = pow(rmag2, 1.5);
  dtype rdash5 = pow(rmag2, 2.5);


  dtype t5[3];
  vmult(vdot(moment, r), r, t5);
  vmult(3/rdash5, t5, t5);

  dtype t3[3];
  vmult(1/rdash3, moment, t3);

  vsub(t5, t3, out);
  vmult(MagneticPermeabilityOver4Pi, out, out);
}

int main(int argc, char **argv) {
  dtype q[] = {0, 0, 0};
  dtype p[] = {10, 10, 10};
  dtype moment[] = {1, 0, 0};
  dtype field[3];

  fieldfunc(p, q, moment, field);
  vprint(field);

  int x;
  for (x = 0; x < 1000000; ++x) {
    fieldfunc(p, q, moment, field);
  }

  return 0;
}

timing was done as follows:

$ gcc -o c_bench c_bench.c -lm && time ./c_bench 
(0.000000e+00, 1.924501e-11, 1.924501e-11)

real    0m0.116s
user    0m0.114s
sys     0m0.001s

Because we do 1 million iterations, per-run time is ~0.12 us, or around 50 times faster.

Summary

Most gain/effort comes from using PyPy
In this particular case, numba did not yield signficant speed up
C is still much faster

Cheers,
Steve

Play Child of Light in English on PS Vita

2014-08-30T00:01:00+10:00

If you want to play Child of Light on PS Vita, you will not only need to download the online update, you will also need to set your system language to English (US). If you have it set as English (UK) then you will continue seeing the game in Japanese.

I know right?

From Lyx/Latex to Word

2014-08-26T22:44:00+10:00

This is sort of a placeholder post. Busy meeting a deadline, but this should help future Steve and anyone else when you need to turn your Lyx document into a Word document while keeping the format mostly sane. Broken, but sane.

Export as Latex (plain).
Run
- latex <name of tex file, with or without extension>
Run
- bibtex <filename>
Run
- latex <filename>
Run
- latex <filename>
Try to run
- htlatex <filename> "html,0,charset=utf-8" "" -dhtml/
- html: format to output
- 0: normally chapters go into their own page, putting 0 here forces everything into a single page
- charset=utf-8: let us be civilised
- -dhtml/: puts the output files in a html sub-directory. Note that you can't have a space between -d and the html/
If the above fails with something like 'illegal storage address', and you get a warning about text4ht.env not been found, then you need to find where it is in your TeX installation, and:
- export TEX4HTENV and try again
- Copy text4ht.env into your working directory
- This approach also lets you affect locally some export parameters. More on this later...
Open the html to verify correctness. You might object to the poor graphics quality. In this case copy text4ht.env into the working directory if you haven't done so, and then modify it so it uses a high density when converting images.
See this tex.stackexchange.com answer for more details
- In my case, since dvipng was been used, I replaced all instances of
- -D 96
- with
- -D 300
It also helps if you
strip away html comments
- These look like 
- centre aligned image divs
- remove <hr/> instances
These changes will make the import into Libre/OpenOffice go easier
Open the html file in Libre/OpenOffice
File > Export > ODT
Close html file
Open exported ODT
Edit > Links
Select all links
Break Links
Verify that the ODT file is now much larger!
File > Save As > Word 97 (doc)

Phew! To help future visitors, a simple python script to fix up the html as I have described is included at the end of this post. You will need lxml and cssselector installed. Cheers, Steve

#!/usr/bin/env python

from lxml.html import parse, HtmlComment
from lxml import etree

def main(*args):
  if len(args) == 0:
    return 1

  doc = parse(args[0]).getroot()

  body = doc.cssselect('body')[0]

  # replace <hr/> with <br/> to make doc conversion easier
  for hr in body.cssselect('hr'):
    p = hr.getparent()
    p.remove(hr)

    br = etree.Element('br')
    p.append(br)

  # remove comments because for some reason libreoffice opens up 
  # html comments as document comments, slowing things down
  for node in doc.getiterator():
    if isinstance(node, HtmlComment):
      node.getparent().remove(node)

  # centre align all figures
  for div in doc.cssselect('div.figure'):
    div.attrib['style']='text-align:center'

  print etree.tostring(doc, method='html', encoding='utf-8')
if __name__ == '__main__':
  import sys
  sys.exit(main(*sys.argv[1:]))

Reading Metadata Out of Nikon NIS Elements Generated TIFFs

2014-08-26T22:41:00+10:00

Fluorescence image of
cavitation effects,visualised
using FITC-Dextran.

If, like me, you use Nikon's NIS Elements to do fluorescence imaging, you would have also noticed that nothing other than NIS Elements can read the metadata that is saved with TIFFs. ImageJ can't read it, the GIMP can't read it, tiffinfo can't read it. This means the only way to recover that metadata, which contains important things like exposure time and pixel size is to open the image in NIS Elements.

This sucks, because NIS Elements isn't exactly easily or widely available, and NIS Elements Viewer doesn't help either - it only opens ND3 files.

Fret not, however. The metadata isn't encoded in any particularly nasty way, and with a little exploration I was able to put together a small python script which will dump out all the relevant information.

Hope this helps someone. It would be nice if Nikon used the standard TIFF tags instead of putting everything in their own tags.

Cheers,
Steve

MYOB Not Printing Chinese Characters in Invoices

2013-11-06T12:10:00+11:00

Simply set the language for non-unicode programs to Chinese (PRC) and it will magically work.

N.B. You must have first installed files for East Asia Languages in Languages Tab for this to work.

Cheers,
Steve

Go Away AVN

2013-05-19T23:53:00+10:00

So it turns out that if you google vaccination on google.com.au, Australian Vaccination Network (AVN) comes up as the second result, right after wikipedia.

Search results from google.com.au for
"vaccination" as of 20th of May 2013

As some of you may know, AVN is an anti-vaccination organisation, part of the anti-vaccination movement, whose core beliefs rests on a retracted paper published by a doctor who was struck off the UK medical register after been found guilty of unprofessional and unethical conduct.

Vaccination is a corner stone of public health policy, and the only means of protection for the most vulnerable amongst us who are unable to receive vaccinations. Through vaccination smallpox was eradicated in 1979, and no child was ever again killed or maimed by it.



A child with smallpox

Due to the efforts of groups like the AVN however, there has been recent decline in the number of children receiving vaccinations against common childhood whooping cough, leading an outbreak of whooping cough in Queensland, and sadly, the death of several infants.

While the Australian Government is taken action against the AVN, the fact it has such a prominent position in Google's search results is undermining the overall effort. Thankfully this is something you and I can do something about, and that is what this blog post is for: part of an effort to increase the PageRank of legitimate sources of vaccination like

If you have a blog, make a post like this one, google vaccination on google.com.au and click on every result that is NOT AVN.

Cheers,
Steve

Un/check all items in iTunes 11

2012-12-15T13:35:00+11:00

I subscribe to The Moth, and had previously selected all episodes to be sync'd to my iPhone. Recently I found myself short on space, so I wanted to tell iTunes 11 to stop doing that. Previously, it was a simple case of multiple selection in a list and uncheck, but with iTunes 11, it looked like I was going to have to do it all by hand... for over 200 episodes!

By playing around, I found that if you command-click on a checkbox, it has the effect of un/checking all the checkboxes in the list. This made things more manageable.

Cheers,
Steve

Unknown control sequence \doublespacing

2012-10-16T17:23:00+11:00

If you are getting the error

"Unknown control sequence: \doublespacing" when you try to compile your

beamer presentation in Lyx, change

Document→Settings→Text Layout→Line spacing

to Single.

Cheers,
Steve

Downloads

2012-09-15T14:36:00+10:00

matrixSolver.zip
A matrix solver in C which can handle parametric solutions, i.e. singular matrices.

Notes On Running Calibre On A Server

2012-09-14T09:50:00+10:00

Calibre is a great tool, especially for converting between ebook formats. Here are some notes for getting it to run on a headless server.

The binary installer off the website works fine — ignore warnings about completion and desktop integration failing.
The installer will always pollute /usr/bin regardless of the installation directly you choose.
You will need the following libraries for mobi conversion:
libxi6
libxrandr2
libxfixes3
libxcursor1
If you get this message
SVG rasterizer unavailable, SVG will not be converted
You will need to install xvfb and use xvfb-run, like so:

xvfb-run ebook-convert blah.epub blah.mobi

Cheers,
Steve

Nook vs Kindle

2012-09-14T08:24:00+10:00

Definitely the Kindle. Amazon offers an amazing service, especially their personal document service's email feature. That is simply divine. Furthermore, Amazon isn't nearly so annoying to use as a non-US citizen. I don't have to use a trick credit card or proxies to purchase ebooks. Amazon just sells them to me, easy peasy.

Disclaimer: I have a first generation Nook and a Kindle Touch. My comments above are however entirely based on the services provided, not the devices themselves. So this is probably more appropriate as Barnes and Noble vs Amazon.

Cheers,
Steve

Acorn vs Pixelmator

2012-09-14T08:20:00+10:00

Pixelmator wins hands down. Compared to Pixelmator Acorn is anaemic in terms of features and costs more than twice as much.

Disclosure: I originally got Acorn as part of MacHeist, so I didn't pay full price for it. I did pay full price for Pixelmator.

Cheers,
Steve

Thoughts on The Design of SPOT2 GPS

2012-08-28T08:35:00+10:00

I love the fact the screws holding down the battery cover has little flip up handles so you can turn them with just your fingers, and that they are set so that they don't fall out once loosened. This is top quality design. However, the battery compartment door is not attached to the unit, and it should be, so there is no risk of losing that. Admittedly, it is pretty hard to lose something that is fairly large and orange
Somewhat more importantly, the SOS button should be hooked into the power button, in the sense that if you press and hold the SOS button, it turns the device on and goes into SOS mode. As it is, activating SOS is a 2 step process, requiring you to first turn the device on.

Cheers,
Steve

Jumpcut is dead. Long live Jumpcut

2012-08-23T07:57:00+10:00

I used to use Jumpcut a long time ago, and was a big fan of it. At some point, I think around 10.5, it stopped working, and I let it go -- too busy at the time to poke at it.

Recently however my interest in it was piqued again, and downloaded the 0.63 source. To my great delight, it compiles just fine, and once recompiled, works perfectly. Score one for good programming and open source!

If like me you have given up on Jumpcut, it is time to add this nifty utility back to your toolbox.

Cheers,
Steve

P.S. If you don't have access to Xcode, or the idea of compiling a program sounds like a bit too much, drop me a line at freespace *at* gmail.com and I will make my copy available.

Converting Excel 1.0 Files On OS X (or some other OS)

2012-08-19T01:51:00+10:00

Download SheepShaver
Download "New World PPC ROM" from redundantrobot.com
Extract the zip. This should produce newworld86.rom. Rename this file to ROM and put it in the same directory as SheepShaver.app
At this point SheepShaver.app should run, showing you a folder with a blinking ? inside it
Download "Mac OS 9 Boot Image (120 megs)", again from redundantrobot.com
Unzip the downloaded file. This should produce OS9.img
Access SheepShaver's Preferences, and add OS9.img to Volumes. Hit Save and restart SheepShaver
SheepShaver should now boot into OS9. Ignore the warning about virtual memory
On the desktop, there should be a Unix drive. This is your Mac's system volume. All your files can be accessed through this.
Download Excel for Mac archive from Macintosh Garden
Unzip, this should produce Microsoft Excel folder, inside you will find 5 versions of Excel
Navigate to this folder OS9, and enter Excel 4.0 Folder
Run Excel, and navigate to your Excel 1.0 files.
Open each file, then save it again using Normal Format which is just Excel 3.0. Probably a good idea to add xls to avoid overwriting the original.
Open the converted Excel 3.0 file in modern Excel. Microsoft Excel for Mac 2011 is capable of opening Excel 3.0 files.

At step 14 you might run into a problem I faced: Excel simply won't see any of the Excel 1.0 files! The problem is that Excel is using extended file attributes to determine which files it can open. On less sophisticated systems this is done via file extensions.

To see this, if you copy **COMMANDS** file out of Excel 1.03's sample directory (you have to convert the image first using Disk Utility), and run **xattr** on it, you will see this:

**\$ xattr COMMANDS **

**com.apple.FinderInfo**

Content of **com.apple.FinderInfo** is:

**\$ xattr -px com.apple.FinderInfo COMMANDS**

**58 4C 50 47 58 43 45 4C 01 00 00 00 00 00 00 00**

**00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00**

This is the magic you need. Suppose you had a Excel 1.0 file called **foo**, you add this extended file attribute as follows:

**\$ xattr -wx com.apple.FinderInfo "\$(xattr -px com.apple.FinderInfo COMMANDS)" foo**

After doing this foo should show up in Excel inside ShavedSheep.

If all this sounds like too much for you, send me an email at freespace \_at\_ gmail.com with subject of "Excel 1.0 Conversion". **Update** An alternative to using Sheep Shaver and OS 9 is to use Mini vMac and System 6. This will let you run Excel 1.0. 1. [Download Mini vMac](http://minivmac.sourceforge.net/doc/download.html) 2. Download "Mac Classic ROM" from [redundantrobot.com](http://www.redundantrobot.com/sheepshaver-tutorial/). Extracting the zip produces **vmac.rom** which is incidentally the exact filename Mini vMac expects 3. Follow [these instructions](http://minivmac.sourceforge.net/doc/start.html) to get System 6.0.8 running 4. Drag-n-drop the Excel 1.0 program **img** file (see above) directly into Mini vMac. You will now have access to Excel 1.0 5. To get a read/writable disk, create a **dmg** in Disk Utility. Drag-n-drop this into Mini vMac and you will be asked to initalize and format it. Do so, and then drag-n-drop Excel into this new read-writable disk. 6. Do your conversion, shutdown Mini vMac 7. Open the **dmg**, and it should mount, despite having been initalized and formatted by System 6.0.8 -- backward compatibility for the win

Mini vMac is not as powerful as Sheep Shaver, and System 6.0.8 is as much as it can handle. It is however much smaller and easier to use than Sheep Shaver, and for the purpose of converting Excel 1.0 to a more manageable format is more than sufficient. Note that you might need to do the **xattr** trick above.

Cheers,
Steve

A Layman's Incomplete and Probably Inaccurate Understanding of The GFC

2012-08-15T11:54:00+10:00

Foreword: It has been four years or so since the world went through the throes of financial upheaval known as the Great Financial Crisis. It was a complex event that will not doubt be analysed in depth by experts for years, if not centuries to come, as an example of what could happen. Sometimes we forget that we are still part of a grand experiment, and that nothing like our civilisation has ever existed before. This means that some lessons must be learnt the hard way. The recent LIBOR scandal however would suggests that the financiers are slow learners...
* This is blog posts crystallises my thoughts and understanding of the event, gleaned from various places over the last few years. I make no claims on accuracy or veracity -- it is labelled rant after all.
* Lastly, the terms I use below are only loosely connected to their actual meaning in the finance world. For example I use capital just so I can not use the word "money" so much. They mean the same thing here. And money just means something you can pay your debtors with.

Lets begin with some axioms:

There is a ceiling to the amount of money a bank can loan out
Therefore banks want to... realise the value of their loans as quickly as possible
They are therefore willing to sell some loans at a discount, in order to free up money which they can loan to someone else, so they can make more money
Perception of low interest rate is absolute, no relative. Thus if banks can borrow money at 1%, they can double the interest on their loans, i.e. 2%, and the perception of low interest rate is maintained. Whereas if the inter-bank loan rate was say, 20%, they can hardly add another percent without significantly affecting the number of people taking out loans.
If the profit banks make, derived from the difference between the interest rate at which they borrow money, and the interest rate at which they loan money, is high enough, then it is profitable to take on high risk loans. The increased risk of default is balanced by the greater reward.

Now for the play:

- Easy credit meant more people are eligible to take out loans, most of which were used to buy houses - As a result, housing prices went up, and size of loans increased as a result - Some branches are opportunistic, and under-rated the risk of loan applicants so they can give them loans. - Banks started packaging high risk loans, which they were giving out due to the high profit margin, with low risk loans, and selling the entire package as low risk. - For example, suppose risk is 0..1, where 0 means the loan will definitely be paid back, and 1 means instant default. If one packages nine risk=0.1 loans with a single risk=0.5 loan, then the overall package was being sold with risk=0.14. - This practice inflates enormously the value of high risk loans, at the relatively small expense of low risk loans. - These packages were then further manipulated. e.g. taken apart and with individual loans sold at the risk rating of the overall package. This serves to obscure the high risk nature of some of the loans in the package. - For example, company A sells company B the above loans as a single package with risk=0.14. Company B then splits the package into five smaller portions, each with risk=0.14, and sells it to company C. If company C is lucky, it will be getting a good deal: two risk=0.1 loans instead of two risk=0.14 loans. If company C is unlucky, it will end up holding a risk=0.1 and a risk=0.5 loan. - These manipulation happened many times, to the point no one can be sure any longer of the true value of any individual loan.

Something happened at this point, I am not entirely clear what, but the effect was that financiers realised that some of the loans they hold are not worth what they are paid, so...

- They raised interests rates to compensate for the suddenly higher risk of the loans they are holding, and; - They tried to sell off those loans who providence cannot be verified. - These had the effect of: - Increasing the number of defaults, and thus repossessions. As loan holders sold off houses in an attempt to recoup their costs, over-supply of houses depressed the price of houses, bursting the real estate bubble. - This meant that loan holders could not recoup their costs, and is thus operating at a loss - Devaluing the worth of loans with questionable providence, even if they are in fact low risk, and thus good loans. - This meant that loan holders were "stuck" with their loans - Both of these combined meant that: - Loans were worth a fraction of what they were worth before - Loans could not be converted into liquid capital

This freezing of capital, and the devaluing of assets lead to panic in the financial world:

- Creditors called in their debts, especially from those debtors who specialise in mortages - But as mentioned above, the debtor's can't pay: the loans they have purchased with the money they had borrowed could not be converted back into capital. - As a result, debtors, often large financial institutions, go bankrupt or require injection of capital, i.e. "bail out" - Over all effect: - The collapse of major financial institutions - Erosion of trust in the financial systems - Devaluation of real estate - Increased homelessness as homes are repossessed - Increased unemployment as institutions closed - Slow down in the flow of credit as creditors become more reluctant to give out loans -- once bitten; twice shy. - Extreme devaluation in the assets and worth of investors, from banks to companies

These effects were not just limited to the U.S. The inter-connected nature of modern financial markets meant that banks and institutions all over the world lost billions if not trillions of dollars in worth, and the reduction in available credit pushed up the interests rates.

More importantly, this was not limited to private companies. Many banks are owned nationally, and thus governments around the world suffer in much the same way as private enterprises:

- Large part of their worth disappeared - Higher interests rates - Creditors calling in their debts

Governments also have to contend with:

- Lower tax revenue - Cost of bailouts to maintain social structure

Cheers,
Steve

2012-07-22

2012-07-22T13:09:00+10:00

Over this weekend I have been working on faerii, a USB controlled RGB LED based around the ATtiny85.

Here is a picture of the breadboard prototype



faerii breadboard prototype

The ATtiny85 is mid centre, and immediately above it is the ISP header. To the left of the ISP header, near the centre, is a 4 pin header that provides USB connectivity. Obscuring it is two filter capacitors, pull resistors, and zener diodes. Finally on the far left edge is a common-anode RGB LED.

Here is a video of it in operation:

The project is based around the hid-data example from [vusb](http://www.obdev.at/products/vusb/index.html). The EEPROM contains control blocks, consisting of 4 bytes. The first 3 bytes specify the red, green and blue intensities, in that order. The last byte specifies a duration. Upon reading a control block, the LED transitions, over the specified duration, from its current colour to the new colour. Currently the duration specified in multiples of 20ms.

Lists of control blocks, which I call a control sequence, can be delimited using delimiter blocks. These blocks have a specified duration value of 0xff. When such a block is encountered, the sequence is restarted from the beginning. Multiple sequences can be programmed into EEPROM.

The host software performs the job of programming sequences into EEPROM. It also provides additional commands, such as RESET and GOTO. The latter allows a collection of sequences to be stored in EEPROM, and activated individually. This feature was provided to minimise the amount of EEPROM writes required to change patterns. For example, sequences might be stored for an idle and new mail state. Activation then simply requires sending the correct GOTO command, without rewriting the EEPROM which as a limited write/erase cycle.

Currently a total of 62 control blocks can be stored. This is due to incomplete support for writing to arbitrary EEPROM address, and the fact the first block is reserved. It should be no great difficulty to fix this.

Two major features I have no implemented yet are REVERSE and MODIFY-ON-READ. These are animation options, where REVERSE specifies that upon reaching the end of a sequence, instead of starting again from the beginning, control blocks should be read backwards. MODIFY-ON-READ is more interesting. The intention is that after reading and executing a control block, the block's RGB values should be modified. This allows free-running random colour cycling without explicit programming.

The [firmware and commandline utility source code is hosted at github](https://github.com/freespace/faerii). I will add proper schematics next weekend, though you can probably figure most of it by googling and looking at the photo above.

Cheers,
Steve

Notes on x86 Opcodes

2012-07-21T01:47:00+10:00

Here are some notes I made while trying to understand the opcodes in this fun article on generating small elf binaries. Hopefully they will be of use.

  00000000 B801000000        mov        eax, 1
  00000005 BB2A000000        mov        ebx, 42
  0000000A CD80              int        0x80

In the above snippet:

B8 is the move instruction, in which the destination register is encoded into the opcode itself. The mov instruction is B8+r where r = 0..7, 0 being al/ax/eax depending on the data size.
One might naively expect then that the next opcode to move 42 into ebx would be B9, and one would be wrong. The registers are not numbered alphabetically. The next 2 registers in sequence is cl/cx/ecx for r=1 and dl/dx/edx for r=2, and finally we get to bl/bx/ebx for r=3. This explains why the next mov instruction has value BB.
- Note also the little endian encoding of bytes in the operand.

  00000000 31C0              xor        eax, eax
  00000002 40                inc        eax
  00000003 B32A              mov        bl, 42
  00000005 CD80              int        0x80

In the above snippet:

- 31 encodes xor - C0 is the [MOD-REG-R/M](http://www.c-jump.com/CIS77/CPU/x86/lecture.html#X77_0060_mod_reg_r_m_byte) byte, which has the format: - 0..2: R/M (register or memory, 0..7) - 3..5: REG (register, 0..7) - 6..7: MOD (addressing mode, 0..4) - In this case, we have: - MOD=11 - REG=0 - R/M=0 - Which says: addressing mode is register addressing mode, and the destination and source registers are eax (REG=0) and eax (R/M=0). - 40 is an instruction like B8, where the register to modify is encoded in the opcode itself. - B3 is B0+r with r=3. This is like B8+r except B8+r deals with 16/32bit data while B0+r deals with 8bit data. - Recall again that the bl/bx/ebx is the 4th register, not the second.

Instruction information was sourced from the very useful [X86 Opcode and Instruction Reference](http://ref.x86asm.net/coder32.html).

Cheers,
Steve

GNU readline with System Python (OS X 10.7)

2012-07-21T01:46:00+10:00

By default system python loads "fake" readline (fake because it actually uses libedit) from /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload/readline.so. Even if you install readline (which goes into /Library/Python/2.7/site-packages), it will still load it, even if you fiddle with sys.path.

The one solution I have found, which I am not terribly proud of, is to rename readline.so to readline.so.bak. This forces the GNU readline installed via pip/easy_install to be loaded.

Now I have nice things in the python interpreter again.

Cheers,
Steve

DFT and the Window Spectrum

2012-05-17T12:11:00+10:00

In case I forget again why the window spectrum is computed when doing DFT, the answer is that discretisation leads to aliasing artefacts.

Consider the DFT of a x(t)=1. Its DFT is calculated by calculating the sum sin(2 pi f t)*x(t) and cos(2 pi f t)*x(t) individually, then squaring the resulting sums, add them together, then take the square root. Since x(t) = 1, for any frequency you are essentially summing cos(t) and sin(t), which you expect to be zero, and thus the power spectrum should be 0 for any frequency.

If you actually do this with, you will find that unless the points in time where sampling occurs covers an integer number of wavelengths, and is coherent in phase, i.e. sampling occurs in the same phase of each cycle, you will find that you don't get 0. You might get 0.1, 0.15, 0.09, 0.01, etc, but not 0. This is made more obvious by non-uniformely sampled data, such as those you might get in the real world.

This present a problem: the residue can produces peaks where there would otherwise be none, and this is more pronounced for lower frequency, because their wavelengths are longer and thus less likely to fit perfectly inside the window.

One way of rectifying this issue is to compute a correction coefficient c(f)=1-w(f) where f is the frequency, w(f) the window spectrum. The "corrected" power spectrum can then be calculated as correctp(f) = p(f) * c(f), where p(f) is the power spectrum.

I should add that the above method is not at all mathematical. It is chosen because any correction strategy that involves dividing by w(f) is unstable as sometimes w(f) gets very close to 0. Simply subtracting w(f) from p(f) won't work either because p(f)'s magnitude clearly depends on x(t) whereas w(f) doesn't.

An obvious failure of the above correction is that it doesn't make the residue disappear - it only reduces it. A superior method would correct the DFT for a DC signal so it is 0 everywhere.

Update

The obvious answer is to simply normalise x(t) so the maximum amplitude is 1.0. Then the window power can simply be subtracted. Duh.

Cheers,
Steve

PSA: Using Lyx With Native OS X Spellchecker

2012-04-28T11:48:00+10:00

Lyx 2.0 and onwards on OS X will use spellchecker provided by the OS X. Note however that the language it will use for spellchecking is determined by the document's language setting, not your system language setting.

Furthermore, in version 2.0.3, if you change your document's language setting, you have to close and re-open the document before it takes effect.

Cheers,
Steve

Notes on RF-0417C

2012-04-23T12:13:00+10:00

Some notes on using the popular Bluetooth serial module RF-0417C:

When sending AT commands, do not include \r\n either together or singly.
It appears to be happy to receive 5V inputs to TX.
It is not happy to receive 5V to Vcc.
If you connect a LED, it blinks when unpaired, blinks slightly faster when paired, and becomes solid when a serial connection is established.
It works just fine with the SoftwareSerial library.

Cheers,
Steve

PSA: Replacing the SuperDrive With A Hard Disk

2012-02-12T13:41:00+11:00

Replacing the SuperDrive with a hard disk seems to be a Bad Idea at least in my 13" mid-2010 MBP: my 320GB WD Scorpio Blue took over a minute to copy 60MB. That is so 80s.

Interestingly, when I put the hard drive back to where it belongs, and put a SSD in the slot it vacated, the performance of the hard drive went back up to nominal.

Any one planning to upgrade to a dual SSD+HDD configuration should leave the HDD where it is and replace SuperDrive with the SSD.

Cheers,
Steve

Getting pyglet setup in OS X 10.7.2

2012-01-27T04:58:00+11:00

Create a virtual env and activate it
hg clone https://code.google.com/p/pyglet/
pushd pyglet; python setup.py install
popd
easy_install pyobjc==2.3 # the ==2.3 is required as of 2012-01-27, or pyobjc-core will not install
python -c "import pyglet" # this step should not fail

Cheers,
Steve …

3D Printing with Blender and UP!

2011-12-18T14:48:00+11:00

No intersecting planes! These confuse the software into making voids without making scaffolding
1 unit = 1mm

Cheers,
Steve

Manchester encoding/decoding in LibHiJack

2011-11-15T04:42:00+11:00

The hijack iPhone library implements Manchester encoding for digital communication. Manchester encoding maps 0 to high-low transition, and 1 to low-high transition.

The iPhone library generates the transitions using full or half period of a sine wave, using a full period when a bit run is detected. An example of this is shown below.



Manchester encoding of 0110011101 by libHiJack

Detection of Manchester encoding is relatively simple: first the signal is regenerated into a square wave by setting all values above 0 to 1 and 0 otherwise. The number of samples between transitions (0 to 1 or 1 to 0) is then measured. When this interval is within an acceptable range (as determined by the baud rate) the bit is read simply by taking the value of the regenerated square wave immediately after the transition. This works out nicely because 1 maps to a low-high transition, and the value immediately after transition is 1, while 0 maps to high-low transition, and the value immediately after transition is 0.

The important thing to note is that detection of a bit occurs at the transition from one bit to the next, and the code ignores transitions during a bit period. Specifically a transition must occur between 3/4 and 3/2 bit periods from last bit detection, otherwise it is ignored.

For example the transition between sample 64 and 96 is ignored because it occurs 1/2 a bit period since the last bit detection at sample 64.

Finally, the UART frame used consists of a start bit, eight data bits, one parity bits and one stop bit. Note my example doesn't include the parity bit since I reimplemented the encoding algorithm in python to produce the graph.

Cheers,
Steve

Brendanites of the Brendanverse

2011-08-01T16:29:00+10:00

Of all Brendanites, the worst off are the criminals and other malcontents. Water-boarding is par-for-course as is other cruel and unusual punishments, like electric-clamps-on-nipples and listening to boy bands non-stop. By the O'Neill doctrine, if it worked before then whatever it is is OK now and forever. Amen.

While criminals have it bad in Brendanverse, the entrepreneurs have it easy. Starting business in Brendanverse is simple: find a market and setup shop. No need to worry about established competition, they won't do things like undercut your prices or bad mouth you in front of their customers. No siree, that's not how Brendanverse works.

You see, in Brendanverse a company that owns, say 70% of the market, will do nothing like leverage their market share and resources to drive out, hinder or crush their competitors. In fact, calling them competitors is a misnomer: it implies competition and we can't have that. Companies are more like friends, happily coexisting and sharing their toys, aka customers.

Even more blessed than the entrepreneurs are the Chosen - the Journalists (not the Jews). They have all the right the Government has, including and not limited to reading people's emails and tapping their phones. These are rights that, by the O'Neil Doctrine, the Government owes to journalist, because unlike the Government, a Journalist is the epitome of integrity and honesty. They rise above the law and accountability and other trifling matters like FOI requests.

Whoever they are though, every Brendanite is a completely rational human being unswayed by emotional rhetorics, who gives every opinion their due weight before making a decision.

What a brave new world, with such people in it.

Having had a glimpse of the mind of Brendan O'Neil, I can't help but think he is someone who when confronted with an uncomfortable question latches on to the nearest superficial answer and runs with it.

Some people call him a "passionate defender of free speech" which brings to mind the following quote by Jascha Heifetz:

“No matter what side of an argument you're on, you always find some people on your side that wish you were on the other side.”

I wonder if he supports the right of people to yell fire in theatres...

Cheers,
Steve

git with multiple svn-remotes

2011-05-29T00:15:00+10:00

Use git init to create an empty git repository, then edit .git/config to add the svn remotes:

[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
ignorecase = true
[svn-remote "svn"]
url = file:///home/steve/code/svn-repos/foo
fetch = trunk:refs/remotes/trunk
branches = branches/*:refs/remotes/*
tags = tags/*:refs/remotes/tags/*
[svn-remote "svn-other"]
url = file:///home/steve/tmp/foo-svn-other
fetch = trunk:refs/remotes/svn-other/trunk
branches = branches/*:refs/remotes/svn-other/*
tags = tags/*:refs/remotes/svn-other/tags/*

It is assumed at this point svn-other is simply a copy of svn. They are allowed to diverge later.

Do a git svn fetch -R svn to initialise git svn. To manage commits between the two svn remotes, create local tracking branches of remote branches:

\$ git checkout -b trunk-other remotes/svn-other/trunk

I ended up with something like :

  master
  trunk
* trunk-other
  remotes/svn-other/trunk
  remotes/trunk

You can pull changes from one svn repository then push it to another:

\$ git svn fetch -R svn r1 = 049fed636e283096986e0eefa261be0525d8d7b3 (refs/remotes/trunk) Checked out HEAD: \$ git svn dcommit
Committing to file:///home/steve/tmp/foo-svn-other/trunk ...
A test
Committed r2
A test
r2 = 10613af6701eca4b30a3ff89ab408e38ca157fa0 (refs/remotes/svn-other/trunk)
No changes between current HEAD and refs/remotes/svn-other/trunk
Resetting to the latest refs/remotes/svn-other/trunk

Cheers,
Steve

Find and svn add all untracked files

2011-05-18T08:17:00+10:00

svn st | grep '^?' | sed 's/^[? ]*/"/' | sed 's/\$/"/' | xargs svn add

Cheers,
Steve

How to Leave LAX with a microsim

2011-05-16T06:17:00+10:00

It is possible to leave Australia without an overseas SIM card and
Cheers,
Steve

Firehol and mDNS

2011-05-08T03:05:00+10:00

Here is my firehol.conf that allows multicast mDNS packets through:

# define mdns so we will accept it
server_mdns_ports="udp/5353"
client_mdns_ports="5353"

interface eth+ multi
   policy return
   server mdns accept
   server multicast accept

interface eth+ home src "\${home_ips}"
   server all accept
   client all accept

Initially I had the server mdns accept and server multicast accept inside the home interface, but this didn't work. Firehol's developer, Mr Costa Tsaousis, pointed out that src "\${home_ips}" on home would exclude broadcast packets sent from MAC addresses, thus the second interface definition (multi).

Cheers,
Steve

Success for Science

2011-05-07T12:23:00+10:00

Just finished packaging my engineering thesis project into a more portable format: an altoids tin! I have seen people put some neat stuff inside them, and I am chuffed I managed to as well :) Though I had to cut through the lid for the display. And I only had to use the hacksaw once.

Cheers,
Steve

Improved the DSO Nano Probes

2011-05-06T05:59:00+10:00

Got parts from element14 today: hook probes and right-angle 3.5mm mono plug. Modded my DSO nano probes, replacing the micro-tweezer probes and the connector. Interestingly the factory probed using a stereo connector, but the mono replacement works just as well.

This along with BenF 3.61a firmware upgrade has improved the DSO nano somewhere between 100 to 1000 times.

Cheers,
Steve

My Err99 Resolution

2011-04-23T05:05:00+10:00

Err99 is a somwhat common error encountered by Canon DSLR users. Because it is something of a catch-all error code a variety of causes and resolutions can be found via google. In my case the error was fixed by a firmware upgrade while it was in the hands of Canon camera servicing personnel, so if you find you have exhausted all options, send it back to Canon!

For what it is worth, the Camera already had what I thought was the latest firmware, perhaps I downloaded the wrong version, or Canon worked some additional magic.

Cheers,

Steve

Another Galaxy Down

2011-04-22T14:16:00+10:00

Found NGC 4594, aka the Sombrero Galaxy.

In addition also found what is probably cataracts in my eyes \>.\<

Cheers,

Steve

TIL: const, NSError, NSApplicationsupportDirectory

2011-04-17T15:34:00+10:00

const char *foo; is not the same as char * const foo; The former declares a pointer to constant char, while the latter declares a constant pointer to char.
- [NSError localizedDescription] returns the object for key NSLocalizedDescriptionKey in the error's userInfo dictionary. I always wondered how to set it since there is no setLocalizedDescription:.
On iOS the application's Application Support directory doesn't seem to exist by default, unlike the Documents directory. This has to be created programmatically.

Cheers,
Steve

ICBM: iOS OTA Distribution Webapp

2011-04-15T12:44:00+10:00

Finding myself in the position of needing to distribute several apps OTA and unable to use the more well known OTA services like testflightapp.com due to client concerns, I made my own, ICBM.

ICBM is a small python webapp built using my favourite webapp framework, bottle. You just put your application along with icons and the Info.plist (not the binary one) into a directory, and ICBM will generate the required HTML page and manifest plist.

e.g.

icbm.py
AwesomeApp/
- AwesomeApp.ipa
- Icon.png
- Icon_512.png
- AwesomeApp-Info.plist

More detail over at its github page: https://github.com/freespace/icbm.

Cheers,
Steve

How to Tell if You Will Like Sucker Punch

2011-04-11T15:41:00+10:00

Can you relate to the following image? If so, then yes.

Cheers,
Steve

Broken OS X Installers and How to Fix Them

2011-03-26T14:42:00+11:00

The installers Ralink provides for some of their chipsets, like the RT2770 does something retarded: they attempt to unload a kext in a pre-install script, and when it fails the script fails and the entire install fails.

This means on a new machine, or one that never had the kext installed, you can't install their driver.

Fail.

It used to be that pkg installers were just directories, and fixing something like this is easy: find the offending line and comment it out. But OS X 10.5 onwards introduced flat pkgs. These don't give up their secrets so easily.

An article on cnet tipped me off to pkgutil, a program that is installed by default. It lets you expand a flat pkg into a directory, and more importantly, allows to repackage it as a flat pkg after you have excised the cause of your troubles. This last step is important because a flat pkg when unpacked has a different directory structure to a "normal" pkg and thus can not simply be open'd.

Here is what I did to fix Ralink's installer:

pkgutil --expand installer.pkg ~/Desktop/installer-expanded.pkg
cd ~/Desktop/installer-expanded.pkg/installroot.pkg/Scripts/
vim preinstall #alternatively, for ppl unfamilar with vim:
1. open .
2. right click on preinstall, open in TextEdit.app
comment out the offending line which is trying to remove the kext
save and exit your editor
cd ~/Desktop
pkgutil --flatten installer-expanded.pkg installer.pkg
open ./installer.pkg

Cheers,
Steve

Endianess, Thy art Sneaky

2011-02-25T05:12:00+11:00

I took delivery of my Linksys WUSB600N V2 today and was very excited to get my G4 Mac Mini online. The many online sources suggests all I need to do is change a few values in an Info.plist. However as it turns out, that wasn't enough. In order for me to get it working, I had to change the values, but also write the new values in hexadecimal format. This is because even though 0x0079 translates to 121, that is only true for a little endian system. Likewise, 0x1737 also only translates to 5943 under a small endian system. Since OS X running on PPC is a big endian system, unless you write out the exact byte values using hexadecimal notation it isn't going to work.

So, for the record: Linksys WUSB600N V2 runs just fine on OS X 10.5.8 running on G4. It does 5GHz and successfully authenticates with my airport express, which the Monoprice USB 2.0 Wireless N it replaced didn't.

Cheers,
Steve

Tabbing in Vim With Tab Autocompletion

2011-02-24T13:03:00+11:00

I use vim with a tab autocompletion macro, and sometimes I really do want to insert a tab character and autocompletion gets in the way.

Today I found out that if I hold down shift and hit tab, a tab is inserted and tab autocompletion doesn't get triggered. Prior to this I have been adding a space then hitting tab, which leaves ugly little space-tab sequences in my files.

Hope this helps some one out there.

Cheers,
Steve

iOS Toolbar Pagecurl Icon

2011-01-27T11:30:00+11:00

iOS 4.x's page curl UIBarButtonItem comes in blue, and blue, and blue. If you set a UIToolbar's tintColor, then it disappears for some reason.

So I had to make a replacement. Since I use a lot of icons made and given away by awesome people, I feel it is only fair to contribute my share, small though it maybe.

Released under WTFPL. Though it would be nice to hear from you if you do use it :)

Cheers,
Steve

iPhone 4 layer export script for Gimp

2011-01-27T11:29:00+11:00

I often mockup iPhone interfaces on the Gimp, then exporting each layer for use as backgrounds. For iOS 4 each image needs to be exported twice: one at full resolution with @2x in its filename, and once at half-resolution without the @2x. e.g. nav_bg@2x.png and nav_bg.png.

Exporting layers by hand gets old real quick. Thankfully the Gimp supports scripting in my favourite language: python. Even better, Chris Mohler had already written a script to do something very similar, so all I needed to do was make some simple adjustments:

#!/usr/bin/env python
# -*- coding: <utf-8> -*-
# Author: Chris Mohler <cr33dog@gmail.com>
# Copyright 2009 Chris Mohler
# "Only Visible" and filename formatting introduced by mh
# License: GPL v3+
# Version 0.4
# GIMP plugin to export layers as PNGs
# modified by Shuning Bian 2011

from gimpfu import *
import os, re

gettext.install("gimp20-python", gimp.locale_directory, unicode=True)

def format_filename(layer):
    layername = layer.name.decode('utf-8')
    filename1 = layername + "@2x.png"
    filename2 = layername + ".png"
    return filename1,filename2

def get_layers_to_export(img):
    layers = []
    for layer in img.layers:
        if layer.visible:
            layers.append(layer)
    return layers

def export_layers(img, path):
    dupe = img.duplicate()
    savelayers = get_layers_to_export(dupe)
    for layer in dupe.layers:
        layer.visible = 0 
    for layer in dupe.layers:
        if layer in savelayers:
            layer.visible = 1

            if layer.mask:
                pdb.gimp_layer_remove_mask(layer, 0)

            filename1,filename2 = format_filename(layer)
            fullpath = os.path.join(path, filename1);
            tmp = dupe.duplicate()
            pdb.file_png_save(tmp, tmp.layers[0], fullpath, filename1, 0, 9, 1, 1, 1, 1, 1)

            imgwidth = pdb.gimp_image_width(img)
            imgheight = pdb.gimp_image_height(img)
            pdb.gimp_image_scale_full(tmp, imgwidth/2, imgheight/2, 2)

            fullpath = os.path.join(path, filename2)
            pdb.file_png_save(tmp, tmp.layers[0], fullpath, filename2, 0, 9, 1, 1, 1, 1, 1)

        dupe.remove_layer(layer)


register(
    proc_name=("python-fu-export-layers-iphone4"),
    blurb=("Export visible layers as PNG"),
    help=("Export all visible layers as individual PNG files."),
    author=("Chris Mohler <cr33dog@gmail.com> + sbian"),
    copyright=("Chris Mohler"),
    date=("2009"),
    label=("as _PNG"),
    imagetypes=("*"),
    params=[
        (PF_IMAGE, "img", "Image", None),
        (PF_DIRNAME, "path", "Save PNGs here", os.getcwd()),
           ],
    results=[],
    function=(export_layers), 
    menu=("<Image>/File/E_xport Layers"), 
    domain=("gimp20-python", gimp.locale_directory)
    )

main()

Cheers,
Steve

Socket.IO Framing Protocol

2011-01-22T14:55:00+11:00

Socket.IO is a great library and framework that doesn't seem to have a good description of the protocol available. In interest of helping others when they google "socket.io framing protocol", this post was born.

The description of the framing protocol used by Socket.IO below is taken from ajaxorg's Socket.IO-node fork on github. I have made some changes with regards to the annotations, specifically that they must be terminated by with newline. This description is current for v0.6+.

Socket.IO Framing Protocol

Socket.IO 's framing protocol is on top of the underlying transport. Messages have the following format:

(message type)":"(content length)":"(data)","

Where message type is one of:

0 for forced disconnect - no data is sent, always sent as 0:0:,
1 for messages - see below
2 for heartbeats - data is an integer, e.g. 2:1:0,
3 for session ID handshake - data is a session ID, e.g. 3:3:253,

Messages

If you were familiar with the Socket.IO protocol you will notice there appears to be no way now to specify a message contains JSON data as the new protocol has no counter part to the JSON Frame indicator ~j~. Fear not - the new Socket.IO protocol provides a means for this and many other possible extensions via **annotations** which maybe attachd to messages in a manner reminiscent of HTTP headers.

A Socket.IO message now has the following format: > \[key\[:value\]\["\n"key\[:value\]\]\["\n"key\[:value\]..."\n"\]":"\[message\] In words: annotations are key-value pairs where the value may be omitted. Individual annotations are delimited by newlines, and annotations are separated from the message by another newline. From examining the Socket.IO source, if no annotation is present then there should be no newline, but the colon is still required. A JSON message is sent with a single annotation with key of **j** and no value. Below is an example taken from a debugging session: >

> > 1:128:j > >

> >

> > :{"method":"create_user","params":\[{"password":"jhhgffufuhgv","email":"h@h.com"}\],"id":"83BCA0A8-7F9D-428A-A546-2EFCBDC20AB3"}, > >

Note there is a newline after the **j**. The official Socket.IO client uses an additional annotation: **r** for realm. e.g. >

> > 1:18:r:chat > >

> >

> > :Hello world, > >

Note the newline after **chat.** ** **

Cheers,
Steve

UIGraphicsBeginImageContext on iPhone 4

2011-01-16T10:21:00+11:00

I generate UIImages in some of my iOS applications, and prior to the iPhone 4 they all worked fine. With the introduction of the iPhone 4 and Retina Display, I realised my generated images were blurry even though I am rendering them at twice the resolution.

It turns out this is due to the scale property of my generated UIImages being set to 1. This is mainly due to my use of UIGraphicsBeginImageContext(), which creates a bitmap context that is a) non-opaque and b) scale=1. The fix is quite simple - use UIGraphicsBeginImageContextWithOptions() and specify the scale appropriately.

For images derived from an existing image, e.g. rotating an existing image, it is sufficient to use the scale property of UIImage. For images created "from scratch", I use the following bit of code:

if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)])
{
  UIGraphicsBeginImageContextWithOptions(size, NO, [UIScreen mainScreen].scale);
}
else UIGraphicsBeginImageContext(size);

Cheers, Steve

Pulse-o-matic now on App Store

2010-12-16T00:05:00+11:00

It took a month and a bit, but Pulse-o-matic is finally on the App Store. For my loyal followers (all 3 of you), email me for a promotion code :)

Cheers,
Steve

On Wikileaks and World Stability

2010-12-07T13:54:00+11:00

Since the release of US embassy cables (aka #cablegate), many have accused wikileaks of being irresponsible on the argument that what is revealed will retard progress or even destablise world politics.

However, 15 days after the release of these cables, we have observed no breakdown in negotiations, no cooling of relations, and no increase in aggression, even from those states the world is most weary of - Iran and North Korea.

I see nothing unusual about this.

In my opinion, the documents revealed no real surprises for the states players - in my opinion the diplomatic services of the states involved would have already known or at least suspected the attitudes and opinions contained in cables. I find it unlikely that US diplomats have such distinction and trust amongst their colleagues that they are privy to the confessions to exclusion of all others.

Having said that, cablegate will certainly lead to many more awkward moments across the negotiating table. Will diplomats sabotage negotiations over "blunt assessments" of themselves?

Cheers,
Steve

Thoughts on HTML, computer programs, and programming languages

2010-09-21T01:29:00+10:00

I would like to start this post off by saying that emotionally I agree with the sentiment that HTML is not a programming language. Intellectually, however, my position is that HTML is a programming language.

My argument for HTML as a programming language is very abstract, and to put it simply: programming languages are used to express instructions to the computer on what to do. HTML instructs the computer on how to display content, therefore HTML is a programming language. Against this argument are the following, which can be encountered on any number of programming websites.

The most common argument against HTML being a programming language is that it describes itself as a markup language, as evident by the M in HTML. I find this argument wanting on 2 fronts: a) it implicitly assumes that a markup language can not be a programming language. TEX is a good example of a language which 99% of the time is used for markup, and the other 1% for programming; b) this argument is superficial. It implies if I was to simply rename HTML to HTPL, hypertext programming language, then *poof* now it is a programming language without having changed any of its characteristics. A rose by any other name...

A better argument is that HTML doesn't have control structures, whereas programming languages do. Suppose we accept this argument, which implicitly requires programming languages to support control structures. Consider a strict subset of LOGO, called miniLOGO that contains only the turtle graphics part of LOGO and nothing else - no loops, no conditionals, no control structures. By the definition we have assumed here, miniLOGO isn't a programming language. Now suppose you write a program in miniLOGO to draw "hello world" on the screen, what have you written? I (and most people) say it is a program. This then presents a problem: you should not be able to write a program with a not-programming-language. At least it is a problem for me.

Suppose now you say no, the miniLOGO hello world isn't a program, and you give one of two reasons - that it doesn't contain control structures or that it wasn't written in a programming language. The first reason implicitly defines all programs as those containing control structures. I can not accept this reason because you can make a non-program a program by injecting a control structure with no side effect, and it is no less absurd and no more useful than the accepting HTML as a programming language. Not to mention the millions of introductory programming texts that will need to be rewritten so "hello world" contains an unecessary control structure. (There are those who will then say: there ARE control structures, they are just a few levels of abstractions down. Well there are similar control structures in a browser. We do not worry about the rest of the abstraction stack, only the top of it).

For the second reason, consider what happens if I write the same program in full is-a-programming-language LOGO. Now it is a program by the virtue of having been written in a programming language, which brings us to an uncomfortable place: now we two things which are absolutely identical, but one is a program and one isn't by virtue of their parentage. Accepting this position is no more absurd than accepting that HTML is a programming language.

The final argument I will discuss is that my definition is such a generic definition just about anything is a programming language, therefore that definition is next to useless. This I agree with. However as I have (hopefully) demonstrated, it isn't easy to come up with a definition of what is a programming language (or in fact what is a program) that isn't contradictory or would invalidate millions of simple programs around the world.

I am still giving this issue thought, but until I am a more learned person in CS and possibly philosophy, my choice is between a definition of programming languages with low discriminatory powers, or ones which are fickle and contradictory.

HTML-is-a-programming-language, I choose you!

Cheers,
Steve

Avoiding tag collisions

2010-09-20T14:29:00+10:00

UIViews in UIKit has a tag property which is very handy for marking views then retrieving them later. I am always worried though I will use the same tag for views in the same view hierarchy

Cheers,
Steve

Script to read iPhone stack trace

2010-07-10T11:43:00+10:00

Sometimes my iPhone apps would crash and all I would get is a stack trace even when I run in Debug mode. Using atos wou
Cheers,
Steve

Why Even Techies aren't Immune from the Filter

2010-07-09T10:22:00+10:00

Of late I have seen statements from technologically inclined individuals along the lines of:

I am not worried about the filter. Even if they put it in it will just slow things down a bit but we all know how to get around it.

At first glance this seems reasonable, after all it is true. It however ignores the fact the filter is not just a mechanism for stopping "naughty" content. The government can easily abused the filter and use it monitor attempts to access blocked content. In other words the government will be able to construct a list of "naughty" people.

You might ask

What's the problem with that? Surely having a list of people who attempted to access child porn can only be a good thing

If you are asking this question, then you have been victim to Conroy's propaganda. The filter doesn't block just child pornography, it blocks all refused classification (RC) content. At least it is suppose to. The list of websites to be blocked will not be available for scrutiny. In other words, if the filter were to block content on such controversial topics such as abortion or euthanasia you won't know until you have attempted to access such content. By then it would be too late - the government now knows you tried.

The number of ways such a list of "naughty" people can be abused is beyond counting. Suppose the police needs a few child pornography arrests to look good. They just need to go through the list looking for a few poor souls who stumbled on their internet travels. Bang! A list of people whose privacy will be thoroughly violated as the police fishes through their background looking for dirt. God help them if they have actually broke some trivial law in our complex legal system.

But wait, you say,

Isn't attempting to access refused classification material wrong?

The answer is no, unless it is child pornography. The national classification code allows adult to read, hear, and see what they want:

Classification decisions are to give effect, as far as possible, to the following principles:

(a) adults should be able to read, hear and see what they want;

RC material can not be shown, sold, and possession for the purpose of sale or display is illegal. But to consume it with in the privacy of your own home is no crime [1]. As an adult what you chose to read, hear and see is your own private business.

I am well aware this is a slippery slope argument, however I don't think it is outrageous or preposterous. Governments love to monitor what their citizens do [2], censor what they see, and control what they do. That is almost by definition. To imagine the government to pass up on abusing the filter mechanism is difficult to imagine. It would require integrity on their part, something that has been conspicuously absent thus far.

Hang on, I hear you say,

How does this affect me, who always uses an encrypted connection?

Because my dear Watson, the lack of clear text communication is in itself damning evidence to the government. It shows you are to hiding *something*. In next to no time they will bring out the old fallacy: > If you have done nothing wrong, what have you to hide? Remember that Conroy is so ***incompetent*** he doesn't even know online banking is encrypted. The bottom line is this: don't allow this invasion of our privacy the chance to snowball just because it doesn't inconvenience you (yet). Nib it in the bud. At the next election, vote below the line and vote for the parties against the filter: the Greens \[3\], the Nationals \[4\], and if they make it in time, the Pirate Party Australia \[5\]. Cheers, Steve

\[1\] They did try to make it a crime, but sanity prevailed. http://www.parliament.nsw.gov.au/Prod/parlment/hansart.nsf/V3Key/LA19970515003

\[2\] Just see how much the UK loves their surveillance, despite no evidence it actually lowers crime.

\[3\] Greens might trade a rainforest or two for the filter though

\[4\] Nationals recently passed a motion to block any mandatory Internet filtering

\[5\] PPAU by definition has to block the filter.

Ben NanoNote First Impressions

2010-06-15T07:22:00+10:00

Recently unboxed my Ben NanoNote, and I am impressed. The packaging was top-notch and classy as hell. I would not hesitate to put my name to it.

The NanoNote itself is tiny, and feels fairly solid despite the shiny-appearance which I have come to associate with cheapo devices. It's a nice little package, the only issue being the lack of cover of some sort for the micro-SD card slot, which is odd considering the USB port does.

For those wondering, the keyboard has good tactile feedback, though there is no way you are touch typing on this.

There is a microphone opening and a speaker grill, though I have no at this time exercised any of those functions.

If you are wondering what the Ben NanoNote is, here is a little background:

Ben NanoNote is a \$99 device which runs OpenWRT. In and of itself this is nothing special. What is special is the copyleft hardware - you can download the schematics off qi-hardware. For hardware meddlers like myself, this is a boon: we can do many interesting things when we know exactly what is available to us and how.

The copyleft nature of the NanoNote hardware is that anyone else can build their own 100% compatible NanoNote variant. This allows immediately opens the platform to competition, and it also gives product developers peace-of-mind: you can always make your own Ben NanoNote, even if qi-hardware stops making them.

In many ways, the Ben NanoNote is like the arduino: here is some hardware and schematics along with a software platform/SDK with source. Now go wild.

Cheers,
Steve

Open Letter to Silicon Chip Australia

2010-06-15T06:53:00+10:00

Dear Silicon Chip,

I recently cancelled my print subscription. You are no longer a magazine I wish to support.

Political commentary on topics like the insulation scheme and global warming has no place in an electronics magazine. The editor(s) are using the mailbag section to push their own agendas and opinions on the rest of us. I can no longer tolerate such non-sense, and have no interest in financially supporting a magazine that is so set on disinformation and irrational discourse.

Let me be clear: I am not cancelling my subscription because of the beliefs of the people at SC. I am cancelling because SC is being used as a platform to spread those beliefs. Whether or not SC believes in global warming, or that the government is at fault for the deaths from the insulation scheme, commentary of these issues are best left to newspapers. They have no place in a publication about electronics.

On other thing, the filler article reviewing consumer electronics (e.g. MacBook) is most annoying. It lowers the standard of the magazine. If you really have nothing to write about, go find some interesting arduino variants, like the jeeNode, and review one of those.

You have lost your way SC, and it is a sad thing to have to let you go. Maybe we can get back together again.

Steve

Script to make IPAs for ad-hoc distribution.

2010-06-09T05:22:00+10:00

This script produces an IPA, then verifies to make sure the IPA is actually valid.

PRODUCT_NAME=""
IPA="\${PRODUCT_NAME}.ipa" APP="\$.app"

if [ -z "\${PRODUCT_NAME}" ]; then
echo "PRODUCT_NAME not set";
exit 1;
fi

rm -rf ipa
mkdir -p ipa/Payload &&
cp -R build/Debug-iphoneos/\${APP} ipa/Payload/ && pushd ipa && zip -q --symlinks -r \$ Payload/ &&
mkdir test/ &&
cp \${IPA} test && cd test && unzip -q \$ &&
cd Payload/ &&
codesign --verify --verbose \${APP} &&
popd
open ipa/

Designed to be ran from the command line, but it should be easily made into a build phase.

Cheers,
Steve

2010-06-09

2010-06-09T04:35:00+10:00

PRODUCT_NAME=""
IPA="\${PRODUCT_NAME}.ipa" APP="\$.app"

if [ -z "\${PRODUCT_NAME}" \]; then echo "PRODUCT_NAME not set"; exit 1; fi rm -rf ipa mkdir -p ipa/Payload && cp -R build/Debug-iphoneos/\$ ipa/Payload/ &&
pushd ipa &&
zip -q --symlinks -r \${IPA} Payload/ && mkdir test/ && cp \$ test &&
cd test &&
unzip -q \${IPA} && cd Payload/ && codesign --verify --verbose \$ &&
popd
open ipa/

Cheers,
Steve

Discouraging File Sharers at LANs

2010-05-08T07:58:00+10:00

A friend of mine likes to go to LANs and like to run LANs. He has been complaining for sometime that social gaming no longer occur at LANs and in its place is leeching. Lest you think LANs have somehow turned into 19th century medical clinics, we are talking about leeching of files, which given the kind of people who go to LANs, consists of porn, porn, porn, movie, and porn.

My friend laments that he hasn't found a nice way to deal with file sharers such gamers aren't impacted, since some file sharing is required for games installers, updaters, drivers, etc. Any kind of port blocking, packet inspection, real-life-what-are-you-doing inspection are right out for the reasons of impotency, latency, and privacy.

After some discussion, we came up on the following idea to discourage, not ban, file sharers: limit upload rate of all ports. This won't affect 99.99% of gamers since games use very little bandwidth, and it still lets you download at full speed. This however impacts significantly on file sharers: the theoretical maximum downstream a file sharer can achieve is n-1 * upload_rate, which assumes everyone else is giving him their upstream bandwidth. Make this theoretical maximum low enough, and file sharers are better off using sneaker net.

There is an elegance to this that appeals to me - it exploits the fact gaming prioritise latency over bandwidth, and file sharing bandwidth over latency. It is also resistant to circumvention - because this can be implemented on the data link layer, it isn't something file sharers can get around by changing ports or using encryption.

If you know of any LANs that implement this policy, or run a LAN implementing this policy, I would love to know how well this idea performs in the real world.

Cheers,
Steve

Notes on PHD Guiding

2010-03-26T02:45:00+11:00

Maximum RA guide pulse is 1000ms (1s). If PHD is not locking on to the star and it says "dur=1000" in the status bar, a better polar alignment is required.
RA hysteresis is used in a 2-term weighted moving average:

RA_dist = (1.0 - RA_hysteresis) * RA_dist + RA_hysteresis * last_guide

Cheers,
Steve …

Journey's End

Thoughts on entropy, compression and predictors

Entropy and Prediction

Compression and Predictors

Adventures in Compressed DNG

Rant

Python One-liner for Local QR Code Decoding

PIO and Interrupts

Introduction

PIO program

C Program

Interrupt Setup

PIO Setup

PIO ASM and PlatformIO

Introduction

PIO

PlatformIO

PlatformIO and pioasm

Building pioasm

Estimating a Supernova's Brightness as an Amateur

Introduction

Light Curves

General Approach

Identifying Stars

Measuring Brightness

Deriving Visual Magnitude

Verification

Absolute Magnitude

Type II Classification

On NS*DateFormatters

DIY EQMod Direct USB Cable

Build Log: SCD41 CO2 Sensor

Notes on DietPi

Unexpected Latency in Tinyproxy

Conda and Slow Proxies

Installing python package arcgis in conda on Apple Silicon

Verifying Local iOS Backups

Build Log: ATTiny13 LED Dimmer

Introduction

Build Details

Code and CAD

To Improve

Exif Tag Types

FSCK'ing Veracrypt Volumes on macOS

TigerVNC and Systemd

Using SubShapeBinders and Assembly4

Kopia: Handling Directories That No Longer Exist

Adventures with Astroberry/KStars/Ekos

Astrophotography Notes: ISO, Light Pollution, Histograms

ISO

Light Pollution

GDK/GTK Signal Handling Notes

Verifying GoTo Mount Settings

Goodbye SpiderOak

Quick Survey of Some Lightweight Linux Distributions

Busenlabs Lithium

AntiX 21

bodhi linux HWE 6.0.0

Q4OS Gemini, Trinity

3D Printing at Home

FlashForge Creator Pro

Designs

The Subtle Poison of Religion

How *Not* to Play with Programmable LED Strips

You Need That Resistor

You Want Shorter, Thicker, Wires

T102HAAS.303 Considered Harmful For Linux

T102HAAS.303 Breaks Suspend

Downgrading from T102HAAS.303

Re-enabling Hibernation

Ubuntu 18.04 on Asus Transformer Mini (T102H)

Installation

Xorg Setup

i915

Backlight

Keyboard Backlight Control

Airplane Mode

Power Saving

TODOs:

IPython Notebook on GPS Timing and CDMA

PlatformIO and `pioasm`

Building `pioasm`

How Not to Play with Programmable LED Strips

`T102HAAS.303` Breaks Suspend

Downgrading from `T102HAAS.303`