Category Archive

Working on a project to potentially building a piece of art to put up in my room next year. The idea is this one: with the help of a friend who is better at hardware than myself, some ICs, my Arduino, and lots of patience and soldering, I want to build a 30 inch by 30 inch board with 100 discrete 3 inch by 3 inch “pixels” which are lit by a single RGB LED, that would look something like this, if the LEDs were set to display red, green, blue, repeating:

Each pixel diffuses the light from the LED so that it appears that the whole pixel is lit.

Since each LED can display any mix of red, green, and blue, any color is possible within each pixel, so designs can be displayed. It will maintain a USB connection to the computer (although extra power will probably be needed as the Arduino/USB won’t supply enough for 100 bright LEDs) so the computer can run more complex algorithms than the ICs could normally handle, and maybe even be able to display simple visualizations that follow music, fades and sweeps, and any color that I desire to set a certain mood to my room.

Other ideas include Conway’s Game of Life. The board could be mounted on a piece of foam board or plywood, with the elctronics hidden beneath, and the LEDs shining through either translucent acrylic or some sort of cloth, most likely.

Anyway.. mostly I have to keep it cost effective. Ordering LEDs from eBay, I can get 100 RGB LEDs for about $35, which beats DigiKey’s $150-ish for 100, but I still have to find integrated circuits and learn how to do it. Wish me luck :)

(Any suggestions are more than welcome)

Sometimes. And telling when it’s stupid is important to being a good coder, in my opinion.

Maybe I’m wrong. I don’t have a degree yet. But I know that when I write a Python script that I want to rotate the screen on my tablet, I’m not worrying about extensibility or modularity, I just want a small procedural script that does this, this, and this, and then finishes. The faster the better, both in writing the script and in the script’s execution.

So, in beginning work on JORSnix, I decided I’d get my tablet working perfectly first, as a system to model it on. Part of this made rewriting my tablet.rb script that rotated my tablet between landscape and portrait mode in Python. I spent about 20 minutes on it, not counting the time I spent learning that the os module was deprecated and thus learning how to use the subprocess module.

Anyway, the finished product is this:

#!/usr/bin/python
from subprocess import *
import re

p1 = Popen(["xrandr"],stdout=PIPE)
p2 = Popen(["grep", "current"], stdin=p1.stdout, stdout=PIPE)
output = p2.communicate()[0]

current = output[output.find("current "):output.find(", max")]
pattern = re.compile('[0-9]+')

resolution = pattern.findall(current)

if resolution[0] > resolution[1] : #landscape
        Popen("./xrotate"+" 3", shell=True)
        Popen("cellwriter &",shell=True)
        Popen("easystroke &",shell=True)
else : #portrait
        Popen("./xrotate"+" 0", shell=True)
        Popen("pkill cellwriter && pkill easystroke", shell=True)

As you can see, it's pretty simple and straightforward. It's no piece of art, but it does what it needs to do. No more, no less. And it will work on any single-monitored tablet, no matter the resolution, for swapping the screen from portrait to landscape and back.

If it needs to be turned into a couple functions so I can use it in a class, that would work. But that's not what the plan is, at least not yet. But I was told by a friend on IRC that it was unreadable, and wrong simply because my code isn't "modular and extensible" without first examining why it would need to be extended upon. He gave this as the "correct version:"

getting pregnant

#!/usr/bin/python
from subprocess import Popen,PIPE
def bash(c):
	if c.startswith('cd '):
		chdir(''.join(list(c)[3:]))
	else:
		return Popen(c, shell=True, stdout=PIPE).stdout.read().strip()

class Display():
	def getCurrentResolution(self):
		res = bash("xrandr")
		res = res[res.find("current ")+8:res.find(", max")].replace(' ','')
		return (res[:res.find('x')],res[res.find('x')+1:])

	def rotate(self):
		res = getCurrentResolution()
		if res[0] > res[1]: # Landscape Mode
			self.xrotate(3);
			bash('cellwriter &')
			bash('easystroke &')
		else:               # Portrait Mode
			self.xrotate(0)
			bash('killall cellwriter')
			bash('killall easystroke')

	def xrotate(self, mode):
		# unknownmosquito can fill it in from here

class Wacom(Display):
	def getStylusMode(self):
		return bash('xsetwacom get stylus Mode')

display = Wacom()
display.rotate()

Besides going into the fact that the "better version" would no longer use regular expressions (and thus would be less resilient to oddly shaped displays), it aliases Popen to bash for "readability." Overall, being accused of using procedural programming for a systems script in a language like Python (which allows you to do this for a reason), and to have this given to me as a "correction," just rubs me the wrong way.

Especially when I'm told that it needs to be done like this to make it more "readable."
Object Oriented Programming is wonderful. Unless using it is just wasting time.

Note: If it becomes necessary to integrate this script into a larger part, obviously it will get OOP'd. But for now, it'll remain a script.

Ironically I’m going to post again so soon after my “I’m not posting during the summer” post, but I got a bug and designed a single-page portfolio for my friend Luis. I thought to myself, “There should be a simple introduction to his work that he shouldn’t be afraid to put on a business card.” And he seemed to like it until it was almost done, and then started asking for things like tabs with more content.. but I feel like his blog is for that. So I finished it as I saw fit and told him he may do with it what he pleases. It is his domain, after all.

But for now, it is quite a masterpiece, if I do say so myself. I am very proud of it, and I find it very aesthetically pleasing, and straight and to the point.

Here is a permanent screen capture, in case he decides it just isn’t for him:

The thumbnails are rollovers; when you mouse over, the shading and text are removed so you can see the (still cropped) original image. As of this writing the links don’t even go anywhere, besides the Twitter, email, and blog links at the top, but I suspect if Luis decides to keep the design, he will add links for his work. It is organized the way he wanted it, and it’s his color scheme.

Please keep it, Luis! :(

I’ve been messing around with Pygame to some extent. It’s a neat little Python library, designed for the easy creation of some simple games. It’s cross platform, so it runs anywhere Python does.

I haven’t done much; the tutorials on the website provide much more instruction than I could at the moment, but I’d like to post the short program I wrote just for my own amusement. The button merely makes an image appear on-screen and work as a “button.” I wrote a short Button class as well as the main script, and am pretty impressed with the results. It’s a very basic example, but maybe it’ll help someone out there having some trouble getting started.

#!/usr/bin/python
import pygame
from pygame.locals import *
import os
import sys
from Button import *

pygame.init()
window = pygame.display.set_mode((640,480))
screen = pygame.display.get_surface()
pygame.display.set_caption("My Game")
bgcolor = 255, 255, 255
clock = pygame.time.Clock()
button = Button("play.png","play_invert.png",50,50)
while True:
	for event in pygame.event.get() :
		if event.type == QUIT :
			sys.exit(0)
		elif event.type == MOUSEBUTTONDOWN :
			if button.isInside(event.pos) :
				button.switchStatus()
		elif event.type == MOUSEBUTTONUP and not button.getStatus() :
			button.switchStatus()
		else :
			print event
	time_passed = clock.tick(50)
	window.fill(bgcolor)
	button.draw(screen)
	pygame.display.flip()

That was the main script. It requires four things: pygame, Button.py (coming), and two images (the button up and the button pressed).

Those are the two images I used. This is Button.py:

import pygame
class Button :
	def __init__ (self, path, invertpath, x, y) :
		self.x = x
		self.y = y
		self.button = pygame.image.load(path)
		self.invert = pygame.image.load(invertpath)
		self.status = True
	def draw (self, screen) :
		screen.blit(self.button, (self.x, self.y))
	def isInside (self, pos) :
		if (pos[0] >= self.x) and (pos[0] <= self.x+self.button.get_width()) :
			if (pos[1] >= self.y) and (pos[1] <= self.y+self.button.get_height()) :
				return True
			else :
				return False
		else:
			return False
	def getStatus(self) :
		return self.status
	def switchStatus(self) :
		self.status = not self.status
		temp = self.button
		self.button = self.invert
		self.invert = temp

Of course I failed to comment it… figures. Most of this should be pretty obvious though.
Also: consider this code public domain. Use it, make money with it, I don’t care. Whatever. I shouldn’t have to say that, but I will just in case.