What uses a fire extinguisher, a bike pump, and provides hours of probation, community service, and possibly jail time? If you said an automatic graffiti writer you’re correct! [Olivier van Herpt] calls this little job the Time Writer. We call it defacing property… but tomato, tomahto.

Details are a bit scarce, but you get a fine overview of the system from the video after the break. [Olivier] tagged the post as Arduino; it’s obviously running the dot matrix printer made up of seven solenoid valves on a metal rod. These are fed ink via a tube connected to a fire extinguisher which serves as the reservoir. The bike pump is used to pressurize the enclosure so that a pump isn’t necessary when out and about.

Obviously you shouldn’t try this at home, but let’s talk about possible improvements as an academic exercise. First off the mix of the ink/paint needs to be reigned in to get rid of the dripping. We’d also like to see the inclusion of some proper spray can nozzles to tidy up the results. That, paired with an IMU board should be able to smooth out the printed designs.

This might make an interesting add-on to that rainbow graffiti writer.

[Mikeasaurus] found a way to build his own refillable spraypaint canister. The donor vessel used here is a plastic soda bottle. It’s a great choice since it is engineered to house a pressurized liquid and you can find them for free by intercepting a satisfied soda consumer before they reach the recycling bin.

He repurposed the spray nozzle from a commercial spray paint can. By first releasing all of the pressure from the empty paint he could then use a hack saw to remove the top disk. He used Sugru to attach it to the bottle cap which has a hole drilled in the center to accept the feed straw. We wonder if there wouldn’t be a better way to attach this from the inside of the cap for better resistance to bottle pressure?

The final piece of hardware is a Shrader valve from a bicycle inner tube. This lets you pump up the pressure in the bottle. You’ll need to dilute the paint you use to make it sprayer-friendly. [Mikeasaurus] diluted his six to one which might have been a bit too much judging from the drips seen in the video after the break.

Here’s an art exhibit that does its own painting. The Senseless Drawing Bot (translated) uses the back and forth motion of the wheeled based to get a double-pendulum arm swinging. At the end of the out-of-control appendage, a can of spray paint is let loose. We’re kind of surprised by the results as they don’t look like a machine made them.

The video after the break gives a pretty good synopsis of how the robot performs its duties. The site linked above is a bit difficult to navigate, but if you start digging you’ll find a lot of build information. For instance, it looks like this was prototyped with a small RC car along with sticks of wood as the pendulums.

We can’t help but be reminded of this robot that balances an inverted double pendulum. We wonder if it could be hacked to purposefully draw graffiti that makes a bit more sense than what we see here?

[Thanks Brian via IEEE Spectrum]

[mudlevel] built this rainbow graffiti producing robot for an art exhibit in San Diego. While there are no build details we can easily pick this apart from the pictures. Looks like the brains are an arduino, the drive is a power drill with the trigger removed, and a few other servos for firing the spray cans.  The counter weighted arm for creating the rainbow was a pretty good idea too. Watching this, we had an idea for a super simple purely mechanical way to do this that would be similar to a catapult.  You could use the motion of the trailer to “wind up” the counter balance with a simple ratcheting spool of string attached to the axle. Engage your spray cans and let the balance drop and you’re done.  Pedal on to re-wind the counterbalance for another rainbow.

The txtBomber is a high-tech graffiti printer developed by [Felix Vorreiter]. Details are a bit scarce but the video clip after the break proves that this works quite well. [Felix] admits this is Arduino powered but we’re going to have to guess at the rest of the setup from the pictures. He says there are built-in-pens so we’d bet there’s a felt-tip type of thing going on and those look like seven solenoids that actuate them. He posted a picture of the handle side of the device and we can make out two wheels that are connected to LEGO gears. This tracks movement of the txtBomber across a surface in order to synchronize the printing process. There’s no sign of an LCD so it looks like you have to pre-program the messages before you go out into the field.

This is akin to the Chalkbot, but the messages that leaves wash away with the rain. This one seems like it might get you into some trouble if you get caught leaving permanent tags around the neighborhood.

[Thanks Kermit M]

[Ben's] father was a metalworker and the combination of being around metal fabrication for most of his life and getting a couple of art degrees brought together a satisfying combination of hacking skills. Above you can see a Graffiti Machine that he built, which we’ll look at in-depth after the break.. This isn’t the first CNC machine he’s worked on. [Ben] became interested in rapid prototyping but was put off by the cost of commercial cutters, which led him to build his own CNC plasma cutter.

[Ben's] creation consists of a vertical gantry that houses the motors as well as a carriage for the spray paint ‘rattle can’. He’s using stepper motors and belts to move the carriage and gantry with a controller that he picked up from HobbyCNC. Let’s look at how he put it all together.

This is the can carriage. On the right, above the can, you can see the motor used to start and stop the flow of paint. To the left you can see the timing belt used to move the carriage up and down. Its ends are secured with C-clamps.

[Ben] uses the head of a machine screw to depress the valve of the rattle can.

The top of the gantry houses motors to move the gantry itself as well as the can carriage.

The full gantry is one piece with the can carriage traveling along its length. You can see the timing belt that the gears use to move the can.

The two images above show the belts used to move the gantry along the top and bottom horizontal tracks. A rod travels the length of the gantry, driven by a stepper motor on one end to move the gears of both the top and bottom belts.

This image shows the angle-bracket that is used as a track. This gives the machine horizontal scalability.

This closeup shows a skateboard wheel with a slot cut in it. This keeps the gantry firmly seated in the track as it moves.

[Ben] ties the system together with a Linux box running the Enhanced Machine Controller. He’s hoping to pit man against machine some day in a graffiti showdown. This is a great build [Ben], thanks for sharing the details with us.

[Jon] wanted to have some fun with the Graffiti Research Lab’s LASER Tag. Unfortunately his computer wasn’t quite up for the challenge of detecting the laser pointer with a webcam. Not to be discouraged by this hardware limitation, he purchased a used Wacom tablet and threw together some code to make it work with the GRL display software. Now designs can be scrawled on the pad and the projector displays them with the familiar dripping paint effect.

For those who watched the Tour de France, you may have been pleasantly surprised to see some cool tech. Nike was using a robot to paint pictures on the street in chalk dot matrix style. It was accepted by the general public as new and innovative, as well as generally cool. In the hacker community though, a bit of trouble began to brew. The Chalkbot bears more than a passing resemblance to a project called GraffitiWriter. GraffitiWriter was a bot initially designed to protest the militarization of robotics. As it turns out, one of the early developers of the GraffitiWriter is behind the Chalkbot in a legitimate contract. The trouble doesn’t seem to be one of intellectual property legalities. People are mad at the corporatization of public work. They want kids watching to know that this system was designed by regular people in their spare time at their homes, not by a team of researches in a secret underground Nike laboratory.

The article takes a bit of a turn and talks some about the possibility of projects being taken and used for corporate advertisement. The specific item they are talking about is the Image Fulgurator which secretly projects images on objects in your photographs. You’ll have to go check that one out to see how it works.

Wondering what we did with our web server on a business card project from last week? It’s powering a giant LED graffiti wall. Animations can be user-submitted using the online designer. You can watch a live feed of user animations as well. The online interface runs on the Google App Engine for maximum scalability and resilience.

In today’s How-to we cover all the ins and outs of building your own networked graffiti wall.

Concept overview

Graffiti sequences are designed online with the JavaScript animation designer. Finished sequences are validated and stored in a database; we made database backends for PHP/MYSQL and Google Apps (Python). Sequences are syndicated from a simple datafeed API. Our mini web server retrieves animation sequences from the feed, and caches them on an SD card. Finally, the sequences are displayed on a giant LED matrix.

Large, low resolution displays
Our graffiti display is a 1 meter square, 5×5 matrix of LEDs. It’s inspired by the Daft Punk coffee table sold by Habitat a few years ago. The Daft Punk table spawned many DIY replicas, including this excellent Instructable on building a Daft Punk table. Over time, the trend morphed into several permutations, such as our “Daft Punk table” wall-hanging. Given the range of big, blinking furniture, we sought a better term than “Daft Punk table”. We came up with “large, low resolution display” or LLRD for short (pronounced ‘lard’).

The original Daft Punk table flashed randomly, or in time to music. [Mathieu Roncheau]‘s replica table stored animation sequences in an EEPROM. Our first design took this a step further by storing the animation files on a FAT formatted SD card. Now, we’ve put the designer online so that we can fetch user-submitted animation sequences over the internet.

Online interface
Graffiti animations for the LLRD are created with a simple JavaScript sequence maker. Watch a live feed of user-submitted animations, or try it yourself. The graffiti sequence designer and data backends written, for PHP/MYSQL and Google App Engine, are included in the project archive.

The JavaScript graffiti sequence designer is easy to use:

• Click the boxes to toggle the LEDs shown in each frame of your animation.
• Use the arrow buttons to navigate between frames.
• The backup and restore tools provide an easy way to save your sequence locally in a text file.

“Add text frames” inserts character frames using a bitmaped font. If you hate the default font, just create a new one:

• Click the ‘edit font’ button to load the existing font.
• Make your modifications.
• Click ‘update font’ to replace the default font with the new frames.

The font array is a lookup table of bitmaps for the ASCII characters between space and Z (ASCII characters 32 to 90, ” !”#$%&’()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ”). To add a new font permanently, just paste the updated fontset in the JavaScript code following the ‘font=’ variable. The “font format” option in the backup box will generate variable formatted bitmaps that are ready to paste over the existing font.

When you’ve completed an animation, enter your name in the author box and press submit. The sequence code will be generated and sent to the server.

The online JavaScript-based graffiti designer is inspired by an offline version by [Mathieu Roncheau]. [Mathieu]‘s Delphi source code and executable are archived here. Our JavaScript-based designer has a few extra features, is browser-based, and it doesn’t require you to run an unknown .exe file. Even though it’s intended to run on the web, the designer will also work from a local copy on your computer.

The script will work for any arbitrary matrix, just change the dptRows and dptCols variables to the dimensions of your LLRD.

The live viewer uses asynchronous HTTP (AJAX-ish) requests to show a streaming feed of user-submitted graffiti animations. It will try to set a cookie so that it can start with fresh sequences each time the page loads. If you don’t allow the cookie, it ‘ll just start over at 0 on your next visit.

Sequence bitmap format
The sequence builder outputs each column as an ASCII formatted bitmap. The bitmap for each column is separated by a space, and each full frame is terminated with a line feed (nr). This format was defined by [Mathieu Roncheau]‘s PC sequencer program, we kept it to maintain backwards compatibility.

Bitmap data is zeroed on the upper left hand corner of the frame. The top cells of each column are bit 0, and the bottom cells are bit 4. It seems more logical to follow standard mathematical notation and use the bottom left cell as the origin, but we didn’t design the specification.

The value for each column is found by treating lit LEDs as 1 in a binary number, and converting to decimal. For example, the first column above is 10000 binary, or 1 decimal. The last column is 11111 binary, or decimal 31. You can verify our conversions using an online binary-decimal calculator.

Note that the column bitmaps are represented by ASCII equivalents of the actual decimal values. Numeric digits are encoded according to the ASCII standard, which is the actual value plus 0x30h. Further, multi-digit numbers are stored as individual characters; 24 in the example is stored as 0x32h,0x34h.

Server side
The backend is a simple piece of software that accepts animation sequences, does some validation, and saves them to a database. Stored sequences are accessible from the datafeed API.

Backend
We wrote two versions of the backend; both are in the project archive. The first is a simple PHP/MYSQL backend for low volume online LLRDs, the other is a Google App Engine/Python version that should be able to handle a bunch of Hack a Day readers.

It’s really easy to write a backend for your favorite platform. Change the graffiti designer’s submit form action to point at your backend; both versions currently POST to backend.php. Now, catch the ‘author’ and ‘seq’ variables on your server and save them to a database.

Our backend performs a bit of validation to prevent attacks on the system. We implemented checks in phases so they don’t waste too many resources. First, the overall size of the submission is checked to make sure its within reason. Next, the sequence is split into individual frames and each is checked for form. If it passes validation, it’s saved to the database.

Feed API
Sequences are accessible through a simple datafeed API. The API has two variables:

http://graffiti-me.appspot.com/feed.php?max=1&last=0

• max – the maximum number of sequences to send.
• last – the last sequence read, only newer data is sent.

The datafeed begins each animation sequence with the character ‘#’, followed by an ID number and line feed. ‘#’ is an invalid bitmap value that alerts clients to the beginning of a new sequence. Clients can use the ID number with last variable of the API to get fresh sequences on each pull.

Hardware
Mini web server

We used our PIC24F mini web server as a TCP enabled client for this project. Read our previous articles to learn how to build the web server.

Daft punk table
[mrgalleta] has a great construction tutorial for the actual table part of a Daft Punk table replica. An LLRD can take many forms, though, such as our wall-hanging.

Most of Daft Punk table replica designs are controlled by a 74HCT595 (pdf) output expander and ULN2803A (pdf) transistor array. The driver board from this Instructable combines both into an easy-to-etch, through-hole PCB. Each driver board has two 74HTC595s, or 16 outputs; we needed two driver boards for our 25 cell LLRD.

The 74HCT595 is a serial output expander that’s controlled by an SPI-like interface. An update is initiated by dropping the latch line. The state of each LED (on or off) is put on the data line, followed by a pulse of the clock. Bits are put on the output pins once the latch signal returns to high. Data cascades from the data-output pin of one 595, to the data-input of the next. Read this 74xx595 tutorial for a detailed look at interfacing this device.

It’s important to note that we used the 74HCT595, and not the 74HC595. The “HCT” part works over a wide range of voltages, including the operating voltage of the mini web server: 3.3volts.

The 74HCT595 sources current, meaning we could probably run a single LED directly from each output at 3.3volts. Since most LLRDs have 2-8 LEDs per cell, operating between 5 and 24volts, we employ a ULN2803A transistor array to switch the larger load. The ULN2803A sinks current, rather than sourcing it; it switches the ground connection of the LEDs, rather than the power.

Our LLRD has two LEDs per cell, running at 20mA with a 5 volt supply and 56ohm resistor. We soldered the LEDs around a piece of cardboard, rather than etching 25 tiny circuit boards.

Connections

A 5 wire connection between the mini web server and the driver boards controls the LLRD.

Firmware
Our firmware is written in C using MPLAB and the Microchip C30 demo compiler. Learn more about programming and working with the PIC24F in our introductory tutorial. Two firmware versions are included in the project archive. The first just reads all *.seq sequence files from the SD card, the second version adds the Microchip TCP/IP stack for internet connectivity. Learn more about the Microchip SD card and TCP/IP libraries in our mini web server tutorial.

All graphics functions, including the TCP client, can be found in graffitigfx.c. The TCP client is based on the generic TCP client example that’s included with the TCP/IP stack. We followed Microchip’s cooperative multitasking approach and broke our code into small segments that share CPU time with the rest of the TCP/IP stack.

The client periodically connects to the datafeed and requests new sequences. New sequences are parsed for ID numbers, and appended to a temporary file on the SD card. The last ID detected is written to the very end of the temporary data file, and is appended to the last variable of the URL on subsequent datafeed requests. We record the ID at the end of the file to avoid repeated writes to the same sector on the SD card. Hopefully wear leveling inside a 1GB SD card is sufficient to avoid problems for the first few decades of use. If no network connection is available, the device plays any *.seq files in the root directory of the SD card.

A parser function decodes frames and sends them to the LLRD. The parser is fairly robust to errors. Bad data that makes it past the backend validation routine will be rejected at the device level without ill effect. If a few corrupt frames do manage to display, it’ll hardly be noticed amongst the other abstract patterns playing on the wall.

#define GFX_USE_TCP_CLIENT //include the TCP client
#define GFX_TCP_ONLY //only do TCP and read temp file, don't read other files on the SD card.
#define GFX_CLEAR_TEMP_ON_RESET //optionally delete the temp file on reset. good for Google App Engine...

Three defines at the beginning of graffitigfx.c control which features are included at compile time. GFX_USE_TCP_CLIENT compiles the firmware with the TCP client enabled, comment this definition for a SD card only version of the firmware. GFX_TCP_ONLY ignores any .seq files on the SD card, and only plays sequences downloaded from the web. The GFX_CLEAR_TEMP_ON_RESET option will delete the temporary sequence file on each reset; this is helpful for databases that have non-sequential record IDs, like Google’s datastore. In the future, these definitions could be changed to variables that are set by a configuration file on the SD card.

Taking it further
Our simple firmware is a stable starting point for an online graffiti wall. While we were working on this project we came up with a ton of additional features that didn’t make it into the prototype.

• Display IP address on startup.
• A configuration file on the SD card that sets the datafeed url, refresh frequency, and other variables.
• A telnet or web interface for remote configuration.
• A TCP server for direct access to the display; push animation frames from a remote PC.
• A mail client that reports errors and status information.
• Progress messages during startup and sequence downloads. SD card not present/full errors.
• Scrolling Twitter feeds.
• Your thoughts?

Don’t just read about this project, contribute some frames to the graffiti wall.

Next time we’ll introduce our final PIC24F project, an ethernet backpack for the tiny $20 color Nokia LCD knock-off from SparkFun Electronics.

Non-places are areas that lack any history or monuments: a McDonald’s looks essentially the same no matter where it is. Like a hotel, supermarket, or airport it no one expects it to have any sort of historical significance to the local population. He had examples of how some of these spaces are being humanized. The project We Tell Stories uses a Google Maps hack to give a fictional story locational awareness. GRL’s lasertagging work turns single purpose items like bridges and buildings into giant canvases. There are even location based gaming like Plundr which gives purpose to spaces that are generally ignored.

The video above is Nate’s personal project ‘Invisible Narrative‘, adding a hidden story to a nondescript elevator car. An audience member asked if GRL giving away their techniques might increase the amount of annoying ‘guerilla’ ad campaigns. His response was that releasing any type of technology could result in people implementing it in a bad way, but it’s important to get free technology into the hands of people who will use it for good.