volzo

Christopher Getschmann

mostly CC BY

A Simple Approach to Digital Solargraphy

17 Aug 2023

Ultra-long exposure images or Solargraphy are photos that are taken over the span of a few hours, days or weeks or months. Usually, they include the bright arcs the sun takes over the course of at least one sunny day. In the case of analog Solargraphy images, the exposure often lasts from solstice to solstice for half a year, showing all arcs from the lowest to the highest point of the sun in the sky. Doing even a single-day exposure with a digital camera requires some special software and hardware.

I built a dedicated camera for this in the past, made a video about it, and wrote a blog post.


While I am pretty happy about the camera, its image quality and versatility are a bit limited. Framing an image when setting up the camera is cumbersome1 and the sensor module does not output RAW files that are compatible with Adobe Lightroom. A week before I went on vacation recently, I thought about how I could get my trusty mirrorless Sony a6000 to do the same job as the cameras I’ve built before.

Quick recap:

To create a digital Solargraphy image two image sequences are needed:

1: One sequence of correctly exposed images that include metadata (shutterspeed, f-number, ISO)

2: (at least) one sequence of extremely underexposed images that record very little light so that only the sun itself is visible

The main problem:

Remote control via PTP with gphoto2 is really slow. Doing a full cycle, adjusting the shutter speed from 1” to 1/4000 and back to 1” takes 42.16 seconds (on my Sony a6000, other cameras may handle those operations faster). Adding the time for exposing the photo and downloading it you’re way over a minute. But to avoid ending up with a sunstreak that looks like a string of pearls at most every 60s an image needs to be taken and that’s non-negotiable. On top of that there is a bug in the camera firmware (I’ll be nice and assume it’s a bug/an oversight), if you request the built-in exposure meter values, the software always reports 0, so the camera would need to run in manual mode and one would need to roll a DIY auto-exposure algorithm (not a lot of fun).

So, gphoto2 is off the table, sadly. There is an alternative: remote control over wifi. The a6000 features a (very old) barebones Android system that can be launched from the camera menu and executes some Sony apps. There never was a way to use regular Android apps or write your own software, only the so-called PlayMemories store by Sony offered some paid and free Apps (until Sony did shut it down and there was no way to download the apps again you paid good money for)2. One of the apps running on the device (the SmartRemote app) does offer the remote control functionality (for some reason I tried to find out how that actually works and it’s a webserver offering a Rest API using Java Servlets. And that stuff was already horribly old when I enrolled for my first semester…). Anyway, trying to set up a remote control over wifi which is supposed to be reliable and stable over the course of several hours is not something I intend to waste a lot of time with.

So, simple question: What is the least-complicated way of getting things done?

Make the camera switch modes manually. The camera can be configured separately in manual mode and in aperture-priority mode and those configurations are not reset when switching modes. Switching modes, however, can not be done in software. The only way to achieve that is to rotate the mode wheel on top of the camera. So we’ll do exactly that. Mechanically. For each image.

The first prototype was a bit rough, but overall the required hardware and software are surprisingly simple.

A 3d-printed piece of plastic is glued with superglue to the mode wheel on top of the camera.

A 3d-printed “hat” with a tiny hobby servo motor designed for remote-controlled planes is placed on top of it. A microcontroller rotates the mode wheel to the correct position and triggers the shutter via the remote cable.

I cobbled together the hardware and software in a matter of days while planning my vacation and took this photo on Heligoland:

(That’s about 4 hours of a nice sunny evening compressed into a photo)

The first prototype was hand-soldered wire and a 2.5mm audio jack for the trigger cable. It looks pretty rough and there was no way of telling how many exposures were already done.

Afterwards I spent a bit of time creating some “proper” hardware on a printed circuit board, realized it’s slightly more convenient if there is a display, and improved the housing a bit.

Does it work?

Yes. Surprisingly well and all things considered probably the easiest method of taking a “quick” solargraphy image. The downsides:

What do you need if you want to build your own:

Files:

Fusion360/Step CAD files can be in the github repository

EasyEDA files (including BOM) for the PCB can be found at the EasyEDA project page

Fine print:

This post and all images are licensed under CC BY.

You are free to Share — copy and redistribute the material in any medium or format and Adapt — remix, transform, and build upon the material for any purpose, even commercially. But you need to take care of Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.

See the FAQ for more info.

  1. The camera has no display. One needs to turn it on manually and then screw the weatherproof enclosure shut. While the camera can create an ad-hoc wifi network and stream liveview data to a website you can open on your phone, it’s quite a hassle. ↩

  2. Long tangent: Of course, the sensible option would have been to issue a firmware update that bundles all of the few apps that Sony had in this weird app store so anyone would have access indefinitely. No value would have been lost to customers or Sony themselves since they obviously have no intention of charging any money for these apps from now on, but I guess that’s not how the world works for MBAs in a large corporation. Fun fact: Sony is still selling the a6000, but obviously now as a product that loses and not gains features over time. Anyway, luckily someone reverse-engineered enough of the whole thing and offers a framework for writing your own apps plus a toolchain to upload them: https://github.com/ma1co/OpenMemories-Tweak ↩