here’s what it does: first, it searches for the string “my favorite color” and in practice finds around .1-5 tweets a minute like (totally random samples shown)

#KnowYourAnon my favorite color is neon pink/orange

— Milwaukee Princess(@PrincessMiltown) March 28, 2013

You know I’ve seen it all from the orange of the fall to the green of the summer, but my favorite color is neon

— Kennedy Shutter (@KennedyJShutter) March 28, 2013

My favorite color is purple and I like playing with kittens. There, now that we know each other…can I crash on your couch?

— Witchy Woman (@dreamthievin) March 22, 2013

my initial plan was to use the wikipedia list of colors as a lookup table, when i realized that people are commonly not very creative when choosing their fav color: it’s mostly one of about 10 different colors. so i compiled my own small lookup table from my experiences of staring at tweets:

colorlist = ["grey","lime","white","violet","yellow"...

the script simply cleans up the tweet, removes any strange character like "#" and compares every word of the tweet with my lookup table. the first color string in the tweet wins.
after that, the string is converted into predefined RGB values and weighted with the tweet length to generate some more diversity. the longer the tweet, the brighter the color.
that's basically it. now every time somebody twitters his/her favorite color, a pixel is slowly fading in to the LED matrix, forming a color spiral in the end.

the result is a very relaxing effect that somehow connects my room to the internets out there in a very abstract way. there are color trends that change over the day and the stream of retweets forms longer traces in the same color. you get an idea of what's going on in the "favorite color" corner of the twitterverse without obtaining too much information. obviously you could generate a similar effect by choosing random colors and times. but if you look at the display and you know that if a pixel lights up, somebody in some place in the world initiated this by tweeting his/her favorite color and is totally unaware of this project, it feels awesome.

so go ahead and check out the project files to use twitter as a data input for your next project:

))) project files (((

for my latest project, i have to populate 10 identical boards. why not have a PCB manufactured, you may ask. well for different reasons: first, it’s too expensive, because the boards are rather large. secondly, i have to get rid of a larger amount of perfboard. third, the layout is not complicated enough to justify a manufactured board.

anyway, in a former similar project, i used a CNC mill to plot the traces onto the board:

this was extremely helpful, but setting up the files and the mill took some time. now in the recent project, i experimented with toner transfer to not only put the layout on a perfboard but also a silkscreen on the top. the result is a board that is as easy and flawlessly to assemble as your first beginners electronics kit back in the day and it is neither complicated nor time comsuming:

although this is supposed to be some kind of tutorial, i’m not going into details about the toner transfer process, because this is described in other tutorials.
the base of the process is to have a board layout. i normally create layouts even for my perfboard circuits in Cadsoft Eagle. if you set the grid to 0.1 inch and stick to 90 degree angles, you’ll be fine. after that, you usually print out the layout and use it as a template while soldering.
but soldering is still pain in the rear. so why not spend a few minutes with a laser printer, an iron and a sip of water to create a professional perfboard™?

first, i CNC’ed out the boards, because they have a rather odd shape.

if you have no access to a CNC, just use a hacksaw, jigsaw, scroll saw, chainsaw, dynamite, whatever. if you cut your boards manually, you maybe want to cut it after the silkscreening to have an outline for cutting.

for the toner transfer, laserprint the layout onto a piece of catalog or anything else that does not absorb the toner. you may want to stick to one of the toner transfer tutorials i linked earlier for details.
now it gets a little counter-intuitive: keep in mind that during ironing, the layout gets mirrored. that’s why you should only mirror the TOP layer before printing, not the bottom layer. it’s a good idea to print out of Eagle directly. printing into a PDF first is likely to result in unwanted scaling of the layout.

this is a little tricky: you have to carefully align the perfboard grid to the layout grid. i made good experiences with aligning towards a window or a ceiling light, then holding both layout and board with two fingers, carefully putting it on a table upside down and carefully taping it into place. did it mention that you should be very careful? before ironing, check the alignment again.

after ironing, let the board cool down and put in into a bowl of water. peeling/rubbing off the paper is easy if done underwater (only the board and your hands need to be under water). if you decided to do layout AND silkscreen, just repeat the whole process, but be sure not to iron the second layer too long, because you will re-liquify the toner on the other side and the board will stick to the surface.
satisfied? then go solder your professional perfboard™.

summary of things to keep in mind:

* print directly out of Eagle/yourLayoutSoftware
* mirror the top layer, print bottom layer normal
* carefully align layout and perfboard grid
* check alignment before ironing
* iron second layer only half a minute or so

if you have any questions or ideas to improve the process, please do comment!

UPDATE: here’s timelapse of soldering the board. it took about one hour and the video is speed up 10x:

‘just because’, we decided to integrate all electronics into the tube instead of putting it into the base. we also chose to use perfboard and not a dedicated PCB because we had all the parts leftover from different projects and this one is more of a recycling project.

the heart of our resistor is an ATmega168 microcontroller in an uncomfortably large DIL28 package. along with the microcontroller we use a 7805 for voltage regulation and a 4511N BCD to 7-segment decoder/driver for the extra display.

we multiplex the three RGB-LEDs and the 7-segment displays using BC846 transistors as drivers. in order to save some space, we decided to use SMT for transistors and other passive components.

the resistor is made of dark grey PVC pipe. RGB LEDs and 7-segment displays are integrated into acrylic discs that form the rings of the resistor. in order to embed the displays, we had to CNC a custom disc.

to perform the actual measurement, we experimented with measuring the resistance by the discharge time of a capacitor. the problem: the measurement takes some time, so the user does not receive an instant measurement when she connects the probes to a resistor. so we decided to rather use a voltage divider and the ADC of the ATmega. the problem this time: we wanted to cover a large range of resistances. so if you use – let’s say a 1K resistor as the constant resistor and measure a 1K resistor, you measure a nice 50% value at your ADC, let’s say 512. if you measure small resistances, like for example 10R and 12R, you cannot safely distinguish between those two because both lead to very very small ADC values. our solution was to use two voltage dividers, one with a 150R constant resistor and the other one with a 27K. we determined this values with some spreadsheeting.

the resistance is measured with both voltage dividers. threshold values decide if the measured value lies in the safe range of the first or the second voltage divider. as a result, we were able to cover the E12-series over more than 5 decades. in other words: from 10R to 1M

the firmware displays a fancy colorful animation if the line between the probes is open. if a resistance is measured, the ADC value is compated to a lookup table. the closest value from the E12 series is selected and the correspondent colors are displayed. cheatmode is activated if a resistance is measured during power-up. it is sufficient to bridge both terminals with your fingers to do so. if cheatmode is active, you get an additional decimal display of the resistance value.

feel free to take a look at the calculations, scripts, firmware and schematics:

))) project files (((

if you have any questions, please do comment.

UPDATE: the device is now used as a temperature sensor, connected to an NTC. although my brain is still struggling to figure out the mapping from temperature to colors

additional images:

time was short, so we went for five panels to end up with a 5*5 matrix at the first party. we bought slats, stapled them together and ended up with ladder-like constructs that were 3.3 m long and 0.4 m wide. some fabric was used as a diffusor. an ATmega168 and some transistors on a breadboard control the five LEDs and the thing looked like this:

as you can see, the angle of radiation of the LEDs seperates the singe ‘cells’, making it possible to display clear ‘pixel’ images later on. since a breadboard is not the most robust solution for electronics and manufacturing PCBs would have been to time-consuming/expensive, i used perfboard and throughhole components. i routed the board in Cadsoft Eagle and used a CNC mill with a pen as a plotter to draw the traces onto the boards before soldering. this made it easy to reproduce them and place the mounting holes. no more messing around with mirrored Eagle printouts and forgotten traces. optimized like that, soldering went pretty fast, about an hour for a complete board.

so what’s on that board? as the brain, i still use the ATmega168. ULN2001A darlington arrays drive the LEDs and a 1489N RS232 receiver changes the +-12V signal to 0-5V. the voltage regulation is handled by a 7805, dirty but inexpensive. the complete board costs around 10 Euros. as connectors for the power supply, i chose 4 way MOLEX power connectors because they are cheap, robust and reverse polarity protected. for the data line, standard SUB-D9 connectors are used. the boards are designed to be daisychained, so power/data in on one side and power/data out on the other side.

power is supplied by an old ATX PSU. i use the 12V line and regulate down to 5V on the single boards. this is done to overcome voltage drops when using a long power line and many boards.
the data stream that controls the panels is generated by an old laptop running some python scriptage on a linux system.

all panels share the same RS232 line. this is possible because they only receive. each panel has it’s own address and can thereby be controlled individually, so it does not matter if you want to control one or fifty panels. the firmware on the panels handles the datastream, generates the PWMs via binary coded modulation and performs a gamma correction.

the protocol for data transmission is rather simple:
'A',address,15 bytes of data (5xRGB)
represents a data package for one panel, 17 bytes in total.
here’s a video of the finished five-panel, 3*3 m matrix:

the panels so far survived 3 partys, rough handling and beeing stored under bad conditions.
so yes, this is the billionth LED matrix, but this time, it’s large scale and really cheap, easy to build and makes a cool illumination for partys. and it always surprises me how you can still amaze people with a bunch of blinking LEDs.

specs in short:
* panel is 3.30m x 0.4m
* costs for each panel: 25 Euros
* 5x superflux RGB LED per panel
* RS232-bus
* 24 bit color depth
* ~80 FPS @ 5 panels in a matrix

feel free to download the source files including firmware sources, example python script and eagle files.

))) project files (((

if you have any questions, please do comment.

i was one of the two hardware people that build the skateboard. the electronics were designed by the other guy and my main task was to mount them to the skateboard, sp o in this post, i will only focus on this aspect of the project.
what sounds simple at first is in fact fairly difficult. besides the strong vibrations while riding the skateboard, huge g-forces are applied to the electronics when you land a trick. another problem is that almost every part of the skateboard is exposed to kicks, scratches and impacts, which has to be kept in mind when searching for a spot to mount the electronics. additional constraints are Bluetooth connectivity and the sensitive LiPoly battery that powers the system.

we decided to put everything between the deck and the trucks of the skateboard. therefor i designed a special mounting consisting of four important parts. first a frame that holds the electronics in place and protects them from impacts. second a set of transparent covers that allow to observe the status LEDs on the PCB. another important component is a custom foam rubber cushion that surrounds the PCB in order to damp vibrations and impacts. finally a thin piece of PVC separates the LiPoly battery from the PCB and keeps it safe inside the truck.

all parts were designed in a CAD software and CNC milled afterwards. after some try and error in the design, the results were pretty satisfying. the skateboard has been in sporadic use for about a year now and it still works fine.

besides the Push Challenge, we presented our work at the ACE 2010, the 7th International Conference on Advances in Computer Entertainment Technology in Taiwan.

demo of the application:

links:
solderinskaters.net, infos about the project
Solderin Skaters @ Flickr
Nokia Push Challenge

yesterday i found some time to do a dirty little hack in order to use my space mouse with Eagle. it took me two hours and somehow works. i spare you the details. just take a glimpse on the video.
this post is not about the actual hack. that’s just a proof of concept.

primarily i’d like to ask you, fellow space mouse and Eagle users, if you ever wished to navigate in eagle using your 3D mouse.
secondly i’ve got a message going out to the people at CadSoft: i like your software very much and it really improved my electronic design skills a lot. thanks indeed for that. but you’d be my all time heroes if you add support for 3D input devices to Eagle in the next release. come on, it’s not that hard. please?

update:
for those of you who really want to know how i did this, here’s the story. first of all, 3DConnexion offers a lot of information, examples and support for people who want to use their input devices in own applications and of course for companies who want to integrate 3D mice into their software. among a developers forum and their SDK download page, developers can download example codes at the 3DConnexion FTP-server (user:examples/pw:examples).

i used a .net example to write a small software that reads the 3D mouse. to interface CadSoft Eagle, i used the WINDOW (@); command bound to a hotkey. this Eagle command centers the view to the mouse cursor. when i move the 3D mouse, my readout software moves the cursor away from the view center (you can see that in the video) and triggers the hotkey. the more i push the mouse, the greater the distance between cursor and view center. this results in a higher panning speed.
zooming unfortunately cannot be done continuous, because it is triggered by hotkeys that zoom in or out a certain amount as the z-axis of the mouse exceeds a threshold.
this is all very dirty, i feel bad about it, do not try this at home, kids. although it somehow works, i have not really tested if it is usable when actually working in Eagle. a problem is that because i use the cursor for navigation, it cannot be used for manipulation at the same time. if you for example want to move a component, grab it with the move command and then use the 3D mouse for navigating, the component is moved too. another point is of course the bad interface between my readout software and Eagle. it is surprisingly fluid, but not comparable to a build in 3D mouse support.
talking about build in support, are you aware that panning and zooming only uses 3DOF of a 6DOF input device? that’s 3 rotational DOF that can be used for example to rotate parts or other awesome features.

i guess most of you are particularly interested in some facts about the hardware and software. first the hardware. i used 100 Superflux RGB LEDs with an angle of radiation of about 100°. the LEDs are dimmed via 8-bit PWM, generated by ATmega8 microcontrollers. each controller is responsible for 4 LEDs, which makes it a total of 25 controllers, running at 14,7456 MHz. there are 4 controllers on each PCB, the outputs are amplified by darlington arrays.

every LED has it’s own small board, including resistors for each color channel. the pixels are separated by a grid made of 4mm plywood. the light in each pixel is diffused by a small piece of air filter material and the frosted plexiglas pane. diffusion was a major problem, and i guess it’s not really possible to achieve perfect diffusion. my solution is a tradeoff between good diffusion and complexity.

the data comes from a PC via RS232(USB adapter) at 460800 baud. all controllers read the RS232 line simultaneously and are addressed by a reserved byte in the data stream. so i broadcast the data to all controllers and each one picks the data it is supposed to read. i’ve reached frame rates beyond 100 FPS.

the final software was written in JAVA because of the OS independency. it is still in development and will probably always be. at the moment it is capable of playing back animations which are stored in bitmaps, displaying the game of life and some variations of it, simple particles and several colorful effects and filters. and of course multiplayer tetris with overlaying playfields. can drive up to three sane persons really nuts.
the matrix was always supposed to be some entertaining decoration element, so it has to be able to generate an endless variety of content without steady user inputs. so i let the software surf the internet and jump from link to link. on every website, it collects content. at the moment, its just an image of the whole website, but i plan to analyze for example the text on the website. the image of the website is analyzed to get it’s n main colors, which are then the basic colors of graphical effects. i hope to end up with some kind of AI which analyzes the web in-depth and shows a simulated creative behavior in dealing with forms, colors and movement. but that’s an utopia right now and it’s gonna be a long way.
another plan was to add some kind of interactivity, but the design is not optimized for adding sensors. maybe a webcam could be used as a proper input-device.
future plans for the hardware include the integration of a netbook to have a completely standalone device which connects to the internet via wifi or ethernet. i considered some embedded solutions, but as old netbooks get cheaper and cheaper, this would be a reasonable solution

if you want to have detailed information about the development and the building process of this project, please visit the project’s own blog
http://rgb-led-matrix.blog.de (german)

i soldered a row of female pin headers directly to the AVR-pins. they have a distance of 0.4″, so you could fit a custom protoboard-shield on top of the module. a 16 MHz-SMD-crystal was glued under the chip and connected to the pins, and so was the pullup. i glued an 6-pin ISP-header to the front of the chip and connected it to the appropriate pins. last but not least  i added an SMD-LED to indicate power-on.  that was it for the electronics. next i filled the space between the female pin headers and above the atmega with hotglue (sticking the led into it). finally i needed a case. i had some lego bricks lying around on the desk and more randomly picked one that seemed to match. amazingly it fit perfect after i clipped the sides of the ISP-header. so i glued the circuit into the hollowed brick and added a label i made in corel draw. that’s about it.

the module is powered by the programmer (USB) and i can access every single pin. i like to use it in prototyping applications where a whole breadboad would be overkill, fragile or simply too large. like when you  just want to create a specific output signal. the module also easily hooks up to a breadboard. here’s another two pics of the lower side and the raw circuit:

pics:

here’s two pics:

yes, i forgot one line