Limina.Log http://log.liminastudio.com Research & Development at Limina.Studio Sat, 05 May 2012 18:56:36 +0000 en hourly 1 http://wordpress.org/?v=3.3.2 How I Got a Tornado App Running on Heroku in 10 Seconds http://log.liminastudio.com/programming/how-i-got-a-tornado-app-running-on-heroku-in-10-seconds http://log.liminastudio.com/programming/how-i-got-a-tornado-app-running-on-heroku-in-10-seconds#comments Thu, 26 Apr 2012 22:34:01 +0000 Tedb0t http://log.liminastudio.com/?p=995 I’d been wanting to try out Heroku and Tornado for a while, so why not try them together?  I found a nice starter repo by Mike Dory, co-author of the O’Reilly Tornado book, so I figured I’d use that.  I forked it and rearranged it a bit, and it worked perfectly!  Here’s what I did:

  1. I’m on a brand new computer, so I had to install some basic stuff first:
    1. Setuptools: 
      sudo curl http://python-distribute.org/distribute_setup.py | sudo python
    2. PIP: 
      sudo curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | sudo python
  2. Get the starter repo.
  3. Make a Heroku account if you don’t have one and set it up.
  4. Make init-project.sh runnable: 
    chmod +x init-project.sh
  5. Run 
    ./init-project.sh
  6. That should be it, and your Heroku app is live!

Let me know if this works for y’all!

]]> http://log.liminastudio.com/programming/how-i-got-a-tornado-app-running-on-heroku-in-10-seconds/feed 0 How to Build clj-processing http://log.liminastudio.com/programming/how-to-build-clj-processing http://log.liminastudio.com/programming/how-to-build-clj-processing#comments Thu, 01 Mar 2012 20:42:45 +0000 Tedb0t http://log.liminastudio.com/?p=991 Recently I wrote up a tutorial on getting started programming Processing sketches in Clojure. The clj-processing bindings require a slightly involved build process, which I’m detailing here.  I have since created a quick-start project that contains the pre-built binary, so unless you want to build a newer version of the processing.core.jar library, you can use that.  So here’s how to build it.

Both are in somewhat early development, so it’s a bit tricky, but here we go.

  1. Get Clooj by downloading the latest “standalone” jar from the downloads page.  That file is the IDE; it doesn’t install, you just double-click on that and it opens the Clooj environment.
  2. Build the clj-processing core.  This is the most complicated part; instructions are for OSX—other OSes have similar commands.
  3. Clone the repo from github.
  4. Find your Processing core.jar and OpenGL jars.  They will be in (Processing Dir)/core.jar and (Processing Dir)/modes/java/libraries/opengl/library.  If you’re on OSX and have Processing in your root Applications folder, (Processing Dir) is this: /Applications/Processing.app/Contents/Resources/Java
  5. From a terminal (on OSX, assuming you have Processing in your Applications folder): 
    export CLASSPATH="/Applications/Processing.app/Contents/Resources/Java:/Applications/Processing.app/Contents/Resources/Java/modes/java/libraries/opengl/library"
  6. From the same terminal, in the clj-processing directory, run 
    ant

    If you don’t have ant, you need to install Java.

  7. This should build the processing.core.jar.  Now open Clooj and make a new project and note where you save it.
  8. Make a lib/ folder in the root of your Clooj project folder.
  9. Copy processing.core.jar and Processing’s core.jar file to your Clooj project lib/ folder.
  10. Restart Clooj.  When it opens again, it should say something like this in the output window: 
    === RESTARTING /Users/daleth/Projects/Clojure/Test REPL ===
Classpath:
/Users/daleth/Projects/Clojure/Test/lib
/Users/daleth/Projects/Clojure/Test/src
/Users/daleth/Projects/Clojure/Test/lib/core.jar
/Users/daleth/Projects/Clojure/Test/lib/processing.core.jar
  11. To get OpenGL functions, we have to take some extra steps. If you don’t need those, you can skip this part.
    1. First, copy the following files from (Processing Dir)/modes/java/libraries/opengl/library/: 
      gluegen-rt.jar
jogl.jar
opengl.jar

      to (Clooj Project)/lib/.

    2. Now, to launch Clooj, you have to use a special command line: 
      java -Djava.library.path=(Processing Dir)/modes/java/libraries/opengl/library/macosx -jar /path/to/clooj-standalone.jar
    3. Note the /macosx on the end of that path—it points to the OS-specific dynamic libraries (.jnilib for OSX) instead of the jars.  This should be changed for your operating system (i.e. windows32 or linux64).
  12. Now you can open one of the examples from the clj-processing repo and hit Command-E to run the whole file.  This should open up an applet window with your Processing sketch running—and the best part is, you can modify the code at any time without restarting the applet!!  Try changing a value in the draw function and hitting Command-Enter, which will only run that function (as opposed to the whole file).  You can also run commands in the REPL and affect the applet—again, all while it’s still running.  Super fun!
]]> http://log.liminastudio.com/programming/how-to-build-clj-processing/feed 0 Getting Started with Clojure & Processing http://log.liminastudio.com/programming/getting-started-with-clojure-processing http://log.liminastudio.com/programming/getting-started-with-clojure-processing#comments Tue, 28 Feb 2012 22:42:38 +0000 Tedb0t http://log.liminastudio.com/?p=978 For the past little while here at the studio, there’s been a lot of buzz and conversation about Clojure, a modern LISP language that runs on the Java Virtual Machine.  It’s a fascinating language that can help anyone learn about functional programming.  There are a variety of interesting resources for learning Clojure, but I find it’s most fun when your code can make something happen on your screen instantly, like Processing does for Java.

As such, my friend Tims Gardner and I were talking about putting together a class on Clojure & Processing using Roland Sadowski’s clj-processing bindings and Arthur Edelstein’s Clooj IDE.  So, to make things as fast and easy as possible for people to get started, I made a Clooj/Processing Starter Project that you can download and start using right away!  Here’s what you need to do.

  1. Clone or Download the Starter Project into a directory of your choice
  2. Download Clooj standalone and run it
  3. In Clooj, do Project > Open… and point at your new CloojProcessingProject folder
  4. Click on one of the example scripts in the src/ directory
  5. Hit Command-E to run it.
  6. Enjoy! Note that you don’t have to close the applet window to change the code—try changing some code in the (draw) function and hit Command-Enter. Voila, the applet reflects your changes without restarting it! (This is buggy in OpenGL at the moment but works well for regular sketches.)
  7. For reference to the names of Processing functions in clj-processing, refer to the core source (for now).
  8. Note that as clj-processing is changed, the library (processing.core.jar) included may not; I’m including it pre-built for ease of use and setup.  I will try to update it as necessary, though!

For OpenGL Support

  1. I made a startClooj.sh script that you need to run instead of just double-clicking on Clooj. Do chmod +x startClooj.sh (if necessary) and then ./startClooj.sh.
    1. Why is this necessary? For whatever reason, to enable OpenGL support, java has to be started with the java.library.path set to the path of Processing’s OGL dynamic libraries. These are different for different operating systems, so I’m not including all of them here. Hence, you’ll need Processing installed.
    2. The script assumes that:
      1. You have Processing installed in /Applications. If you don’t have Processing, download it and put it wherever, and change the startClooj script to point at it.
      2. Clooj is in /Applications and is named clooj-0.2.8-standalone.jar. If not, just change it in the script.

Learning Clojure

Licensing

My understanding is that Processing’s libraries (core.jar, gluegen-rt.jar, jogl.jar and opengl.jar) are licensed under the GNU Lesser General Public License, so I’m including them here for ease of use.

]]> http://log.liminastudio.com/programming/getting-started-with-clojure-processing/feed 2 Kitchen Table Coders in The Atlantic http://log.liminastudio.com/programming/kitchen-table-coders-in-the-atlantic http://log.liminastudio.com/programming/kitchen-table-coders-in-the-atlantic#comments Tue, 28 Feb 2012 20:30:44 +0000 Tedb0t http://log.liminastudio.com/?p=979 My studiomates and I do workshops most weekends on various (sometimes esoteric) coding and hacking subjects, and recently The Atlantic ran a story about us on their blog.

Awesome!  For more information on Kitchen Table Coders, check out our website and our EventBrite page.

]]> http://log.liminastudio.com/programming/kitchen-table-coders-in-the-atlantic/feed 0 Event: First Symposium on Research Art http://log.liminastudio.com/events/event-first-symposium-on-research-art http://log.liminastudio.com/events/event-first-symposium-on-research-art#comments Fri, 10 Feb 2012 04:02:19 +0000 Tedb0t http://log.liminastudio.com/?p=974 The New York Society for Research Art presents a gathering of artists, curators, gallerists and theorists to investigate and debate the role of scientific and technological experiment in contemporary art practice—when is an artwork a science project, and when is a science project an artwork?  Our guest speakers will present a variety of perspectives on the topic, ranging from historical to curatorial to practical to economical.  The talks will be followed by an open panel discussion to address and debate the presented ideas interactively with the audience.

The event is free and open to the public! Register on EventBrite (and please consider a donation!).  Also check out the Facebook Event.

Confirmed speakers include:

  • Georgia Krantz, Education Manager, Guggenheim
  • Kyle McDonald, Artist
  • Luther Davis, Artist
  • Keynote by Ted Hayes and Alex Dodge, Artists

Presenter Biographies:

Georgia Krantz works full-time as the Education Manager for Adult Interpretive Programs at the Guggenheim Museum.  She is an art historian with extensive teaching experience from Ancient to Contemporary Art.  She is Adjunct Professor at the New School as well as ITP, and lectures at the Guggenheim, the Museum of Modern Art and the International Center of Photography.  Over the past few years she has been involved in several outside projects including an NEA-funded educational website for the Rubin Museum of Himalayan Art, and Vital Visionaries, a study by the National Institute on Aging on the value of art for promoting intergenerational communication.  She has an MA in Art History (Northern Renaissance and Baroque Art), and is working on her Ph.D dissertation in Modern Art.

Kyle McDonald works with sounds and codes, exploring translation, contextualization, and similarity. With a background in philosophy and computer science, he strives to integrate intricate processes and structures with accessible, playful realizations that often have a do-it-yourself, open-source aesthetic.

http://kylemcdonald.net/

]]> http://log.liminastudio.com/events/event-first-symposium-on-research-art/feed 0 Welcome Disqus Comments! http://log.liminastudio.com/miscellaneous/welcome-disqus-comments http://log.liminastudio.com/miscellaneous/welcome-disqus-comments#comments Sun, 15 Jan 2012 21:25:34 +0000 Tedb0t http://log.liminastudio.com/?p=970 I just implemented Disqus comments for the entire blog, which should make things a bit nicer, since there’s been a lot of discussion on some posts.  Let me know what you think!

]]> http://log.liminastudio.com/miscellaneous/welcome-disqus-comments/feed 5 Wireless Positioning & Location Awareness: An Overview http://log.liminastudio.com/writing/research/wireless-positioning-location-awareness-an-overview http://log.liminastudio.com/writing/research/wireless-positioning-location-awareness-an-overview#comments Wed, 21 Dec 2011 19:56:50 +0000 Tedb0t http://log.liminastudio.com/?p=965 For one of my major projects I’m tasked with figuring out how we can locate mobile wireless devices within a limited location, and it seems a lot of other people I’ve talked to are in the process of figuring out the same thing, so here’s an overview of what I’ve learned so far.

Wireless Technologies / Protocols

  • WiFi (802.11)
  • XBee/ZigBee (802.15.4)
  • BlueTooth (802.15.1)
  • RFID
    • Near Field Communication (Two-Way RFID)

These are four of the principal wireless technologies in mainstream use today.  The goal is to determine within some degree of accuracy the position in 2 or 3 dimensions of a wireless node.  Most, if not all, of the available approaches utilize the RSSI (Received Signal Strength Indicator) of the target node’s connections to nearby nodes.

If you have fixed routers with known locations, you can use the RSSI values of their connections to the target node to calculate the distances from the fixed nodes to the target node.  However, any RSSI value will be heavily influenced by a number of factors that may be out of your control: interfering structures, interfering people (we are walking bags of water, which readily absorbs 2.4ghz radiation) and other interfering radio signals or noise.

Due to these issues, some smart folks developed a system called RADAR that uses ‘location fingerprinting’ to take a bunch of readings of signal strengths under varying conditions and associate them with known locations.  There are a variety of algorithms to tabulate this information, one of which uses neural networks.

Here is a collection of extremely useful papers and links that describe these various approaches, techniques and technologies:

Resources

]]> http://log.liminastudio.com/writing/research/wireless-positioning-location-awareness-an-overview/feed 2 Using the RN-XV WiFi Module as a Remote Switch http://log.liminastudio.com/itp/physical-computing/using-the-rn-xv-wifi-module-as-a-remote-switch http://log.liminastudio.com/itp/physical-computing/using-the-rn-xv-wifi-module-as-a-remote-switch#comments Wed, 21 Dec 2011 00:40:57 +0000 Tedb0t http://log.liminastudio.com/?p=959 It’s been a struggle, but I finally figured out how to use a Roving Networks RN-XV WiFi module as a remote switch.  It’s not hard now that I know how it works, but figuring out was quite difficult, as the manual is apparently incorrect and the firmware it shipped with was causing problems.  Read on for the solution!

Hardware

Simple! Here’s all you need:

  • An XBee breakout board (so you can plug it into your breadboard)
  • An XBee Explorer (not necessary with ad-hoc mode, but I had one around so this tutorial will use it)
  • 3.3V regulator (ONLY—the module has a 10% tolerance, so anything beyond that will either not work or damage the module).
  • 10µF and 0.1µF capacitors for good measure (clean power is especially important when using radio devices)
  • Power and Ground (Pins 1 and 10, the top and bottom pins on the left side of the module)
  • An LED connected to pin 9.  In practice you’d want to put a current-limiting resistor on it, i.e. 220 ohms, but for a quick test it won’t matter.  The module only drives 8mA on this pin.
  • That’s it!
Setup
Although the module has an ad-hoc setup mode, where it broadcasts its own ad-hoc wifi network that you connect to with your computer, I found it faster to just plug it in directly to my computer using a serial adapter such as the XBee Explorer.  When you connect with ad-hoc mode, you talk to the module over telnet, when you use direct serial, you use a serial terminal such as CoolTerm, which the following instructions will use.
With your module plugged into USB, open up the port in CoolTerm.  You may see some data from the unit or a status message (it’s ok if you don’t).  Type $$$ (without hitting return) to enter command mode.  Now you can setup the module’s wifi settings (hit return after each command):
set wlan phrase <your wpa password>
set wlan ssid <your ssid>
save
reboot

 

The module will power-cycle and the green status LED will start blinking.  After 5-10 seconds it should start blinking more slowly, which indicates that it has successfully connected to your WiFi network.  If your terminal session is still open, you should see a status message that indicates its success and its IP address (which you’ll need soon).
Now we need to update the firmware.  Luckily, they made this extremely easy!  Just do this:
ftp u
And it will take care of the rest—connecting to the Roving Networks FTP server, downloading the newest firmware image and ‘installing’ it.
Once that’s done, you can transfer your module to your breadboard.  The rest of the work happens over telnet, so make sure your computer and module are connecting to the same WiFi network!  When the module is on your board and it’s joined your network, open a shell on your computer and do:
telnet <module's ip address> 2000
You should see a ‘*HELLO*’ message.  Congratulations!  Now you can talk to your breadboarded module from anywhere!  To switch the LED on and off, first set the I/O direction mask:
set sys mask 0x21f2
This adds GPIO (General-Purpose Input/Output) Pin 1 (hex 0×2) to the default mask, setting it as an output.  To switch it high, do:
set sys output 2 2
Similarly, to switch it low:
set sys output 0 2
And that’s it!  You can now, for instance, have a web server connect directly to that port and issue those commands dynamically to control your hardware remotely.  Try hooking up a relay to switch a house light!

References

]]> http://log.liminastudio.com/itp/physical-computing/using-the-rn-xv-wifi-module-as-a-remote-switch/feed 22 Getting Started Developing with the WiMM One http://log.liminastudio.com/programming/getting-started-developing-with-the-wimm-one http://log.liminastudio.com/programming/getting-started-developing-with-the-wimm-one#comments Sat, 17 Dec 2011 00:23:34 +0000 Tedb0t http://log.liminastudio.com/?p=955 We just received a Developer Preview of the new WiMM One wearable touchscreen device, and dove into developing for it.  It runs Android so you have to get the Android SDK set up.  Here are our notes so far.
  1. Install Eclipse.  I had the “Galileo” version which I found out the hard way isn’t supported, so I downloaded the newest as of writing (“Indigo”).
  2. Install the Android SDK.
  3. Install the Android Developer Tools (ADT) plugin for Eclipse.
  4. Download the WiMM Android Add-On (make a free developer account first to get it).
  5. Put the WiMM Add-On folder in the add-ons folder in the Android SDK.
  6. Run the Android SDK Manager from Eclipse > Window.
  7. Select and install Android 2.1 (API 7) and the Android SDK Platform Tools.
  8. Make a WiMM Android Virtual Device with SD card 2 GiB and resolution 160×160.
  9. You can now make new projects that target the WiMM One Add-On.

Building and Running on the Emulator

  1. Open a terminal at [your-android-sdk]/add-ons/addon_wimm_one_7/tools and run ./emu.
  2. Wait for the emulator to boot up (it takes a minute).
  3. Hit “Run” in Eclipse.
    1. If you get an expired certificate error, look here.
  4. If you’re prompted to choose a device, choose the emulator.

Building and Running on the Device

  1. On your WiMM, go to Settings > Advanced and turn on “Allow USB debugging”
  2. Plug in your WiMM.
  3. Open a terminal at addon_wimm_one_7/tools and run ./android update adb.
  4. Go to addon_wimm_one_7/platform-tools and run ./adb kill-server and ./adb start-server.
  5. Now run ./adb devices and you should see your hardware device listed as well as any running emulators.
  6. Now when you run your app from Eclipse, you can choose your hardware device!
]]> http://log.liminastudio.com/programming/getting-started-developing-with-the-wimm-one/feed 0 Getting started with the RN-XV WiFi Module & Node.js http://log.liminastudio.com/programming/getting-started-with-the-rn-xv-wifi-module-node-js http://log.liminastudio.com/programming/getting-started-with-the-rn-xv-wifi-module-node-js#comments Thu, 08 Dec 2011 04:08:54 +0000 Tedb0t http://log.liminastudio.com/?p=951 The RN-XV WiFi module is a nifty little WiFi module designed to fit the same pinout as an XBee, so it’s intended to be a drop-in replacement.

Tonight I whipped up a little test of the module to get a joystick to talk to a Node.js server over WiFi.  I attached +3V power and ground to the module (pins 1 and 10, respectively), pin 2 (TX) to Arduino digital pin 0 (RX), and pin 1 (RX) to Arduino digital pin 1 (TX).  That’s all the hardware setup you need.

I used this WiFly library to handle the connection.  All it does is talk to the WiFly module over serial and send control commands, so the library abstracts that a bit.  Here’s the Arduino sketch I built:

And here’s the very basic Node.js server that just prints out the values it receives:

]]> http://log.liminastudio.com/programming/getting-started-with-the-rn-xv-wifi-module-node-js/feed 12