Geiger Bot is a free iOS appavailable on the App Store
that displays a CPM reading from the clicks/beeps of a Geiger counter's
speaker. It is localized in English, Japanese, German, Russian, and
French. While I had intended to write something like this for quite
some time, the Fukushima nuclear power plant incident motivated me to
release an implementation of it.

Many older Geiger counters lack any sort of indication of relative
radioactivity other than the clicks or perhaps a LED/bulb flashing.
This works well for surveying a moderately radioactive source, but in
order to distinguish objects of low radioactivity (such as bananas) from
background radiation, you must perform an integration count by
counting the clicks over at least a minute of time. This is a very
tedious and error-prone process. Also, the integration accuracy of
analog meters is relatively poor at low counts (ie: the CDV-700).

New2015-10-23 Update

iOS 9.1 broke some standardized Unicode glyphs and replaced them with Emoji glyphs that do not adhere to the Unicode standards. Unfortunately, this non-standards compliance on Apple's part makes Geiger Bot's UI look bad. It will be some time before I can release an update due to a number of changes in the latest frameworks that require me to rewrite a significant amount of code.

As an interim measure for users horrified by the appearance of Apple's new forced retroactive emoji glyphs, the Safecast app can also be used and shares the same codebase as Geiger Bot, but uses less Unicode technical symbols in the UI.

Unfortunately, the font the original Unicode symbols are from (Apple Symbols) is not directly available for use on iOS, so I will likely have to remove the symbols entirely.

I would encourage users unhappy with Apple's changes here to file a bug report at bugreport.apple.com.

New2015-06-17 Update

Good news: The current version of the app still works fine. Bad news: The next one is still a ways off.

A New Geiger Bot Foundation: Analog + Digital Input

I've been working on a new app for Safecast, which will communicate to a Geiger counter over Bluetooth LE. This has introduced additional complexities, such as handling data from multiple kinds of sensors, synchronizing them with GPS locations on the iOS device, storing, and uploading them.

Thus, I've chosen to use very flexible data models that will work with not only BLE devices, but any number of sensors built-in to the iOS device, or analog audio input. I'll be integrating this into Geiger Bot.

The Problem With the Old Geiger Bot

For use cases where you have a Geiger or scintillation counter and don't mind running the app in the foreground, it does fairly well. It is stable and I've ran it for weeks at a time without issue. Not bad for an app that has been continuously updated in someone's spare time since iOS 3.1.1 and is relatively complex.

But it makes a number of assumptions about what kinds of data it's going to get, and how it's going to get them. It's problematic to extend outside of those paradigms, for things such as digital input or different kinds of sensors.

The way the app components work together is also non-ideal. The power and memory use is too high to run as a background app. By fixing this, components can be unloaded to save memory, and when combined with BluetoothLE data can be continuously received without interrupting other tasks or using significant resources.

What This Does For You

1. Keep what you have now
2. Digital input - BLE + others TBD3. Get more than just radiation data4. Add configurations after release with dynamic models that eliminate hardcoding5. Low-power background modes6. Maintainable, codebase that will be shared with other projects via Safecast
7. Open source - you can contribute, or reuse things in your own project

More Info - Preliminary

Hardware Interface

Data arrives from a hardware interface

(eg, CoreAudio for analog audio)

HAL

This data is forwarded to the hardware abstraction layer (HAL), which unifies all data input

Device Model

From the HAL, the data is pushed into raw buffers in the device data model

Processing Graph

Any number of mathematical or meta operation nodes are executed on the raw data

Digital devices are a little trickier than analog in some ways, because they likely all require their own data models and processing graphs to turn raw input buffers into a measurement of some kind, and depending on the MCU + BLE hardware this can vary a lot.

What isn't shown above is that for known BLE device UUIDs, all that will automatically load from an internal database, so there's no configuration required.

For unknown devices, I'll implement the import and export of such profiles, likely in JSON/text format, which can also be edited on-device. I also plan on making a standalone HTML5/JS GUI editor so it will be relatively simple to do this.

Cross-Platform Compatibility

The core data model is written in ANSI C and stores data using a fully normalized, relational database (SQLite) with strong typing. It should be highly cross-platform. The database code will be written in a combination of ANSI C and SQL.

The hardware abstraction layer and individual interface implementations are written in ObjectiveC, as it is necessary to use the iOS frameworks. These will need to be almost entirely reimplemented on other platforms.

The UI components will also thus, by necessity, be written in ObjC. See above note.

Where possible, I will implement data processing code in ANSI C with no platform or weird external dependencies.

*** end of 2015-06-17 update ***

In Development

The next major release will primarily be focused on native / optimized iOS 8 and iPhone 6/6+ support. Significant portions of the codebase are being entirely rewritten to provide cleaner multiplatform support and extensibility.

Already Done

Maps

Significant performance improvements

Improved scaling of GIS raster data.

RGBA tiles (PNG/JPEG)

Can now be rescaled by XBR which is significantly superior for basemaps. XBR is a novel scaling technique especially suited to non-photographic RGB raster data.

Data tiles (Layers)

Correction of scaling spatial error (currently shifted by half a source pixel to the origin)

Use of thresholded Lanczos / bilinear bitmask for shape detection when zooming in. (curves not blocks)

Improved performance for postprocessing and downloading 3rd party basemap tiles.

Audio input status display to simplify device connections, with detection of common misconfigurations and help text.

Automatic configuration for line input Geiger counters

Refactoring of audio DSP code and abstraction to support different types of input (Bluetooth digital data, etc)

Integral webserver with remote access

NewiOS 8 Compatibility

There are no major issues with iOS 8. Expect a later update to provide native support, but there's a good amount of code refactoring I need to do first to cleanly support iOS 6/7/8 and OS X at the same time.

NewOS X App Release

While not Geiger Bot per se, Safecast is available from the Mac App Store and contains the mapping functionality present in Geiger Bot or Safecast for iOS. It does not contain audio DSP (click counting) currently.

The OS X app is also used to generate the Safecast tile map. In fact, that was the reason for its development; a new Safecast web map was needed, and I found I could export a PNG tileset quickly with little code from the iOS app. However, having a couple gigabytes of PNG files on an iPad wasn't directly usable.

Eventually, the full map functionality was ported to a native OS X app to perform this task server-side daily, with a full UI added such that it also works quite well as a GIS content viewing app.

Incidentally, taking code that is highly performant and started life on a humble mobile device, and porting it to a server application ends up working relatively well; the performance is orders of magnitudes faster than other GIS solutions that were tested.

Very Later Development

Open source code release

Mostly depends on getting code cleaned up and refactored such that it can be easily understood, maintained, extended and reused.

Codebase is primarily ANSI C with UI and Apple frameworks in ObjC. Heavy SIMD vectorization with native support for NEON and SSE.

There are few 3rd party frameworks used. Portions of the app in ObjC are being rewritten in ANSI C where possible. ANSI C with no 3rd party framework dependencies is fast and highly portable.

Some of the code has been ported and refactored into open source subprojects

Would you like Geiger Bot available in your native language? If so,
contact me and I will send you a strings file to translate, and
incorporate it into the next version. (note: there may be issues with
right-to-left languages; ie, Hebrew and Arabic, that could cause
delays) I will also credit you on the about screen. Note that some of
the terms are highly technical and there are space considerations in the
UI.

(machine translation has generally produced results worse than keeping it in English)

フィードバックFeedback

私にご質問やご意見をお送りください。私はあなたを助けるために最善を尽くします。

I welcome all feedback. If Geiger Bot is not adapting to your set-up with at least 95% accuracy, please let me know.

(comparison of Iodine-131 dose from Fukushima and US atmospheric nuclear testing. US color legend and dose equivalent units converted to match Japan map. Note I-131 has a half-life of 8 days so this reflects historical exposure in either case. I-131 is generally considered to be the most directly harmful fission product.)

Schematic for using the headset input by Osamu Higuchi. He notes:"- Divide the output voltage (in this case, about 9Vp-p) down to about 0.1V
- Do not decouple the output and iPhone mic input. Let the DC bias on iPhone mic input drop" (more)