A small Applescript application (.zip 445KB) to keep track of your car or motorbike usage in a Numbers spreadsheet. It shows a small pop-up to enter date, mileage, fuel and amount paid.

Make engraved music sheets with Lilypond. A typical workflow to create a sheet looks like this:

1. create a textdocument, e.g. myFirstSheet.ly, with texteditor;
2. run Lilypond
3. check the Postscript and, if any, Midi files
4. if not ok, edit the textdocument and go back to step 2.

This shellscript supports the process. It shows a dialog to select the Lilypond source-document and subsequently asks to redo or stop.

The script uses X11 XDialog which was installed using MacPorts.

Btw, you can embed music engravings in Open Office with OOOLilypond.

In mei begonnen met muziek, dat wil zeggen noten leren lezen en blofluit spelen. Te beginnen met De Jonge Blokfluiter van James Arden. Een van de vele pseudoniemen waaronder Theo Ettema z'n lesboeken schreef.

Inmiddels ook met bladmuziek in de weer. Met behulp van LilyPond kunnen nu ook stukjes electronisch worden bewaard en zonodig omgezet naar MIDI.

Bladmuziek:

• Oude Melodie (PDF 80KB)
• Hornpipe (PDF 56KB)
• Sarabande (PDF 67KB)

For the few who consider using a USB Digital Storage Oscilloscope on Mac OS X. The Voltcraft (i.e. Hantek) model 2090 DSO can be used on the Mac in combination with Oleg Khudyakov's HantekDSO (Linux) software.

Syscompdesign has a simple DSO and OSS software that works on OS X. The 2MHz bandwith I consider too low for my use though.

In search for other suitable DSO's I found none other. What I did find was the HantekDSO package from Oleg K. This opens up the Hantek (Voltcraft and the like) DSO for use under Linux. In short, I managed to compile HantekDSO under OS X (10.5.7) and tested it with the Hantek 2090 (40Mhz) model.

$ sudo port install kde ## dependency (would kdelibs3 and kdeutils3 suffice?)
$ sudo port install binutils ## due to libbfd dependency

$ sudo tar xvfz HantekDSO-0.5.4.tar.gz
$ cd HantekDSO
$ sudo ./configure \
--prefix=/opt/local/HantekDSO \
--include=/opt/local/include/ \
--with-extra-libs=/opt/local/lib/x86_64 \ ## my libiberty location
--with-qt-includes=/opt/local/include/ \
--with-qt-libraries=/opt/local/lib/ \
--without-arts
...
Warning: you chose to install this package in /opt/local/HantekDSO,
but KDE was found in /opt/local.
For this to work, you will need to tell KDE about the new prefix, by ensuring
that KDEDIRS contains it, e.g. export KDEDIRS=/opt/local/HantekDSO:/opt/local
Then restart KDE.
Good - your configure finished. Start make now

## -I/opt/local/include added to DEFAULT_INCLUDES in dsoextractfw/Makefile.in ## http://avahi.org/ticket/194
## -I/opt/local/include added to DEFAULT_INCLUDES in dsoextractfw/Makefile.in
## dsoextractfw_LDADD = -lbfd -liberty -lintl added to dsoextractfw/Makefile.in
## include <malloc.h> commented out and added
#include <stdlib.h> in dsoextractfw/dsoextractfw.c ## http://developer.apple.com/technotes/tn2002/tn2071.html

$ sudo make
$ sudo make install

Test in X11 terminal:
$ cd /opt/local/HantekDSO/bin
$ ./hantekdso
=> Ok

Optionally generate documentation using (MacPorts) Doxygen:
$ cd /opt/local/HantekDSO/HantekDSO
$ sudo doxygen -g ## generate template configuration file (in Doxyfile)
$ sudo vi Doxyfile
## set projectname and doc options:
EXTRACT_ALL=YES
EXTRACT_PRIVATE=YES
RECURSIVE=YES
INLINE_SOURCES=YES

$ sudo doxygen ## generate documentation (in ./html)
=> Open ./html/index.html in Safari

Extract firmware from the Voltcraft Driver CD:
$ cd /opt/local/HantekDSO/bin
$ sudo cp /Volumes/DSO-2090\ USB/Driver/DSO20901.sys .
$ sudo cp /Volumes/DSO-2090\ USB/Driver/DSO20902.sys .
$ sudo mv DSO20901.sys DSO20901.SYS ## want extractfw zoekt met uppercase extensie
$ sudo mv DSO20902.sys DSO20902.SYS
$ sudo ./dsoextractfw
...

Load firmware using fxload-osx (built with xcode):
$ ./fxload-osx -t fx2 -I DSO2090_firmware.hex -s DSO2090_loader.hex -D 04b4:2090
And, finally, run HantekDSO:
$ ./hantekdso

You can create a shell- or Applescript to load the FW and start HantekDSO.

Now working on a small breakout board for the Nanotec microsteppercontroller. To be used in the RepRap 3D Printer.

For those interested, you can download the Eagle files (.zip 291 KB) The parts-list you can find on Thingiverse.

For the stripboard version: if you don't use stripboard, remove the holes and move all top tracks cq wires to the bottom layer, or ripup and autoroute all over again.

Voor het ontwikkelwerk aan de RepRap printerkop een draaibankje gekocht bij VDH in Utrecht.

Wat handige links:

• Draaisnelheid berekenen
• Metrische schroefdraad afmetingen volgens ISO
• Mini lathe tuning
• Grinding your own lathe tools
• Tool bits
• ISO Passingstelsel

In november I ordered a MakerBot Cupcake printer, to have at least some results with a 3D Printer this year ;-) Last week the package arrived and this week I started assembling the MB body.

My first, modest, steps in modeling the heaterbarrel of my RepRap 3D Printer. Starting with a 2D model. Not taking into account real-life stuff such as convection, radiation and other effects (I am probably not even aware of :-)

First tried to get ElmerFEM to compile on Intel Mac to find out it crashed anyway. Then recently I found FreeFEM++ which is perfectly suited for this purpose.

Before I can add some more sensible comments to this post I have to re-read some old math and physics textbooks first. Partial differential equations, thermal diffusivitiy. All this may take some time ;-)

Todays' update; 3D image (FreeFEM3D icw medit) of the heaterbarrel and NiCr Heater coil model. Now reading my way through the "Finite Element Method" by Michael R.Gosz, ISBN 0-8493-3407-1. An excellent introduction on FEM.

Again the FEM study leads to unexpected interesting stuff, such as Sage, a wonderful Math package. If you want to explore Math and you are not (yet) prepared to buy Maple or Mathematica, start with Sage.

"Exploratory Examples - for Real Analysis", by J.E. Snow and K.E. Weller, ISBN 0-88385-734-0, The Mathematical Association of America

Proof of concept, inspired by S. Baker's excellent simple 3D scanner article.

Hardware

• turntable (geared stepper)
• videocamera (keycam)
• laserpointer and glass rod

Software

• ImageMagick (ffmpeg etc.)
• c-scan
• scan-extract
• MakerScanner (cyclops?)
• Blender
• MeshLab

Workflow

• scan movie
• convert to individual frames
• derive point cloud with scan_extract
• create surface with Blender
• check mesh with MeshLab
• create g-code with Skeinforge
• final 3D Print result

the Finite Element Method, its basis & fundamentals, O.C. Zienkiewicz, R.L. Taylor, J.Z. Zhu, 6th edition ISBN 0-7506-6320-0.

The inputfile for example 2.3 (3KB) and example 2.4 (3KB). A beam subjected to end shear and a circular beam subjected to end shear, respectively.

See the FEAP site for documentation on the Finite Element Analysis Program and the personal version (FEAPpv).

This is my Makefile (1KB) version to compile FEAPpv 2.2. On an Intel Macbook with OS X 10.6 (Leopard) and using the MacPorts gcc package Fortran compiler.

You can use Octave as a Matlab substitute to work out the problems.

In addition you can use Sage to work out the problems. These are my Sage (version 4.6.2) worksheets for the problems in the first chapter: 1.1-1.4, 1.5-1.6, 1.7.

Not all routers support wake-on-LAN from the Internet to LAN. This depends on whether you can configure the ARP cache and send or forward a WOL broadcast package.

To support WOL, in this case on an Apple TimeCapsule, an Arduino Ethernet Pro board is used. Thus having a low-power device (Arduino) listening for WOL.

Both the Arduino board and machine to wake-up are connected via Ethernet to the TimeCapsule. The Arduino is powered using the TimeCapsule USB port.

Here a Perl CGI script is used to first send a WOL packet to the Arduino and then redirect to the domain of the server just woken up. Of course, this assumes the script to be on an other, on-line, server. For other applications, e.g. remote desktop, you can just send the WOL packet from a terminal session.

The following code is run on the Arduino:

/*
* WakeUpCube
*
* 2011-07-28 JvO, New sketch
*
* Reference links:
* http://arduino.cc/en/Reference/ServerConstructor
* http://arduino.cc/forum/index.php?topic=62185.0
*
* Derived from Arduino WakeMyPc
* Ricardo Dias
* http://ricardo-dias.com/
*
* This sketch sends the "magic packet" to wake up
* a PC on Local Area Network [when a push-button
* is pressed.]
*/

#include // needed for Arduino versions later than 0018
#include
#include // UDP library from: bjoern@cs.stanford.edu 12/30/2008

// Arduino configuration
byte arduinoMAC[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // Ethernet shield MAC address
byte arduinoIP[] = { 10, 0, 1, 203 };
byte gatewayIP[] = { 10, 0, 1, 1 };
byte subnetMask[] = { 255, 255, 255, 0 };
unsigned int localPort = 9; // local port to listen on

// the IP broadcast and wake-up target MAC address
byte targetIp[] = { 10, 0, 1, 255 }; // LAN broadcast address 10.0.1.255
int targetPort = 9;
byte targetMAC[] = { 0x00,0x12,0x34,0x56,0x78,0x90 }; // MAC address of the machine to wake-up

// these two variables are set when a packet is received
byte remoteIp[4]; // holds received packet's originating IP
unsigned int remotePort; // holds received packet's originating port

// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; // buffer to hold incoming packet,
char replyBuffer[] = "acknowledged"; // a string to send back

// serial connection speed
const int serialBaudRate = 9600;

// Initialisation
void setup() {

// initialize the ethernet device
Ethernet.begin( arduinoMAC, arduinoIP, gatewayIP, subnetMask );

// initialize server
Udp.begin( localPort );
}

// Main LOOP
void loop() {

delay(1000);

// if there's data available, read a packet
int packetSize = Udp.available(); // note that this includes the UDP header

if(packetSize) {
packetSize = packetSize - 8; // subtract the 8 byte header

// read the packet into packetBufffer and get the senders IP address and Port number
Udp.readPacket( packetBuffer, UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort );

// send the wake-up packet
sendPkt();
}
}

// Send the wake-up on LAN message (aka magic packet)
void sendPkt() {

byte all[102];
int i, c1, j=0;

// the 'magic packet' consists of 6 times 0xFF followed
// by 16 times the hardware address (MAC)
for( i = 0; i < 6; i++, j++ ) {
all[j] = 0xFF;
}

for( i = 0; i < 16; i++ ) {
for( c1 = 0; c1 < 6; c1++, j++ ) {
all[j] = targetMAC[c1];
}
}

Udp.sendPacket( all, 102, targetIp, targetPort );

}

The Perl CGI script to send the WOL package and redirect to the server:

#!/usr/bin/perl

###################################################
# Send Wakeup On LAN broadcast message and redirect
#
# usage: http://yourURL/cgi/wakeup.cgi
# test: http://yourURL/cgi/wakeup.cgi?test=1
#
# 25 july 2011, JvO, New script version 0.1
###################################################

use CGI;
use CGI::Carp qw( fatalsToBrowser ); # pass errors to the browser

use Socket;
use POSIX;

$query = CGI::new();

&getParms; # Get parameters
&sendWOL; # Send Wakeup on LAN
&returnHtml; # Return result page

#
# Set params
#
sub getParms {
$destAddr = "192.168.10.20"; # Destination IP Adres
$destMAC = "de:ad:be:ef:fe:ed"; # Ethernet Pro MAC address
$hostURL = "http://your.url.here"; # the URL to redirect to
$port = 9;

# Remove colons
$destMAC =~ tr/://d;

$test = $query->param("test");
}

#
# Return HTML page
#
sub returnHtml {
# redirect to the Cube
print "Content-type: text/html\n\n";

if ($test) {
print "<html><head><title>Wake on LAN</title></head>\n";
print "<body bgcolor=\"#CCCCCC\">\n";
print "<hr size=5 width=75%><p>\n";
print "<center><h1>Server at IP adres \"$destAddr\" has been sent a wakeup msg</h1></center>\n";
print "<hr size=5 width=75%>\n";
print "</body></html>\n";
}
else {
print "<meta HTTP-EQUIV=\"REFRESH\" content=\"2; url=$hostURL/gallery3\">\n";
print "<html><body>You are being redirected to $hostURL...</body></html>\n";
}
}

sub sendWOL {

# Magic packet is 6 bytes of FF followed by the MAC address 16 times
my $magic = ("\xff" x 6) . (pack('H12', $destMAC) x 16);

# create socket handle and connect
socket($sh, PF_INET, SOCK_DGRAM, getprotobyname('udp')) or die "Socket could not be created. Reason: $!\n";
connect($sh, sockaddr_in($port, inet_aton($destAddr))) or die print $runlog "Socket connect failed: $! host: $destAddr port: $port\n";

# send the wakeup packet
print $sh $magic;

close($sh);
}

The TimeCapsule is set to forward WOL packages, using the Airport configuration program "Advanced" option (sorry for the screenprint being in Dutch):

1) scan all documents
The printed text consisted of A4 pages as well as small (A5) booklets.
The A4 pages were scanned in full, booklets two pages at a time.
Scanner settings: 300 dpi, B/W (1 bit), saved as .tif files with a sequencenumber suffixed filename.

2) process the .tif files in batch with this shell script. Adjust it to your specific needs, e.g. the pixelsize of the scan images.

3) heavily relying on the spellchecker, use OpenOffice to cleanup the raw .txt and save the final text as .odt

Et voila!

Software used
Tesseract 3.00, Macports package
XDialog 2.3.1, idem

Tesseract trained data
Copied to /opt/local/share/tessdata
Dutch
English
Hindi

Sample text (dutch)
The scanned original: (textsnippet taken from this lecture)

Tesseract OCR result:

The final text after editing:

Another find of the FEM study is Octave, a great Math package.

Octave is a reimplementation of part of Matlab developed by Professor John Eaton at the University of Texas, Austin, and later at the University of Wisconsin, Madison.

If you are looking for an Open source alternative to Matlab you should give Octave a try.

You can either install the Macports Octave port or download a ready to run binary from Sourceforge.

The sine 3D example is taken from the network-theory.co.uk GNU Octave Manual. Sine 3D code:


tx = ty = linspace (-8, 8, 41)';
[xx, yy] = meshgrid (tx, ty);
r = sqrt (xx .^ 2 + yy .^ 2) + eps;
tz = sin (r) ./ r;
mesh (tx, ty, tz);