I’m working on a notebook about tides and tidepools with a Spark Core inside to retrieve data about the latest tide levels. It works, hooray! (I say working on because I’m still adding to the notebook, which documents me learning both about tides and about the technical details of getting the wifi and electronics parts working :). There was this rather fun moment when it was finally receiving live tide data when it felt like the book suddenly came alive and became connected to the world – not in the social media, always-connected kind of way, but as though there was a thread tying it to a real thing far away.

Photos below by Jennifer Dick of Nexmap and the 21st Century Notebooking project. More documentation here, with more complete photos.

Here’s what I liked about the Spark Core:

• Really nice and small, fits quite well into a notebook.
• It’s quite fast to get up and running.
• Unlike the Electric Imp, it works with Arduino (in a web IDE), so I could build on what I know, and prototype the electronics part without the Spark Core itself.

Here’s my wish list:

• Right now Spark Core programs won’t run unless it can connect to the network, which means I can’t program in a default behavior for the notebook that runs before it can connect. This made me realize just how automatically I build in a backup behavior into things I make – a lesson learned from having so many demos fail! So it’s a bit frustrating not being able to build this in – but it sounds like they are working on it.
• Some networks just don’t work. I do realize that for something like the notebook that I want to be able to move from place to place, a Bluetooth-tethered-to-phone solution would be better.
• I wish they didn’t pre-solder header pins on! Much easier for paper electronics things, and other types of flexibility.
• After poring over a lot of documentation, it seems like you can use a web call to run functions on the Spark Core, and you can subscribe to events like sensor readings, but you can’t actually have it retrieve data from the web on its own. To update the Tide Book with the latest tide readings, I created a cron job that runs on my server and runs a function on the Spark Core that changes the tide reading, which then controls the number of LEDs that fade in and out like waves. It makes much more sense to me that the microcontroller would be able to make its own requests and pull data rather than push it like this, so I’m not super happy with this solution. I very well may be missing something about the way this device works – especially because I’m not hugely experienced with web programming, and this project involved a lot of cobbling the bits I know together. Update! a helpful engineer at the Spark Core booth at Maker Faire pointed me to TCPClient, which I think is exactly what I needed. Some documentation here. More updates once I try this.

I want a Makey Makey for remote hugs.

I’m using Tom Igoe’s term “remote hugs” for paired devices that communicate a simple message at a distance. Like these adorable lamps, pillows connected to a loved one’s heartbeat, or long-distance electronic scrapbooks. A simple remotely-connected button can be amazingly emotionally expressive when the meaning is personalized by the people who use it. Even more so, I would argue, if people could make these together.

Images: Good Night Lamp (TM)

Images: Telescrapbook

Electronics tools like the Makey Makey or Bare Conductive’s new Touch Board are awesome because you can build them into something right away. You can make something personal before you get bogged down in the technical details – with paint, bananas, walls, cardboard, or your favorite materials. But you can also go deeper into the programming and electronics to make them do new things, because they are open and use a well-known, well-documented programming language.

So here’s the product idea: two Arduino-compatible microcontroller boards that can transmit pin states remotely, for building custom remote-communicating devices. A voltage detected on one pin of one board (or a touch, or even just a high or low) would be sent wirelessly to an output pin on another board anywhere in the world. Transparently, no need to mess around with wireless or web protocols, just choose which two devices to pair and start tinkering right away. But of course, it’s also open and hackable so that you can tweak it for more specific purposes.

The picture above is a (now slightly embarrassing!) prototype I made a while back with help from Hayes Raffle and Tico Ballagas, using a couple of Nokia Internet Tablets. It wasn’t super reliable, and the visual metaphors definitely needed work! But kids definitely had fun with it.

More recently I made a prototype for use with a Makey Makey using an instant messaging protocol. It needs a computer per user, but made me think that Raspberry Pis would be an inexpensive option.

I got excited about the Electric Imp, and spent some time tinkering with two of them with Jie Qi, but got a bit turned off by their proprietary programming language which is a bit hard to wrap your head around. Even once we get it figured out, it won’t be very shareable because it’s another language for people to learn, and it’s tied to the company’s “cloud.” I’m now really hopeful about the Spark Core, we’ll see how those are when they come out.

The hardware and software are really close to being readily available. The idea would still need a web infrastructure to handle the connections and for people to “pair” their devices with each other. Something which I just plain don’t have the bandwidth to build nor maintain, but would LOVE if someone wanted to run with the idea (*hint hint*).

Lots of interesting Internet-Of-Things products coming out, but most of them seem to be about devices talking to apps or devices taking to devices in the same space. I’d love to see devices talking directly to remote devices.

Anyone want to help me make this happen? Or is it out there already?

Spirogator is now online and downloadable.

It’s an application designed as a math, science, and art inquiry activity. You can use it to play with digital “spirograph” patterns, export those patterns, or export and fabricate the gears themselves to make physical patterns on paper.

More here.

Concept: aesthetic investment.
Motivation through making something your own, getting it just right in look and feel. I was thinking about this in the context of feeling increasingly excited about Le Fonduephone after I’d put in some time cleaning the space (the projected environment) and improving the layout and look.
Being able to make something your own in a way that meshes with your value system has big implications for education. This is so obvious and well-established it seems trivial to say, but I think I understand it better. Now to figure out how to explain it…we’ll say this is a placeholder.

Le Fonduephone update: mouse-draggable projected fruit, application written in Processing. These are just photoshopped web images of fruit I used as a test, looks surprisingly nice though. I think it’s the color that works well.

I’m making a fork with IR LEDs for Le Fonduephone, so it can be tracked and used to pick up and move the projected fruit. Press-fit battery holder and conductive paint in laser cut traces techniques from Hannah Perner-Wilson’s Kit of No Parts. So many iterations but I think I’ve figured out a better way in the process. Instead of trying to track three LEDs (to get orientation), easier to place an LED so that it illuminates the tip of the fork. The camera will be quite far from the table and the fork will be tilted, so measuring the relative distances between the three closely-spaced bright LEDs was going to be unreliable.