Skip navigation

Recently I discovered Geoff Boeing’s amazing OSMnx Python package. It’s an extremely useful tool and very well documented. Geoff used originally used his tool to compare city street grids. I decided to use it to compare college campuses. I started with alma mater.

And our biggest rival.
Texas A&M.png

One really cool feature of OSMnx is you can maintain scale when plotting and saving maps. This makes it really easy to compare the relative sizes of different campuses.
UT A&M.png

But why stop at just two schools? Here are comparisons of all the schools in the ACC, Big 10, Big 12, Pac-12, and SEC.

View post on

And here are all the individual campuses.

View post on

I plan on generating more maps of more schools, but if you want to do it yourself here’s the code I used.

import osmnx as ox, matplotlib.pyplot as plt
from descartes import PolygonPatch
from shapely.geometry import Polygon, MultiPolygon
ox.config(log_console=True, use_cache=True)
import geopandas as gpd

def generate_campus_map(campus_name,result_to_use,background_color,accent_color):
    # get the place shape
    campus = ox.gdf_from_place(campus_name,which_result=result_to_use)
    gdf = ox.project_gdf(campus)

    polygon = campus['geometry'].iloc[0]
    buildings = ox.create_buildings_gdf(polygon)
    buildings_proj = ox.project_gdf(buildings)

    G = ox.graph_from_place(campus_name,which_result=result_to_use,simplify=True,network_type='all', retain_all=True)
    G = ox.project_graph(G)

    west, south, east, north = gdf.unary_union.bounds

    # plot the network, but do not show it or close it yet
    fig, ax = ox.plot_graph(G,show=False, close=False, edge_color=accent_color,node_size=0,edge_linewidth=0.25,fig_height=(north-south)/500)

    # to this matplotlib axis, add the place shape as descartes polygon patches
    for geometry in gdf['geometry'].tolist():
        if isinstance(geometry, (Polygon, MultiPolygon)):
            if isinstance(geometry, Polygon):
                geometry = MultiPolygon([geometry])
            for polygon in geometry:
                patch = PolygonPatch(polygon, fc=background_color, ec=accent_color, linewidth=1, alpha=1, zorder=-2)

    for geometry in buildings_proj['geometry'].tolist():
        if isinstance(geometry, (Polygon, MultiPolygon)):
            if isinstance(geometry, Polygon):
                geometry = MultiPolygon([geometry])
            for polygon in geometry:
                patch = PolygonPatch(polygon, fc=accent_color, ec='none', linewidth=.05, alpha=1, zorder=1)

    ax.set_ylim((south, north))
    ax.set_xlim((west, east))
    plt.savefig(campus_name+'.png',format='png',dpi=300,bbox_inches='tight',pad_inches = 0)

Next month I’m going to lead a studio at TEI12 about how to fabricate electronics using rapid prototyping tools. Our studio isn’t even the coolest one; you can check out the complete program here. This week I’ve been experimenting with different ways to fabricate edge-lit displays. There are excellent tutorials on how to make your own edge-lit displays at Instructables and EMSL, but why do something by hand when you can do it with a laser? After wandering around the parameter space I found that rastering a 0.005″ width outline on 0.125″ thick clear acrylic works pretty well. (The settings for those keeping score at home are 100% power and 68% speed on a 40W Versa Laser.) Here’s an example of my lab’s logo. The light is coupled into the acrylic using cheap optical fiber.

Now one edge-lit display is cool, but more is always better. The optical fiber works well for a single piece, but it doesn’t scale well. If only multiple LEDs came in a cheap, convenient package… Then I remembered that we have a couple LED matrix shields from last semester’s display class floating around the lab. Let’s see what they can do! The acrylic pieces are currently spaced two rows apart to reduce cross talk and make assembly easier, but future iterations could have up to 8 pieces.

It should also be possible to use two 5×7 LED matrices instead of one 8×8 matrix and have 10 pieces for the digits 0-9. Coming soon: Laser-etched, edge-lit numerical displays, the nixie tubes of the 21st century!

Here is my advice to senior design students on how to transform their final projects from functional to amazing.

Good news everyone! The nixies survived the trip to and from Providence, and I met some amazing people. Kipp Bradford and Brian Jepson put together a great event. Johngineer from adafruit was demonstrating his impressive cyclorama and he took some stunning nixie tube pictures.




When he wasn’t teaching kids to solder or playing with his LoL Shields, Jimme P. Rodgers was the only person to actually solve the puzzle without cheating. I had to order a LoL shield once I realized that I don’t cover charlieplexing in the Modern Display Science and Technology labs.

I shared a tabel with Chris Walker from Secret Labs LLC who was showing off the new Netduino. It’s such an amazing, but mysterious little device. Secret Labs definitely earned its name.

“That’s some powerful hardware. How can Netduino be so cheap?”
“I can’t tell you.”
“I noticed you have unused I/O pins. Any plans to use them?”
“Definitely. But I can’t tell you what they’re going to be used for.”

Of course, I had to order one for myself to unlock its secrets. It’s time for the nixies to get a brain transplant. Stay tuned.

I’m going to Providence this weekend to show off Nixie Sudoku at Maker Faire RI. Come and check it out! Let’s hope the tubes make it there in one piece…

Finally a post that isn’t about sudoku.

Generated with Flipbook.

GeekDad is running an awesome competition to see what everybody can make using parts from SparkFun and Ponoko. My Nixie Sudoku uses many parts from SparkFun and a custom case from Ponoko, but unfortunately neither company sells nixie tubes (yet). So I decided to redesign the game using 7-segment LEDs instead. Presenting the 7 SEGDOKU concept.

Just multiply by 9, add 2 potentiometers, 1 keypad, 1 Arduino, and 1  custom case.

And you have a fun, inexpensive, easy to build, easy to program, easy to play game for the whole family! Check out the board, schematic, and case design here.

How can you Arduino drive 81 nixie tubes? It’s easy with open source hardware. I was inspired by two excellent projects: the Arduinix and the Ogilumen Nixie Duo and Nixie Driver kit. I highly recommend both to anybody who wants to start playing with nixie tubes.

The Arduinix

What’s so great about Arduinix? It has a simple, inexpensive 555-based boost converter to generate the high voltage necessary to operate the tubes, and it lets you multiplex the tubes. The power supply is on the right. On the left are four high voltage anode pins and 20 cathode pins connected to two 74141 driver ICs. In between the drive ICs and the power supply are high voltage transistors that enable multiplexing. This configuration allows you to control up to 8 tubes.

Nixie Duo and Driver

What’s so great about the Ogilumen kit? It puts the tubes on top of the drive components, and it lets you cascade multiple drive boards. Each driver board has a shift register that enables the cascading. With a high current power supply, you can control up to 12 tubes.

Nixie Sudoku Driver

I decided to combine my favorite features from these projects and have mutliplexed tubes on top of cascable drive boards. I designed a board that allows you to control 9 tubes multiplexed in a 3×3 configuration. It uses a 555-based boost converter power supply, multiplexing high voltage transistors, shift registers, and of course 74141 driver ICs. Of course I still needed an easy way to control 9 driver boards…

Arduinos Control EVERYTHING

I decided the simplest way to control everything (and get instant blog cred) was to use an Arduino. 9 digital outputs control three banks of shift registers, 5 digital I/Os get information from the keypad, and two analog inputs get information from potentiometer knobs. (I’ll talk more about the control software in a later post.)

Under the case

To increase the mechanical stability, portability, and awesomeness of the project, I ordered a custom case from Ponoko. The case really takes the project to the next level, and it hides all of my crazy wiring. Designing and ordering it was a learning experience, but these days no project is complete until it has a custom case.

And that’s all the hardware you need! Simple really. If anybody is interested in building their own I have some spare development boards around here somewhere…

A new video demonstrating a game of Nixie Sudoku. Narrating videos for the internet is harder than I thought…

Everybody loves nixie tube clocks. But why stop at 4, 6, or 8 tubes? Why not 81 tubes?  Inspired by ArduNIX and ogi lumen I decided to build a nixie tube sudoku game. Gotta love open source hardware.

Displaying the puzzle from Cleve’s Corner.

Recursively solving the Wikipedia example puzzle using a modified version of this code.

All of the design files (schematics, boards, source code, and case design) are available here.

Bookmark and Share