RoutinoFrontend

I’ve just released Routino Frontend to the world wild web. The current code needs manual installation. A proper installer will be created only in case I see there’s some interest in this application.

Routino Frontend will start the GPS subsystem and allow you to get the current GPS location as departure or destination. Additionally, up to three via points are accepted.

To get the coordinates for via or destination points, go to Mappero, point the map to the desired location, press the left uppermost on-screen button, choose »Show Position« and copy it to the device’s clipboard.

After a route is calculated, the resulting file will be placed in the documents folder of the device, ready to be loaded into Mappero or Maep.

The code is in its early stages and needs refactoring. Please note that the current frontend will invoke routino in blocking mode. As soon as you process a route, Routino Frontend will not return before it finished. In case you calculate a long route, this means that Routino will eat all your CPU, memory, swap memory and battery power until it has done its job (which means that you probably need to remove the battery to quit it).

If you are more familiar with Python (and especially its subprocess module) as I am and you can help to add a nice cancel button which reliably kills Routino please drop me a line.

Forest parcel name rendered in osmarender, zoom 17

At crossings of tracks in the woods, you often can find up to four name plates displaying the names of the adjacent wooden parcels. I usually placed a node tagged as place=locality and added the names. Of course this leads to a situation where the names will overlap each other, and after collecting some of those plates, it was desirable to draw the parcels as areas with the name rendered at the center, not as individual nodes at the vertices. I currently add a polygon tagged as landuse=forest.

While Mapnik renders the names of natural and landuse features in zoom levels 14 through 17, Osmarender only rendered them visibly at zoom level 17. It rendered natural names at zoom levels 16 and 15, but subsequently the caption was hidden by the rather huge surrounding wood polygon. landuse was missing in those levels.

I’ve thus adjusted the render rules so the names of natural and landuse features also get displayed at zoom levels 16 and 15. I hope this won’t mess up the map in densely populated areas. If so, please drop me a line and I’ll change the additional k="landuse" v="*" to something like k="landuse" v="forest|wood".

As soon as the changes are slurped by the tiles@home clients, I’ll start to convert the locality-nodes to something like amenity=nameplate or similar to finally clean up the map.

Waypointcatcher on Maemo 5 (aka Fremantle)

As the location API has changed in Fremantle from libgpsbt to liblocation, the previously released version of waypointcatcher won’t do the job on the N900.

I’ve thus updated the python code, which despite its C&P nature just »works for me«. I’ll share the application on request, until I find the time to do the necessary cleanup and to offer a proper point and click installation link.

Its main purpose is to collect waypoints for openstreetmap, as Mapper does not record marks reliably ATM.

Simple Sysexxer receiving data

During the last days and weeks, I missed some minor features in Simple Sysexxer, so guess what I was doing…

The current SVN hosts some minor new features. When loading or receiving data, the annoying dialog to confirm data loss now offers to remember the confirmation. This is not done persistently, but on a per-session basis:

Simple Sysexxer - confirm data loss

When loading a file, the data can now be sent automatically to the device:

Simple Sysexxer - autosend option

The option to request data from a device is now back in all its glory – including some ugly icon :) :

The current code offers to split the loaded data into single SysEx files. This feature mainly is useful for single program banks of the Access Virus C synthesizer. The file names will be built according to the sound’s name, while special characters (like forward slashes, ooops) will be filtered out.

The split files will be altered, so sending them back to the device will load the files into the current edit buffer instead of writing them back to the original destination:

Simple Sysexxer - split file

The code which does the splitting is quite ugly (heck, I just needed the task to be done!). As I deny to do the necessary refactoring, it will be removed before the next release. Use it at your own risk and responsibility. If you brick your Virus, accuse yourself. If you still cannot resist, check out revision 28 from the subversion repository.

Just in case that you wonder what this is all about, here’s the use case. There are tons of soundbanks for the Virus spread all over the web. You can of course load them into the Virus completely, overwriting your RAM banks. But there’s no tool for Linux to audition individual sounds. Thus the splitting option:

• Load the sound bank (either in syx or smf format) in Simple Sysexxer.
• Save the individual sounds into an empty directory.
• Connect the MIDI output of Simple Sysexxer to your MIDI device using aconnect, qjackcontrol or patchage.
• Enable the autosend option.
• Drag and drop individual sound files onto Simple Sysexxer.
• Play the sound.
• Keep or drop the file, using your file manager.

What I really miss for Linux is a universal synth editor and librarian (JSynthLib seems to be rather dead). And yes, I deny to master such a tool as OSS in my spare time :) .

JOSM Logo

I rearranged the presets in JOSM and am prepared for the usual bashing :) .

Tracks and paths have been reunified into one menu entry only, so the convenience menu shortcuts to the various types of tracks and paths are past. OTOH, I have introduced dedicated menu entries for combined foot and cycleways:

JOSM presets - cleanup and additions

The types have been included as popup menus into the dialogs. Besides tracktypes and hiking scales, I also included mountainbike scales, while more special tags for mountain bikers can be used by including an existing set of externally maintained presets:

JOSM - Path Preset

Obviously, the dialogs are completely overcrowded. We will not be able to stuff any and all tags that will develop in the future into JOSM. Be prepared that I will do some major cleanup work some day.

JOSM Logo

JOSM provides the capability to include presets from external sources. It is the perfect mechanism for a group of mappers to maintain a specialized set of presets. This way, »Special Interest« mappers like skiers, mountain bikers or seamen can feed menu entries they need directly into JOSM without polluting the default menu space of JOSM.

Some examples are available via JOSM’s wiki pages. There’s also a page how to create and use such presets.

Consider you have 2,248 files in a directory, each containing one single sound program for your favourite Z1 synth. You need to load them into the synth individually, listen to them and to sort them in directories. Painful it would be.

Fortunately, all sounds are set to one of 18 predefined categories like guitar, synth hard, synth soft, piano, organ and the like. In the SysEx files, the category is coded into the 26. byte. So it was easy to sort the files into subdirectories using a couple of lines of Ruby code (sorry for the misformatting):



#! /usr/bin/ruby

Dir.glob( '*.[Ss][Yy][Xx]' ) do |entry|
determineCategory entry
end



This language seems to be very powerful. Need to do more with it.

Meeting Point Symbol (openclipart.org, public domain)

The XP Days are just a couple of hours ahead. I’m curious what people will attend and expect some illuminative talks. I hope it will be possible to blog directly from the conference, either using the notebook or the N810. I’ve also set up an “extra group” :) in our “company owned” messaging system in advance.

Though it is not for free it was too tempting to attend – it’s just a five minutes walk from our office, so there was no excuse :) .

Simple Sysexxer Icon

The last release of Simple Sysexxer used RtMidi for MIDI input. However, some weird things happend when I tried to receive data from my beloved Korg Z1 synth. Today I have rewritten the MIDI input thread using the ALSA sequencer API.

I hear complaints about the sparse ALSA documentation every now and then. Most people use Matthias Nagorni’s commented example code. I read the code of other ALSA sequencer clients during the last couple of days, and I got the impression that many coders took advantage of the open source principle. Or the other way around: copy and paste is great ;-) . Anyway, I learned some things about C hacking while writing my own code, and I’m getting better reading other people’s code day by day.

Here are some snippets of the code which “works for me”. I inherit QThread for the MIDI in class. From it’s constructor, I invoke the init method to create the client for the ALSA sequencer (sorry for the formatting, Wordpress doesn’t do better):



void MidiIn::init()
{
sequencerHandle = 0L;
sequencerEvent = 0L;
if ( snd_seq_open( &sequencerHandle, "default", SND_SEQ_OPEN_INPUT, 0 ) < 0 )
{
emit errorMessage ( tr( "Cannot initialize the MIDI subsystem."), tr( "Please ensure ALSA is accessible." ) );
}

if ( snd_seq_create_simple_port( sequencerHandle, APPNAME, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_APPLICATION) < 0 )
{
emit errorMessage ( tr( "Cannot create MIDI port."), tr( "Please ensure ALSA is set up properly." ) );
}
}



The run method gets invoked as soon as the thread gets started. The polling code has been stolen from Matthias' examples. Thanks a bunch :) :



void MidiIn::run()
{
recordMidi = false;
int npfd = snd_seq_poll_descriptors_count(sequencerHandle, POLLIN);
struct pollfd* pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
snd_seq_poll_descriptors(sequencerHandle, pfd, npfd, POLLIN);
while ( true )
{
// Avoid too much CPU load. According to the MIDI baud rate, 4 bytes need at least 1024 microseconds to pass the chord.
usleep( 512 );
if ( poll( pfd, npfd, 100000) > 0 && recordMidi == true )
{
processInput();
}
}
}



Here's the code that does "the actual work". The ALSA sequencer gets passed the client's handle and sequencerEvent, which is a pointer of type snd_seq_event_t. ALSA will set this pointer to the memory address where it buffers the current event. As I'm only interested in SysEx data, I leave the body of the loop in any other case. If it is SysEx data, I copy the actual data over to a QByteArray.

ALSA splits (variable length) SysEx data into chunks of 256 bytes. That's why I check whether the data starts with an 0xF0 and ends with an 0xF7. If so, the package is complete and gets send to the main thread via a signal. Otherwise the loop continues collecting data, informing the main (GUI) thread that a chunk of data arrived. This is needed to inform the user that data still is coming in:



void MidiIn::processInput()
{
do
{
snd_seq_event_input( sequencerHandle, &sequencerEvent );
if ( sequencerEvent->type != SND_SEQ_EVENT_SYSEX )
{
snd_seq_free_event( sequencerEvent );
continue;
}
// Stolen from aseqmm/alsaevent.cpp by Pedro Lopez-Cabanillas
tempBuffer.append( QByteArray( (char *) sequencerEvent->data.ext.ptr, sequencerEvent->data.ext.len ) );

// ALSA splits sysex messages into chunks, currently of 256 max bytes in size
// Therefore the data needs collection before sending it to the master thread
if ( tempBuffer.startsWith( 0xF0 ) && tempBuffer.endsWith( 0xF7 ) )
{
emit eventArrived( tempBuffer );
tempBuffer.clear();
}
else
{
emit chunkArrived();
}
snd_seq_free_event( sequencerEvent );
}
while ( snd_seq_event_input_pending( sequencerHandle, 0 ) > 0 );
}



There are a lot of things that can be improved in this code. Patches are always welcome :) . OTOH it will hopefully give other hackers a good starting point. The code also can be found in SVN. See the files src/MidiIn.h and src/MidiIn.cpp.

Broken Windows

I run a dual boot machine, using both Linux and Windows operating systems. I rarely boot Windows but only use it once a semester or so to try out some application or to compile Gebabbel for my Windows users.

These days I wanted to check out some editors and tools for the Z1. So I was finally back to the infamous world of Windows shareware, freeware and demo software. I immediately felt uncomfortable.

When booting Vista after some time, you will be bothered by almost any bit in your machine that begs for updating it – Vista itself, Adobe Reader, Java, you name it. The best thing is that Vista will deny to shut down or reboot before the updates aren’t installed or “configured” properly. That’s pretty annoying if you need to reboot your machine during some driver installation.

Driver installation? True. I use some USB MIDI devices which are class compliant and therefore run without any special driver on Linux and Mac OS X. Vista searched the Web for a driver but failed miserably. So I had to visit the homepage of the manufacturer and to manually download and install a driver¹. After some further fiddling I noticed that something went wrong and the data received from the synth was garbage. Doh!

It’s great we have the internet, and it’s great to get free updates for your operating system. As a long time Linux user, I’m used to it. But I decide when to do updates. Mac OS X notifies me if updates are available and lets me decide whether to install it now or later. Windows notifies me that the machine needs a reboot – the only option I had was to delay it for a couple of hours.

None of the tools I tried out fulfilled my needs, so I’m now “back home” on my Linux box. There’s nothing wrong with Windows, but for me it’s just not the operating system of choice.

¹ Yeah, that’s how we did it in the last century, in times of Web 1.0

—-

Update:

Today a colleague of mine tested our software in a virtual machine running Vista. While copying an ISO image (remaining time: 13 minutes and 10 seconds) Vista insisted in a reboot in 4 minutes and 19 seconds. The option to postpone the reboot was disabled. The only way to avoid the reboot was to kill windows update via the task manager:

Vista Update