Investigating duty cycles on this plastic fan:

fan hack

I figured that I could horse around with my PowerSwitch Tail, and make it somewhat mimic a PWM 5V setup. I was curious how long I would have to ‘pulse’ the switch with juice to keep the fan constantly rolling. I started with it fully on, and kicked my ‘active’ duty cycles lower until I reached a nearly-continual state of motion. Pause for Arduino code snippet:

/*
PowerSwitch Tail Template
-
120V AC Driver w/ LED indicator
-
Joseph Swanson
2011 | http://swantron.com
*/

void setup() {
// declare pins (13, 7) for writing
pinMode(13, OUTPUT);
pinMode(7, OUTPUT);
}

void loop() {
// Fire relay / LED
digitalWrite(13, HIGH);
digitalWrite(7, HIGH);

// Configure for “on” time
delay (50);

// Kill relay / LED
digitalWrite(13, LOW);
digitalWrite(7, LOW);

// Configure for “off” time
delay (950);
}

Pause for a small small-video break:

As that code and vid indicate, 1/20th of a second is all it took to keep the fan rolling, with 19/20th of a second idle. Not bad. Not sure what the takeaway is, but that is something to mention.

Put that knowledge somewhere safe, provided the question of humidifier fan duty cycles should spring up.

Still poking…

dual terminals and a terminal

Making progress…snagging my Twitter page via Python, and dumping it to LCD:

+1 closing tags

I just need to hammer out some parsing, and I will be good to go. I really need to figure out some sweet regex and drop this whole ‘import (some junk)’ stuff. Who knows…at this rate, I just may.

Thou ought direct thine output aftways, to-wards thine USB port of thee. And that is well and righteous.

Well, that still is the case. My latest project has made it glaringly obvious that sometimes a little Python script will render a whole bunch of shell scripting moot. Namely, parsing HTML. Let’s see a picture…

bad lab mobile

Lunch hour project: parse the comments from swantron.com; feed said comments to an LCD screen.

I was horsing around with wget from a CLI a few days ago. I found myself trying to smash through the resultant file via pure regular expressions…which is incredibly clumsy. Well, as luck would have it, my go-to after my main go-to is Python, and this type of thing has been issue enough to warrant a library. BeautifulSoup. It acts to parse the HTML info into items, that can be smashed around as I see(med) fit.

My setup was simple: py script to snag my comments and write serial, Arduino sketch to drive a LCD and read/write serial. And a source of shade. And a WiFi signal to snag.

bad lab mobile-mobile

Check, check, check, etc. Video time:

Pretty slick…hit the fold for the code, as promised, and a summary.

Python parser / serial writer

#!/usr/bin/python
# http://swantron.com
# htlm grab / parse…
# …write to serial out
# 2011

admin = [ 'Joseph Swanson' ]
total = True

import urllib2, time, serial, sys
from BeautifulSoup import BeautifulSoup

# disregard spammers | disregard identical posts | create spam zone

spam = []

# initialize serial write to Arduino

ser = serial.Serial(‘/dev/ttyUSB0′, 9600)

time.sleep(5)

# work section

while True:

# snag html

html = urllib2.urlopen(“http://swantron.com/comments/feed”).read()

# parse

soup = BeautifulSoup(html)

# inspect parsed results

for item in soup(‘item’):
badGuy = item(‘guid’)[0].string.split(‘comment-’)[1]

if badGuy not in spam:

# spammer jail

spam.append(badGuy)

# time modification

postTime = item(‘pubdate’)[0].string
parsedTime = time.strptime(postTime, “%a, %d %b %Y %H:%M:%S +0000″)
offsetTime = time.mktime(parsedTime) – time.timezone
localPostTime = time.strftime(“%m/%d/%y %H:%M”, time.localtime(offsetTime))

# identify me

author = item(‘dc:creator’)[0].string
if author in admin:
print “(” + localPostTime + “) I, ” + author + “, just posted a comment”
print ” ” + item(‘guid’)[0].string
print ” ” + item(‘description’)[0].string
ser.write(item(‘description’)[0].string)
time.sleep(1)
elif total:
print “(” + localPostTime + “) background noise ~~ ” + author
print ” ” + item(‘guid’)[0].string
print ” ” + item(‘description’)[0].string
ser.write(item(‘description’)[0].string)

time.sleep(10)

Arduino LCD driver

// LCD Driver
// http://swantron.com
// basic serial in > LCD display
// 2011

#include

// **Define pins**
// LCD RS – pin 12
// LCD R/W – pin 11
// LCD ENABLE – pin 10
// LCD BACK+ – pin 13
// LCD DATA4 – pin 5
// LCD DATA5 – pin 4
// LCD DATA6 – pin 3
// LCD DATA7 – pin 2
// LCD VSS, CONTRAST, BACK- – ground

LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);

int backLight = 13; // Define pin for backlight

void setup()
{
pinMode(backLight, OUTPUT);
digitalWrite(backLight, HIGH); // Backlight level (LOW / HIGH)
lcd.begin(20,4); // (Columns, Rows)
Serial.begin(9600);
}

void loop()
{
// when characters arrive over the serial port…
if (Serial.available()) {
// wait a bit for the entire message to arrive
delay(100);
// clear the screen
lcd.clear();
// read all the available characters
while (Serial.available() > 0) {
// display each character to the LCD
lcd.write(Serial.read());
}
}
}

I’m excited about this project. Even though this deal is in gen 3, I still have some crazy take-off ideas. Create a secure page on swantron to hold a few values…hook up my old notebook as a base station…home automation on the cheap. Replace that LCD with a sketch to search for a particular string, i.e. “open garage door” and boom, there you go. This could be very cool. Introduce twitter to remove my server from the equation…awesome.

Hit the comments with any improvements or project ideas you can conjure. This one has me excited…feel free to challenge me with something cool. As always, thanks for reading, yadda yadda, stay tuned, etc.

so...beautiful

I have some sloppy sloppy code at this point, and need to add some hardware and stuffs to my prototype. Stay tuned…this could be a good one.

I started daydreaming at work about how to go about making hardware interface with an RSS feed. I have seen some projects that use Arduinos with ethernet shields to check Twitter, for example, but they seem unnecessarily bulky. Or clumsy. I spend a lot of time working on the command line, and love to put together dirty little scripts to solve problems. It sort of goes along the lines of ‘when you have a hammer, everything looks like a nail’…I figured that the same thing could be implemented with a little shell scripting and my trusty Arduino, sans anything complicated.

So far, so good.

bad lab mobile

I put together a sketch (after the bump) to drive my LCD, writing serial output to the screen. After verifying that the sketch worked via the Arduino IDE’s serial monitor, I popped open a CLI and got to work. FWIW, I am using Ubuntu 11.04 still…ctrl-alt-t pops open a terminal window…unity has me all over shortcuts these days. Anyhow, I was able to verify that I could echo text and direct it to the USB port that the Arduino was mounted to. No sweat.

As a proof of concept, I decided to display the number of times that I had the word “awesome” on swantron.com. Once the LCD was shown to work, the sky is the limit…see some regex, pipes, wget, and so forth in action:

CLI FTW

Survey says:

+11 awesome

Eleven “awesome”s. Awesome.
(Hit the bump for some code, an oddity, and more fun…)

So that is that. You could link two of these together for 160 characters…toss together a shell (or Python, etc.) and have a Twitter display, for example. Whatever you want to…gosh.

I did notice an odd “feature” of the Liquid Crystal library I used. For some reason, it wraps lines in an interesting fashion…

command line usage:
> echo “why does this library I am using wrap text wonky as hell?” > /dev/ttyUSB0

1 > 3 > 2 > 4

No idea why this is. Sort of confusing. Anyhow, the entire sketch is pretty straight forward. Did somebody say snippet?

// LCD sandbox
// http://swantron.com
// driving LCD from command line
// 2011

#include

// **Define pins**
// LCD RS – pin 12
// LCD R/W – pin 11
// LCD ENABLE – pin 10
// LCD BACK+ – pin 13
// LCD DATA4 – pin 5
// LCD DATA5 – pin 4
// LCD DATA6 – pin 3
// LCD DATA7 – pin 2
// LCD VSS, CONTRAST, BACK- – ground

LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);

int backLight = 13; // Define pin for backlight

void setup()
{
pinMode(backLight, OUTPUT);
digitalWrite(backLight, HIGH); // Backlight level (LOW / HIGH)
lcd.begin(20,4); // (Columbs, Rows)
Serial.begin(9600);
}

void loop()
{
// when characters arrive over the serial port…
if (Serial.available()) {
// wait a bit for the entire message to arrive
delay(100);
// clear the screen
lcd.clear();
// read all the available characters
while (Serial.available() > 0) {
// display each character to the LCD
lcd.write(Serial.read());
}
}
}

We’ll see where this one ends up. This one might be a launching pad for a bigger and better thing. Stay tuned.

How about a 20 by 4 LCD project? Okay.

+1 blue

I have had this sitting on the workbench of bad lab for a while. Time to get after it.

The unit came assembled, minus the jumpers I needed to plug this into my breadboard for prototyping. Coincidentally, my soldering station needed to come out of retirement. Sixteen pins…sounds about perfect.

(hit the bump for several more pics, a snippet, and some other awesome stuff)

those.

I snagged the unit from hacktronics.com. Their website has details on the pin-level for the LCD unit. Pretty straight forward…slam it together and feed it a string or four. Wiring as follows:

+ several wires

It has been a while since we have had a snippet. Fair enough; queue the snippet:

// LCD sandbox
// http://swantron.com
// 2011

#include

// **Define pins**
// LCD RS – pin 12
// LCD R/W – pin 11
// LCD ENABLE – pin 10
// LCD BACK+ – pin 13
// LCD DATA4 – pin 5
// LCD DATA5 – pin 4
// LCD DATA6 – pin 3
// LCD DATA7 – pin 2
// LCD VSS, CONTRAST, BACK- – ground

LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);

int backLight = 13; // Define pin for backlight

void setup()
{
pinMode(backLight, OUTPUT);
digitalWrite(backLight, HIGH); // Backlight level (LOW / HIGH)
lcd.begin(20,4); // (Columbs, Rows)
lcd.clear(); // Clear screen
lcd.setCursor(0,0); // Move cursor, print
lcd.print(“liquid | swan”);
lcd.setCursor(0,1); // Move cursor, print
lcd.print(“crystal | tron”);
lcd.setCursor(0,2); // Move cursor, print
lcd.print(“display | dot”);
lcd.setCursor(0,3); // Move cursor, print
lcd.print(“(FTW) | com”);
}

void loop()
{
}

That is that. Again, the potentials for this sucker are vast. I would like to to let this rip with my PING sensor, but need to throw some more effort towards the IOIO. Java schmava. Stay tuned for a bad assed project of some nature…even plan B is pretty awesome these days.

nearly a gross

125 white LEDs. My first thought is 5*5*5 LED cube, powered by the Arduino. I am also thinking that a 6*20 LED matrix would be pretty slick. Either way, my soldering skillz will be put to the test, and awesomeness will surely ensue.

I do know that there is some sort of hands free interface, and that is what I have put together.

+1 dizzy

Long story short, I have extended upon my PING))) project to include some sweet touchless home automation. I have the ultrasonic sensor interfacing with my garage door and a lamp, utilizing a servo and a PowerSwitch Tail, respectively.

Hit the bump for an awesome video of this thing in action, and for my spippet.

*Video contains a rare thumbs up from the author*

Snippet? Oh, INDEED…

//DIY Minority Report

// Joseph Swanson | 2011
// http://swantron.com

// Setup
// LEDs connected to pins 11, 2-5
// Ping))) sensor signal to pin 7
// Servo signal to pin 10
// PowerSwitch Tail to pin 13
// Ping))) +, servo + to 5V
// Ground the shit out of everything

#include

Servo myservo;

int pos = 0;

// Pin assignment
const int ledPin1 = 11;
const int ledPin2 = 2;
const int ledPin3 = 3;
const int ledPin4 = 4;
const int ledPin5 = 5;
const int pingPin = 7;
const int lampPin = 13;

// Create variables to store LED states / lamp state
int ledState1 = LOW;
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
int ledState5 = LOW;
int lampState = LOW;
void setup() {

// Servo pin definition
myservo.attach(10);

//Define pins 1-5, lamp pin as output
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
pinMode(ledPin5, OUTPUT);
pinMode(lampPin, OUTPUT);
}
void loop()
{
// Reset LEDs levels to low to begin loop
ledState1 = LOW;
ledState2 = LOW;
ledState3 = LOW;
ledState4 = LOW;
ledState5 = LOW;
// Reset Servo position to initial location
pos = 0;

// Set duration variable
long duration, cm;

// Loop section for ping signal pin…start as output
pinMode(pingPin, OUTPUT);
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingPin, LOW);

// Listen with same pin
pinMode(pingPin, INPUT);
duration = pulseIn(pingPin, HIGH);

// Convert time to a distance
cm = microsecondsToCentimeters(duration);

// Configure this for LED sensitivity
delay(100);

// March through cm values…set levels where appropriate
if (cm < 95) {
ledState1 = HIGH;}

if (cm < 60) {
ledState2 = HIGH;}

if (cm < 40) {
ledState3 = HIGH;}

if (cm < 25) {
ledState4 = HIGH;}

if (cm < 10) {
ledState5 = HIGH;}

if (cm < 40 && cm >= 30 ) {
lampState = HIGH;}

if (cm < 25 && cm >= 15 ) {
lampState = LOW; }

if (cm < 10) {
pos =( pos + 14 ); }

// fire all LED values...fire servo...fire lamp
digitalWrite(ledPin1, ledState1);
digitalWrite(ledPin2, ledState2);
digitalWrite(ledPin3, ledState3);
digitalWrite(ledPin4, ledState4);
digitalWrite(ledPin5, ledState5);
digitalWrite(lampPin, lampState);
myservo.write(pos);

delay(100);

}
long microsecondsToCentimeters(long microseconds)
{
// 340 meters per second...do some math
return microseconds / 29 / 2;
}

As the code implies, I have set this thing up to look for pings in particular regions. The LEDs indicate where I am at, and the rest sort of plays out from there. The lamp is set up as a switch, with ON and OFF having separate regions. The servo/g-door opener is a simple ON when the region is occupied…similar to my previous setup.

Pretty flipping sweet. As usual, send any feedback my way. This is still in the proof-of-concept mode, and will likely get scrapped for parts soon. Not to mention, Katie will probably want to be able to use the garage door opener, which I disconnected to string that wire that I have running manually to the servo. Be prompt.

Ronco alert

Check this footage of the OOM3K in action. Here, I had it configured to open the door when the ultrasonic sensor echoes off of something within 8 cm…

After the bump, of course

Not only is this thing awesome, but you can get all sorts of clear looks at my trusty Ronco Showtime rotisserie oven. Yard bird is a big hit at the old Swanson place.

There is not much to this code…I built it on top of the LED binary project code. Prepare for a bitchin’ snippet.

//Open-er-o-matic 3000

// Joseph Swanson | 2011
// http://swantron.com

// Setup
// LEDs connected to pins 11, 2-5
// Ping))) sensor signal to pin 7
// Servo signal to pin 10
// Ping))) +, servo + to 5V
// Ground the shit out of everything

#include

Servo myservo;

int pos = 0;

// Pin assignment
const int ledPin1 = 11;
const int ledPin2 = 2;
const int ledPin3 = 3;
const int ledPin4 = 4;
const int ledPin5 = 5;
const int pingPin = 7;

// Create variables to store LED states
int ledState1 = LOW;
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
int ledState5 = LOW;

void setup() {

myservo.attach(10);

//Define pins 1-5 as output
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
pinMode(ledPin5, OUTPUT);
}
void loop()
{
// Reset LEDs levels to low to begin loop
ledState1 = LOW;
ledState2 = LOW;
ledState3 = LOW;
ledState4 = LOW;
ledState5 = LOW;
pos = 0;

// Set duration variable
long duration, inches, cm;

// Loop section for ping signal pin…start as output
pinMode(pingPin, OUTPUT);
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingPin, LOW);

// Listen with same pin
pinMode(pingPin, INPUT);
duration = pulseIn(pingPin, HIGH);

// Convert time to a distance
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);

// Configure this for LED sensitivity
delay(500);

// March through cm values…output LEDs an servo
if (cm < 80) {
ledState1 = HIGH;}

if (cm < 64) {
ledState2 = HIGH;}

if (cm < 48) {
ledState3 = HIGH;}

if (cm < 32) {
ledState4 = HIGH;}

if (cm < 16) {
ledState5 = HIGH; }

if (cm < 16) {
pos =( pos + 14 ); }

// fire all LED values...fire servo
digitalWrite(ledPin1, ledState1);
digitalWrite(ledPin2, ledState2);
digitalWrite(ledPin3, ledState3);
digitalWrite(ledPin4, ledState4);
digitalWrite(ledPin5, ledState5);
myservo.write(pos);

delay(100);

}
long microsecondsToInches(long microseconds)
{
// 1130 feet per second...transofrm inches
return microseconds / 74 / 2;
}
long microsecondsToCentimeters(long microseconds)
{
// 340 meters per second...transform cm
return microseconds / 29 / 2;
}

I hope you enjoyed this one. I had a fun time with this piece of crap. Plus, it has given me some ideas of how to extend this setup into something more refined. Spoiler: more awesome.

Picture time:

doing work at work, again

Follow the bump for a vid / snippet

Video time:

Snippet time:

//Ping LED Levels

// Joseph Swanson | 2011
// http://swantron.com

// Setup
// LEDs connected to pins 11, 2-6
// Ping))) sensor signal to pin 7
// Ping))) + to 5V, – to ground

// Pin assignment
const int ledPin1 = 11;
const int ledPin2 = 2;
const int ledPin3 = 3;
const int ledPin4 = 4;
const int ledPin5 = 5;
const int ledPin6 = 6;

const int pingPin = 7;

// Create variables to store LED states
int ledState1 = LOW;
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
int ledState5 = LOW;
int ledState6 = LOW;

void setup() {

// Start serial

Serial.begin(9600);

//Define pins 1-6 as output
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
pinMode(ledPin5, OUTPUT);
pinMode(ledPin6, OUTPUT);

}
void loop()
{

// Reset LEDs levels to low to begin loop

ledState1 = LOW;
ledState2 = LOW;
ledState3 = LOW;
ledState4 = LOW;
ledState5 = LOW;
ledState6 = LOW;

// Set duration variable

long duration, inches, cm;

// Loop section for ping signal pin…start as output
pinMode(pingPin, OUTPUT);
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingPin, LOW);

// Listen with same pin
pinMode(pingPin, INPUT);
duration = pulseIn(pingPin, HIGH);

// Converttime to a distance

inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);

// Write to serial out
Serial.print(inches);
Serial.print(“in, “);
Serial.print(cm);
Serial.print(“cm”);
Serial.println();

// Configure this for fine tuning… 50 is noisy
delay(75);

// March through cm values…output
if (cm < 128) {

ledState1 = HIGH;}

if (cm < 64) {

ledState2 = HIGH;}

if (cm < 32) {

ledState3 = HIGH;}

if (cm < 16) {

ledState4 = HIGH;}

if (cm < {

ledState5 = HIGH; }

if (cm < 4) {

ledState6 = HIGH;}

// fire all LED values
digitalWrite(ledPin1, ledState1);
digitalWrite(ledPin2, ledState2);
digitalWrite(ledPin3, ledState3);
digitalWrite(ledPin4, ledState4);
digitalWrite(ledPin5, ledState5);
digitalWrite(ledPin6, ledState6);

}
long microsecondsToInches(long microseconds)
{
// 1130 feet per second...transofrm inches

return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
// 340 meters per second...transform cm
return microseconds / 29 / 2;
}

Synopsis time:

The code fires the ultrasonic sensor via a digital pin, listens via the same pin, does a little math to transform times to distances using the speed of sound, takes the distances and writes to various LEDs depending upon the value returned.

Think of the backup collision sensors that ship with many new vehicles…same deal. Instead of firing a speaker, I have fired 6 lights instead…more accurate, FTW!

I sort of want to mount this bad boy on my Trail-90. Or my Yukon…that would be ghetto goddamn fabulous. For real.

Thanks for reading. Happy Tuesday.