I’ve wanted to do a 555 timer project for awhile since they’re cheap and it’s been a long while since I’ve done a project with absolutely no programming. After looking at a few circuits online and messing around with the parts that I had on hand I ended up making the following schematic:

The parts list is:

• R1 – 47 ohm resistor
• R2 – 4700 ohm resistor
• C2 – 470 micro-farad capacitor
• U1 – 555 timer
• Q1 – BC547C NPN transistor
• D1 – an LED
• V1 – a 5 volt power source. I made some figures powered by 5V wall warts, and others I made USB powered.

Here’s a video of it in action

Once the circuit was tested and working I had to figure out how to stick it into a clay figure. As I saw it there were two options. I could build the circuit and then cover it in clay, or I could build the clay figure and then stick the components into it. I ended up having better luck building the circuit first, since it was easier to test that it was working before sticking it in the clay. To do this I soldered all the components together “dead bug style”. This entails soldering the components together without using any sort of circuit board as a base. Here are a few examples:

I then built the clay figures around these circuits taking care not to short anything. I used a cheap skulpty like material that dried in air without the need for a kiln. Initially, I found that the circuits would stop working when encased in clay. It appears that the wet clay is a weak conductor, and that these “shorts” were enough to prevent the circuits from functioning correctly. I even tried to encase the entire circuit in heat shrink and insulation, but not even that worked.

It turned out that I just needed to be patient, after waiting about a week the clay dried and my figures worked perfectly. Here are a few more pictures and videos of the results.

Vs

Parts list:

• Fruit Cake Tin – Any round tin would work for the enclosure, I got this one from the thrift store for 50 cents
• Clock Radio – Something that is reasonably close to being able to fit in the tin. I also got mine from the thrift store for $3
• Piece of Plastic – I bought a 11″x14″ piece from home depot, for $4 making this the most expensive component

Next I dissected the clock radio. Originally I was hoping to drive some blinking lights with some of the clocks circuitry, but it turns out that the clock that I found used a fairly interesting scheme for controlling the LEDs. The clock chip was a lm8560. The AC power coming in goes through a transformer which steps the voltage down to 20V peak-to-peak. As the power oscillates from +10 to -10 the controller switches which segments of the display are being powered. In any case I decided that I would leave well enough alone and concentrate on fitting the circuit into the tin.

The clock radio I used looked like this

In order to fit the board into the tin I needed to rotate the display 90 degrees so that it faced upward. This meant that there was no way that I could reuse the original set of controls. I didn’t feel the need to preserve all of the radio and alarm functionality so I decided to make the only input the time setting controls.

First I removed a four position switch that was used to change the alarm/radio mode and hard wired the connections to the position that disabled the alarm. Next I spent some time figuring out how the buttons on the original panned were used to set the time. This clock had the scheme where you hold down a “time” button and then press a minute or hour button. Turns out the time button just connected the hour and minute buttons to their common ground. I ended up wiring the switch so it would switch between no connections, and connecting the minute and hour inputs to ground so you could get the original controls but in switch form.

Before I mounted the clock circuit into the tin I desoldered some of the extra parts like the speaker and the original input circuitry. The clock circuit was just barely to big to fit, so I had to cut off some of the corners which fortunately didn’t contain anything important. I screwed the clock circuit back onto the plastic bottom of the clock which I cut down to a size that would fit. To put everything together I had to I ended up gluing the switch, cables, and circuitry in place with epoxy. I cut a little chunk out of the tin for the cable to fit through and bent back the metal so the cord wouldn’t be sitting on a sharp edge. With all the done the tins lid could still be taken off and on giving access to the inner side of the plastic and the clock circuitry.

I painted the colored parts of the clock face on the inside of the plastic, and doing the black sections on the outside with a sharpy. I’m sure there’s a better way since the paint I used could be easily be chipped off if it rubbed against anything sharp, but still it ended up looking pretty nice.

My Baby!

http://arstechnica.com/security/2012/12/how-to-bring-down-mission-critical-gps-networks-with-2500/

I didn’t do too much of the actual meat of the software. My job was mostly to program the inter-board communication, set up the kernel and software on the main processor, and do some of the hardware development to connect everything together.

This work previously had a minor mention in Slashdot http://it.slashdot.org/story/12/12/10/0012217/researchers-find-crippling-flaws-in-global-gps

I thought about timing my drive, but that would only gather data about my current commute times. I decided that the easiest way to get a rough sense of the best drive time, and how much it mattered would be to get the traffic estimates from a web service. Unfortunately, I was unable to find any site that offered traffic estimates for any time besides the present. If I wanted to gather information about how the estimates changed over time I would have to collect the data myself.

At first I thought that I could just write a simple HTTP client that would query a web service with my commute information, and then parse out the traffic information. I quickly learned that Google Maps tries to prevent this sort of behavior. I may have been able to get around this, but even the on sites that did allow me to download the html I couldn’t parse out the traffic data since it was populated with the pages javascript.

I figured this out by playing with the developers console in chrome. I could pull the information out from the page loaded in chrome by writing javascript. Unfortunately, executed my custom javascript on a page turned out to be a little tricky. I could do it through the developers console, or by writing bookmarklets, but I wanted a more automated system that could easily be scheduled and produce file output.

My first instinct was to try to write some sort of (cross site scripting) XSS hack. What this would do is load my page with my javascript along with the page containing the traffic info. My code would then access the traffic information and do something with it. I quickly realized that this was a bad idea for all sorts of reasons. This is exactly the sort of behavior that a virus would have, and all of these sorts of operations are made nigh impossible by browser security features and language limitations on javascript.

I then remembered that there were special scripting plugins for browsers that were made to run custom code on pages as they load. The most popular is for Firefox and is called Greasemonkey. Well I was able to use Greasemonkey to access the traffic information on Google Maps, but I wasn’t able to write it to a file. This is an intentional limitation of Greasemonkey and is there for security reasons. In any case doing the kind of repeated automatic data collect that I was hoping for, wouldn’t have been particularly natural in Greasemonkey anyway.

I finally found a solution that worked nearly perfectly in an unusual place. Apparently, it’s not uncommon to use tools originally designed for automated web site testing to do the sort of javascript scraping that I was trying to accomplish. I quickly settled on Selenium as my system. The key feature that Selenium offered was its Firefox plugin. This IDE let me perform the query and select the data I wanted in a very natural way by using the browser. Once I got the commands I needed I was able to export this to python code to wrap a loop around and perform the logging of the information. Here’s my modified version of the generated code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import Select
from selenium.common.exceptions import NoSuchElementException
import unittest, time, re
import datetime
 
SLEEP_TIME=60*10
END_TIME=9
 
class MapTest(unittest.TestCase):
	def setUp(self):
		self.driver = webdriver.Firefox()
		self.driver.implicitly_wait(30)
		self.base_url = "http://maps.google.com/"
		self.verificationErrors = []
 
	def test_map(self):
		now=datetime.datetime.now()
		driver = self.driver
		with open(now.strftime("%m_%d_%Y_%H_%M_")+"trafficLog.txt", 'w') as f:
			while datetime.datetime.now().hour<END_TIME:
				driver.get(self.base_url + "/")
				driver.find_element_by_id("d_launch").click()
				driver.find_element_by_id("d_d").clear()
				driver.find_element_by_id("d_d").send_keys("My Address, CA")
				driver.find_element_by_id("d_daddr").clear()
				driver.find_element_by_id("d_daddr").send_keys("Work Address, CA")
				driver.find_element_by_id("d_sub").click()
				driver.find_element_by_id("d_sub").click()
				for i in range(60):
					try:
						if driver.find_element_by_css_selector("div.altroute-rcol.altroute-aux > span").is_displayed(): break
					except: pass
					time.sleep(1)
				else: self.fail("time out")
				variable1 = driver.find_element_by_css_selector("div.altroute-rcol.altroute-aux > span").text
				f.write(datetime.datetime.now().strftime("%H:%M")+" - "+variable1+"\n")
				f.flush()
				time.sleep(SLEEP_TIME)
 
	def is_element_present(self, how, what):
		try: self.driver.find_element(by=how, value=what)
		except NoSuchElementException, e: return False
		return True
 
	def tearDown(self):
		self.driver.quit()
		self.assertEqual([], self.verificationErrors)
 
if __name__ == "__main__":
	unittest.main()

I then scheduled this, and a slightly modified version of the script for my home commute, to run at the earliest I would consider starting my trips. The code runs until the hour specified by END_TIME, and makes a file with the start time in the name as an output. By collecting this and pulling out the specific traffic information I should have all the info I need.

This is still not a perfect solution. I in order to run this you at least need to have python and its Selenium client installed. Selenium must actually run the browser in order to do the data collection, so you can’t really have it run in the background. I decided to mitigate this issue by having it run on a virtual machine. All in all a much more complicated solution then I was expecting, but at least it was time better spent then sitting in traffic.

The NAS server was a QNAP which has some security center software built in. It was mainly focused on connecting to networked security cameras, but it did support some basic functionality for webcams. Unfortunately, it did not support any of the motion detection features.

The NAS server let you SSH and install packages with ipkg. I found a package called motion, here’s a forum post that led me through the basic setup http://forum.qnap.com/viewtopic.php?p=273345

Here’s a copy of the post for posterity:

 

There’s an Optware package called “motion”, which can do motion detection.

I installed it a day ago and so far it works very well together with a Logitech USB camera. It can take interval snapshots, and record jpg and/or avi once motion is detected. With a frame rate of 5 and a 640×480 resolution my TS-212 uses around 30% CPU. With a lower frame rate the CPU usage is accordingly lower. In contrary to that, QUSBCam with firmware 3.7.1 took 100% all the time even at one frame per second and quarter VGA resolution.

To get it working just

• install the Optware QPKG
• install the motion IPKG
• install the nano IPKG (simple text editor for editing the config file)
• Activate SSH, if not already active
• Use ssh to log onto the NAS
• edit the config file /opt/etc/motion.conf by typing

  nano /opt/etc/motion.conf

  and change the output path to something reasonable, e.g.

  target_dir /share/Recordings/MyUSBCam

• if you want videos, then you have to activate the switch in the config file, there are lots of comments in the file. Find the entry ffmpeg_cap_new and change it from off to on

  ffmpeg_cap_new on

• Save the file (Ctrl-O) and exit (Ctrl-X)
• Run motion

  /opt/etc/init.d/S99motion

If you want to start motion at system startup you have to apply the optware startup patch, that you can find somewhere in this forum.

It took me a little bit of fiddling to get things working, but everything worked as advertised. Once a motion is detected for some configurable amount of time, it triggers an event. This event continues until no motion is detected for some amount of time and then the event ends. This would prevent my inbox from getting an inordinate amount of photos. There is a setting on_event_start that tells motion to run a command at the start of an event.

I wasted a decent amount of time trying to send an email with a bash command, but I wasn’t having any luck. I’m sure it easy if you know what you’re doing, but most of the packages seemed more geared toward running a mail server then a simple notifier. Eventually I went with a solution I had used in the past, Python.

I installed python and wrote up the following script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import smtplib
import sys  
 
fromaddr = '' 
toaddrs = '' 
msg = 'There was a motion detected!'
 
# Credentials (if needed)
username = ''
password = ''
 
# The actual mail send
server = smtplib.SMTP('smtp.gmail.com:587') 
server.starttls()
server.login(username,password)
 
#get the file name from stdin
file='/share/Recordings/motion/'+sys.stdin.read().strip('\n')
 
# Here are the email package modules we'll need
from email.mime.image import MIMEImage 
from email.mime.multipart import MIMEMultipart 
COMMASPACE = ', '
# Create the container (outer) email message.
msg = MIMEMultipart() 
msg['Subject'] = 'Detection'
msg['From'] = fromaddr
msg['To'] = toaddrs
msg.preamble = 'Detection'
# Assume we know that the image files are all in PNG format
# Open the files in binary mode.  Let the MIMEImage class automatically guess the specific image type.
fp = open(file, 'rb')
img = MIMEImage(fp.read())
fp.close()
msg.attach(img)
# Send the email via our own SMTP server.
server.sendmail(fromaddr, toaddrs, msg.as_string())
server.quit()

Of course you need to replace the from/to address ,the username, and  the password to the correct values. You would also need to set the file location to the same configuration you used in motion.conf

Then I edited on_event_start in motion.conf

on_event_start ls /share/Recordings/motion/ -tr|tail -1|python /home/test/sendtest.py

This took me a bit to write since I’m not a super wizard with bash scripting. What this setting does is run these commands when an event occurs. I configured motion to output the webcam images to the folder /share/Recordings/motion/, so this command lists all the files in this directory sorted by time and sends the name of the most recent image into the python script through stdin.

Once that was all done I had the solution that I wanted that worked like a charm while I was away. I would send a few false positives a day, which was actually kind of nice since it let me know things were still working.

All in all not the cleanest system in the world. Networked webcams aren’t that expensive and would have been much easier to deal with. The whole system isn’t that secure since of course the whole server could have been stolen and all I would end up with is a few pictures of the perp. Still for something that was thrown together after packing, it fulfilled it’s purpose.

This is a very simple evolution simulator.

Selecting a type (plant or animal) you can place creatures on the board by clicking on the white area.
They will try to survive and reproduce with their genes represented by their color. Time can be sped or slowed by changing the time speed value.
There is a genome that encodes some of their traits that can be editted, but right now it is very primitive.

A project at the Karlsruhe Institute of Technology, in Germany, to use accelerometers to track heart motion to aid in robotic surgery.

The final design involved having MEMS 3 axis accelerometers on tiny custom PCBs connect to an arduino through a I2C multiplexer. The Arduino would transmit the data to a PC which would process it.

Here are some pictures of the project

As part of a project for the machine learning lab at Cornell, I did the hardware and some of the software to make a stock RC car autonomously drift though a track.

The microcontroller that drove the car from the remote control was put on a switch with an Arduino. The Arduino was connected to an XBEE wireless transceiver. The Arduino would process the sensor data and control the motors, relaying the information to a PC. The Arduino used a PID controller to navigate a pre-mapped course.

Here are some more pictures

Final project for ECE 576 at Cornell, click here for the project write up