StreetWriter

Introduction

I started this project because I wanted to make my mark on the world but didn’t want to leave any aftereffects.

I also wanted a challenging project for my new 3D printer that involved some Arduino Programming.

Finally, I like to build things using as much “found” stuff as possible.

As the videos show, StreetWriter does all of that. It writes 8 inch high messages in water on the pavement as it moves, and leaves no trace once the water evaporates.

I have built two StreetWriters, with minor design differences between them, This Instructable, is based on the second build which is somewhat improved.

In StreetWriter, water is pressurized and fed to a manifold which carries 8 automotive fuel injectors. As StreetWriter moves forward, the Arduino controls the fuel injectors, squirting water onto the pavement. The message to be written is one of 8 that have been written onto an SD Card plugged into the Arduino. The operator can easily select among the messages and can create new messages on the SD card at a computer. There is no length limit on any one message other than the amount of water in the pressure tank. The longest message I have written so far is PI to 300 places.

Parts, materials and tools

Drive wheel assemblies (used from old “Power Wheels” car)

“Found” 5 inch wheels

"Found" Wheel caster

"Found" Small RC car (or other RC remote control)

Wood plank

"Found" Windshield washer tank from old car.

Pressure gauge (optional) 1/8”NPT

Hose Nipple 1/8”NPT

Plastic tubing to fit nipple and water pump

12v Battery ( I used 6-7AHr sealed lead acid, less expensive than LiPo)

Arduino Uno

Arduino power switch Shield (EKT-1016 at Tindie.com)

Arduino SD card shield (www.sparkfun.com/products/12761)

Assorted electronics and connecting wire

3D printed manifold (could be made other ways)

8 automotive fuel injectors (used on Ebay)

Assorted screws and brackets

Cable ties, and Dclips

Barrier strips

3D Printer

Saw

Drill motor and bits

Screw driver

The goal of this project was to write text messages using water which is a transient writing medium. After a short period, the water will evaporate, and the message will disappear without a trace.

I was less interested in the prettiness of the final device than in its functionality. So, if you are interested in style as well as function, there is much room for improvement.

The overall design is a motorized platform which uses 8 nozzles to squirt water in a controlled manner as the platform moves.

As the pictures on this step show, the platform is a wood plank, driven by two motor assemblies which were scavenged from small power wheel toys.

Water from the pump on a windshield washer tank pressurizes 8 fuel injectors under control of an Arduino Uno.

There is a shield board on the Arduino which provides the current needed to drive the fuel injectors, which the Arduino cannot provide directly. There is also a custom shield on the Arduino that has an SD card reader and a few parts for selecting which file is used and the water pressure to be used to write messages.

Finally, there is a remote control of the StreetWriter vby modified electronics from an RC car.

Details on all of this are in later steps.

In many ways, this step is the core of the StreetWriter design.

I bought 8 used fuel injectors and then designed and 3D printed a manifold to hold the fuel injectors and provide water to them. See picture of orange injectors on a blue manifold.

Fuel injectors are a wonderful fit for this project. Each fuel injector contains a valve to control water flow, a 12v electrical solenoid to control the valve, a nozzle which sprays the water in a controlled area, and plumbing and seals to get the water to the valve and nozzle. All the internal metal parts are stainless steel, so the fact that we are using water rather than the gasoline does not cause a corrosion problem. To put out a bit (pixel) of water only requires that the Arduino apply 12V to the solenoid for a brief period of time.

I designed the manifold so the fuel injectors are spaced enough apart so their watery pixels are adjacent. If your fuel injectors spray a very different pattern of water, you may have to raise or lower the height of the manifold/injector assembly so that the sprays are just adjacent.

I found some connectors with wires attached that worked for the pins on the fuel injectors, but you can use automotive hardware for that. There is more detail about wiring things in Step 10, final assembly.

Fuel injectors were bought used on Ebay for about $2 each. Mechanically similar parts seem to be available for multiple car types. The attached photo is annotated with the important features needed for the injector to work with the manifold design provided here.

1) An O-ring at the top that seals the injector to the manifold

2) Slots in the injector that are used to lock it into the manifold.

The 3D printed manifold is the mechanically most complex part of this project.

It contains 8 sockets for the fuel injectors, ports for the pressure gauge, and water inlet, and must be water tight.

I designed the part in TinkerCad, which was fairly straightforward. I am providing the STL file and the Gcode file for PLA. Also, see the video which shows the TinkerCad model and the printer build, an 8 hour task.

There is also a picture of a small red section of the manifold which is annotated to show the holes used to lock the fuel injectors into the manifold. I just ran a piece of copper wire through the four holes, and it locked the fuel injector into place.

The main use for that small section was to test injector fit, and to make sure the build would be water tight, before committing to an 8 hour build. I clamped the part in a vise with a piece of rubber across the open end and applied water pressure. It leaked. I built it several times with various parameters in Cura (slicer program) and could not make the sample part water tight. It always weeped or leaked multiple places. Finally, I switched to Sli3er as a slicer program, and got a water tight test part on the first build. That version is the Gcode file is what is provided here.

After the manifold is printed, there are a few finishing steps required before it can be used.

1) The brim on the bottom of the part needs to be cut away to open the injector sockets for use.

2) The 4 holes in each socket need to be cleared with a small drill so a wire can be installed.

3) The top holes need to be tapped with a 1/8”NPT tap for the pressure gauge and hose nipple.

4) Finally, the inside of each socket needs to be smoothed so the O-ring on the injector will seal. The goal is to level out the 3D printed ridges inside so that the O-ring “feels” a smooth surface. I did this by using WELD-ON 4 solvent on a cotton ball, running it up and down inside each socket until it was smooth to my finger.

At this point, the fuel injectors can be installed into the manifold and locked with copper wires.

I applied Lithium grease to the O-ring on each injector before installing it, to allow an easy fit, and to support sealing water tight.

Test your work. Install the pressure gauge, and the hose adapter. Apply about 15 psi water pressure and look for leaks. If there are any weeps, you can use WELD-ON 16 glue or WELD-ON 4 solvent to seal them, and retest.

As I said in the introduction, the goal of my build of StreetWriter was functionality, not beauty or style.

The frame is ½” plywood with holes, wood blocks, etc. added as necessary. The annotated top photo shows where everything was placed. The only important placement is the row of fuel injectors at the rear of the vehicle and between the rear wheels. That way, as the vehicle turns, the message is minimally distorted, and the wheels never run over the message.

The fuel injectors hang from the manifold and drop through the holes in the frame. They are not supported by the frame. The manifold is sitting on the frame, and is only loosely held by one pipe clamp that you can see in the rear view photo.

The frame is powered by two wheel assemblies that were taken from old Power Wheel style kids riders that I have collected over time. The attachedpicture shows similar units. The power assembly motors are cable tied to a block on the frame, and reinforced on the bottom by “L” brackets. I have added 0.1 ufd capacitors across the motor terminals to reduce the electrical noise from the brush type motors. (The Arduino was randomly rebooting without the capacitors. )

Steering of the vehicle is “tank steering”, with power removed from one or the other drive motor to steer. Steering is not proportional. Stop one wheel and the StreetWriter will turn sharply, Gradual turns are achieved by the operator pulsing right or left, while driving forward.

There is a caster at the front of the frame that allows StreetWriter to make a sharp turn when one wheel stops turning.

The rear wheels on Power Wheel style riders are usually connected by an axle so both wheels move together.

That wouldn’t work here, because I want the rear wheels to operate independently for steering.

I found some 5” wheels somewhere and with minor modification was able to use them. The wheel detail shows that this particular wheel has 12 structural struts. The drive assembly has 6 slots. I just cut away every other strut and the remaining struts keyed nicely into the slots in the drive assembly. I used a bolt through the hole which riginally contained the axle, and a nut with Nyloc insert to hold the two together with enough play to allow it all to spin. (Depending on what parts you use for drive assemblies and wheels you may have to get creative in making them work well together.)

In line with goal of using “found” parts where possible, the RC control for StreetWriter is based on the electronics from a trashed small RC Car. The important requirement is that the remote control be radio, not IR, since StreetWriter will be used outside. Most of these cars do not have proportional steering which is perfect here.

They are either turning right or left, or driving straight.

I used the electronics from the car, and added relays to raise the power handling to what is required for the drive assemblies. The lower (brown) circuit board in the picture is from the car. The upper (hand wired) board contains relays and a voltage dropping circuit needed for the 4.5V RC car circuits. The schematic is attached.

The circuitry is quite simple. A transistor controls each of the three relays. One relay powers the left motor, one the right motor, and the third reverses the power to both motors for driving backward. Control signals come from the RC car circuit board. When a left turn is signaled, a transistor forces the left relay to turn off, stopping that motor.

The remote control is shown in the picture. It can send the vehicle forward/back and left/right.

I have added a piece of music wire (coming toward you out of focus in the picture) so the antenna on the car is coming straight up to increase range somewhat.

There is only one connection from this circuit to the Arduino. The single connection tels the Arduino code that the vehicle is moving forward. If the vehicle is stopped or moving backward, water doesn’t spray.

The pressurized water for StreetWriter comes from windshield washer tank from an old Subaru, but the source auto is not critical. Any tank with a built in 12V water pump will do.

On this particular tank, there are two water pumps, so I just capped off the output from one of them, and used the other. The tank has a bump at the bottom, designed to mate with a hole in the car chassis. I just drilled a hole in the StreetWriter frame for that bump to sit in, (bottom view picture) and bolted the top of the tank to a wood support on the frame. (top view picture) I also used the bolts to secure a plate with the main power switch.

The pump motor requires more power than the Arduino output can supply. There is a transistor amplifier for that mounted at the pump itself to reduce electrical noise. (See RC control schematic, and fairly ugly wiring picture attached.)

Tubing runs from the pump on the tank to the nipple on the manifold. The nipple is sized for the tubing and for the 1/8 “ NPT thread on the manifold.

Arduino code runs the motor briefly before allowing the fuel injectors to write, to pressurize the system.

Arduino code also runs the pump when you move the pressure pot to allow the user to set the manifold pressure, since different surfaces require more or less water for good readability. You just wiggle the pot and the pump comes on so you can adjust the pressure using the gauge. When you stop moving the pot, the pump stops.

StreetWriter requires two shields on the top of the Arduino Uno.

The first is a commercial part , EKT-1016, that I bought from Tindie.com. This provides 16 channels of power amplification between the Arduino Uno and the fuel injectors. We are using 8 of those channels in this project.

The second shield came from SparkFun, (www.sparkfun.com/products/12761

It contains an SD card reader and some custom circuits.

There are:

1) a potentiometer to adjust water pressure

2) a potentiometer to select which text file will be written by StreetWriter

3) a multi-color LED to indicate which of 8 files has been selected

4) a switch to disable printing while moving forward

5) a connector for ground and the two signals needed, forward command input from RC and pressure command output to the pump.

The core function of StreetWriter is to use a digital font to make characters.

Fortunately, someone has done all the hard work of creating fonts and made the result available to us at:

https://www.min.at/prinz/o/software/pixelfont/

This font editor program has multiple sample fonts available, gives the user the ability to edit these existing fonts.

You can then output the resulting font as a block of code that can be placed directly into an Arduino program.

I modified one of the fonts to add footprints, and that file is attached (footprintFONT.pf). You can use any of the sample fonts that come with pixelfont or the one attached, to create the code block that the Arduino file needs.

The Arduino code in the next step has the ability to read and print one of 8 text files.

Which file will be printed is selected using a pot on the Arduino shield, and indicated by the color of the LED on that shield. The colors are: red, green, blue, yellow, cyan, magenta, white, black.

The text files on the SD card are named by the same eight colors for ease of identification. The text in the file is not associated in any way with the file name.

I usually put a table of contents file TOC.txt onto the SD card to help me keep track of what each file contains, and print that file out and paste it to the StreetWriter. (see picture)

Files can be of any length. For instance, the file BLACK.txt contains PI to 300 places.

The text files can be created on any text editor, but some editors may add end of line characters that affect message spacing at printing time. I usually use NotePAD.

The Arduino program I wrote has the ability to access “non-printing” character locations in the font table by addressing the character location directly. For instance, part of one footprint is in font location 128, so the text file contains ^128, The Arduino code detects the “^” and uses it as an “escape” character. It doesn’t print the “^” but fetches the next three characters as a font location and prints that character.

(^128^129^130 ^131^132^133 will print six characters that make up one left and one right footprint.)

The Arduino code for this project is attached. It is straightforward with a few things worth mentioning.

There are two tabs in the program. (In order for the Arduino IDE to find and use these files, they must be put into a folder named STREETWRITER_BLUE.)

STATESET is just a routine that communicates with the ETK-1016 shield, turning its drivers, and thus the fuel injectors on and off.

STREETWRITER_BLUE is the main routine where everything else happens.

Starting at line 13 there is a very long array:

const uint8_t font[] PROGMEM = {

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Char 000 (.)

0x7E, 0x81, 0x95, 0xB1, 0xB1, 0x95, 0x81, 0x7E, // Char 001 (.)

…

0x44, 0x6C, 0x38, 0x10, 0x38, 0x6C, 0x44, 0x00, // Char 120 (x)

…

0x00, 0x60, 0x40, 0x40, 0x40, 0x40, 0x60, 0x00 // Char 255 (.)

};

This is the font table. Each line describes one character, and ends with a comment giving the address of that character and what the character is. Non-printing characters are indicated by (.). This table is too large to fit into Arduino working memory, and the compiler directs it to flash memory. This is fine, since the table is only read from, never written to while the Arduino is operating.

The main LOOP starts at line 345. It detects that StreetWriter is moving forward, reads the next character from the open text file. It sends the bytes for that character to the fuel injectors, one stroke at a time. Then it fetches the next character and sends that.

At line 347:

The Arduino doesn’t adjust how much time a character bit is squirting water as the StreetWriter's speed changes. In practice, I have found that StreetWriter’s speed is fairly constant, so testing and adjusting stroke width once during setup is adequate for producing good enough output. In this code, you can see that it is set at 500.

pulsemin, pulsemax, and pulse are values that worked for my implementations.

At line 376 there is code that starts the pump for ½ second to give the operator a chance to read and adjust the pressure. As long as you keep fiddling with the pot, the pump will stay on. When you stop adjusting, the pump will go off.

At line 393 the code tests for what font character has been returned from the text file and decides how to print it.

The routine UNPACK at line 403 unpacks the font bytes and sends them to the fuel injector drivers.

The routine COLOR at line 410 tests the file selection pot, adjusts the LED color to match, then opens the appropriate text file.

I have not provided an overall wiring diagram, but it is straightforward.

1) The fuel injectors need to be connected to the shield that controls them. I found some connectors with wires attached that worked, but you can use automotive hardware for that. I used a barrier strip to connect those shortish cables to color coded cables to the shield. (shield close up and bottom view)

2) The cable from the custom shield to the RC board provides the PWM signal for the pump, and the command signal back to the Arduino indicating forward motion. This is the 4 wire cable leaving he shield board toward the top in the shield picture.

3) The power needs to be hooked up: Battery to power switch, to Arduino, and to RC motor control board. I used another barrier strip that you can see in the Overall top view picture.

4) Cables between the RC board and the scavenged mini-car board provide power, and forward/reverse left/right signals.

Now, does it work?

1) Are the motors wired to go forward when the RC remote says forward? If not, the fix is to reverse the leads to the motor(s).

2) Does the pump power up, and can you adjust its pressure?

3) Do all the fuel injectors work when you command forward? I like to use the test pattern (white.txt) which should draw 8 stripes.

4) Does the file selection pot change which file is written? And do the files match the color of the LED?

5) Are the letters of a nice width? If too narrow or too wide, you must change the stroke width in the Arduino code, now set to 500.

Since the StreetWriter described here is a second build, some improvements from the first have already been incorporated.

The biggest changes are:

1) to use the windshield washer tank rather than the garden sprayer you may see in some of the videos.

2) Using the EKT-1016 rather than custom wiring for the power amplifiers.

I have considered making a version with 12 to 16 pixels to get more resolution in the text written, but have not been able to find a software source like Pixelfont for the higher resolution and am too lazy to write that from scratch. Please let me know if you do a build like that.

I have been asked to use paint or some other more permanent marking fluid than water, but I resist. The evanescent nature of what StreetWriter has to say is part of the design.

I did try adding kitchen detergent to the water to see if it would blow bubbles as it wrote. The result was faint clean spots on my driveway making messages which lasted several months. No bubbles.

Finally, it turns out there has been parallel invention of this technique on a larger scale. See www.trikewriter.com/