The Internet was Moved?

I’m working late in lab (as usual) and I went to open Firefox (my default web browser), so I clicked Start and selected “Mozilla Firefox” at the top (where your default browser usually goes in XP). Nothing happened… then this message popped up! I had to take a screen shot because it’s so bizarre.

I swear this is straight from my screen (PrntScrn -> mspaint (pasted) -> PNG) with no modifications. I especially love how the computer is trying to tell me what could have gone wrong; the internet might have been moved, renamed, or removed. Slick.


     

Analyzing my Writings with Python

*I spent the day* in the lab with some random time on my hands between adding reagents to an ongoing immunohistochemical reaction I was performing. At one point I decided to further investigate the field of bioinformatics (is it worth seeking a PhD in this field if I don’t get into dental school again?). UCF offers a PhD in bioinformatics but it’s a new and small department (I think there are only 4 faculty). The degree itself is a degree in computer science (the logic side of computers, more programming than designing hardware). A degree in bioinformatics combines molecular biology (DNA, proteins, etc), computer science (programming), and statistics (developing code to analyze biological data). I feel a need to express what it is, because it’s not something that is commonly understood. Do you know what people who study bioinformatics do?

*I came across a paper* today “Structural Alignment of Pseudoknotted RNA”:http://cseweb.ucsd.edu/users/shzhang/app/RECOMB2005_pseudoknot.pdf (by Han B, Dost B, Bafna V, and Zhang S.) which is a good example of the practice of bioinformatics. Think about what goes on in a cell… the sequence of a gene (a short region of DNA) is copied (letter-by-letter) onto an RNA molecule. The RNA molecule is later read by an enzyme (called a ribosome) and converted into a protein based on its sequence. (This process is the central dogma of molecular biology) Traditionally, it was believed that RNA molecules’ only function was to copy gene sequences from DNA to ribosomes, but recently (the last several years) it was discovered that some small RNA molecules are never read and turned into proteins, but rather serve their own unique functions! For example, some RNA molecules (siRNAs) can actually turn genes on and off, and have been assosiated with cancer development and other immune diseases. Given the human genome (the ~3 billion letter long sequence all of our DNA), how can we determine what regions form these functional RNA molecules which don’t get converted into proteins? The paper I mentioned earlier addresses this. An algorithm was developed and used to test regions of DNA and predict its probability of forming small RNA molecules. Spikes in this trace (figure 7 of the paper) represent areas of the DNA which are likely to form these RNA molecules. (Is this useful? What if you were to compare these results between normal person and someone with cancer?)

*After reading the article* I thought to myself “Hmmm… logically manipulating large amounts of linear data… why does this seem familiar?” Then I realized how similar my current programming projects are with this one. (see “my latest DIY ECG data”:http://www.swharden.com/blog/images/ecg_goodie.png posted a couple days ago) Consider the trace (pictured, figure 7 in “Structural Alignment of Pseudoknotted RNA”:http://cseweb.ucsd.edu/users/shzhang/app/RECOMB2005_pseudoknot.pdf) of score (the likelihood that a region of DNA forms an RNA molecule), where peaks represent likely locations of RNA formation. Just generate the trace, determine the positions of the peaks, and you’re golden. How similar is this to the work I’ve been doing with my homemade ECG machine, where I perform signal analysis to eliminate electrical noise and then analyze the resulting trace to isolate and identify peaks corresponding to heartbeats?

*After reading* I shivered from mental-overload. There are so many exciting Python projects in the field of bioinformatics that are just waiting for me to begin work on! I know I’m like a child sometimes, but hey it’s my personality. I get excited. It’s just that I get excited about tacky things these days. Anyway, I got the itch to write a string-analysis program. What does it do? It reads the content of my website (exported in the form of a SQL backup query generated by PHPmyAdmin, pictured), splits it up by date, and allows for its analysis. Ultimately I want to track the usage of certain words (i.e.: the inverse relationship between the words “girls” and “python”), but for now I wrote a script which plots the number of words I wrote. Observe the output.

*Pretty cool huh?* Check out all those spikes between 2004 and 2005! (previous figure) Not only are they numerous (meaning many posts), but they’re also high (meaning many words per post). As you can see by the top trace, the most significant contribution to my site occurred during this time. So, let’s zoom in on it! (next figure)

*And of course, the code to produce this…* (obviously you have to have a wordpress backup SQL file in the same folder – if you want mine let me know and I’ll email it to ya’)

import datetime, pylab, numpy
# Let's convert SQL-backups of my WordPress blog into charts! yay!
class blogChrono():
    baseUrl="http://www.SWHarden.com/blog"
    posts=[]
    dates=[]
    def __init__(self,fname):
        self.fname=fname
        self.load()
    def load(self):
        print "loading [%s]..."%self.fname,
        f=open(self.fname)
        raw=f.readlines()
        f.close()
        for line in raw:
            if "INSERT INTO" in line
            and';' in line[-2:-1]
            and " 'post'," in line[-20:-1]:
                post={}
                line=line.split("VALUES(",1)[1][:-3]
                line=line.replace(', NULL',', None')
                line=line.replace(", '',",", None,")
                line=line.replace("''","")
                c= line.split(',',4)[4][::-1]
                c= c.split(" ,",21)
                text=c[-1]
                text=text[::-1]
                text=text[2:-1]
                text=text.replace('"""','###')
                line=line.replace(text,'blogtext')
                line=line.replace(', ,',', None,')
                line=eval("["+line+"]")
                if len(line[4])>len('blogtext'):
                    x=str(line[4].split(', '))[2:-2]
                    raw=str(line)
                    raw=raw.replace(line[4],x)
                    line=eval(raw)
                post["id"]=int(line[0])
                post["date"]=datetime.datetime.strptime(line[2],
                                                        "%Y-%m-%d %H:%M:%S")
                post["text"]=eval('"""'+text+' """')
                post["title"]=line[5]
                post["url"]=line[21]
                post["comm"]=int(line[25])
                post["words"]=post["text"].count(" ")
                self.dates.append(post["date"])
                self.posts.append(post)
        self.dates.sort()
        d=self.dates[:]
        i,newposts=0,[]
        while len(self.posts)>0:
            die=min(self.dates)
            for post in self.posts:
                if post["date"]==die:
                    self.dates.remove(die)
                    newposts.append(post)
                    self.posts.remove(post)
        self.posts,self.dates=newposts,d
        print "read %d posts!n"%len(self.posts)

#d=blogChrono('sml.sql')
d=blogChrono('test.sql')

fig=pylab.figure(figsize=(7,5))
dates,lengths,words,ltot,wtot=[],[],[],[0],[0]
for post in d.posts:
    dates.append(post["date"])
    lengths.append(len(post["text"]))
    ltot.append(ltot[-1]+lengths[-1])
    words.append(post["words"])
    wtot.append(wtot[-1]+words[-1])
ltot,wtot=ltot[1:],wtot[1:]

pylab.subplot(211)
#pylab.plot(dates,numpy.array(ltot)/(10.0**6),label="letters")
pylab.plot(dates,numpy.array(wtot)/(10.0**3),label="words")
pylab.ylabel("Thousand")
pylab.title("Total Blogged Words")
pylab.grid(alpha=.2)
#pylab.legend()
fig.autofmt_xdate()
pylab.subplot(212,sharex=pylab.subplot(211))
pylab.bar(dates,numpy.array(words)/(10.0**3))
pylab.title("Words Per Entry")
pylab.ylabel("Thousand")
pylab.xlabel("Date")
pylab.grid(alpha=.2)
#pylab.axis([min(d.dates),max(d.dates),None,20])
fig.autofmt_xdate()
pylab.subplots_adjust(left=.1,bottom=.13,right=.98,top=.92,hspace=.25)
width=675
pylab.savefig('out.png',dpi=675/7)
pylab.show()

print "DONE"

*I wrote a Python script to analyze the word frequency* of the blogs in my website (extracted from an SQL query WordPress backup file) for frequency. “This is what I came up with”:http://swharden.com/little/worddump.html I then took my giant list over to “Wordie”:http://www.wordle.net/create and had them create a super-cool little word jumble. Neat, huh? Here’s “a picture”:http://www.SWHarden.com/blog/images/wordie2.png that’s cool but not worth posting.

*This is the script to make the worddump:*

import datetime, pylab, numpy
f=open('dump.txt')
body=f.read()
f.close()
body=body.lower()
body=body.split(" ")
tot=float(len(body))
words={}
for word in body:
    for i in word:
        if 65< =ord(i)<=90 or 97<=ord(i)<=122: pass
        else: word=None
    if word:
        if not word in words:words[word]=0
        words[word]=words[word]+1
data=[]
for word in words: data.append([words[word],word])
data.sort()
data.reverse()
out= "<b>Out of %d words...n"%tot
xs=[]
for i in range(1000):
    d=data[i]
    out += '<b>"%s"</b> ranks #%d used <b>%d</b> times (%.05f%%)
n'%
                (d[1],i+1,d[0],d[0]/tot)
f=open("dump.html",'w')
f.write(out)
f.close()
print "DONE"

     

Celebrity Dwarf Gouramis

So I was reviewing my website statistics generated by a Python script I wrote when I noticed a peculiarity so bizarre that it made me questin the very purpose of my life. Okay maybe it wasn’t that bizarre, but it was interesting. The python script (which is automatically run every hour) downloads my latest access.log and saves it to its own folder. It then analyzes the data, creates some charts and graphs, and dumps out a bare-bones results file displaying some of the information I found useful. Of note is the number of times each page is hit.

This is where things get funny. Outperforming my home page by nearly double was indexOld.php (now indexOld22.php) – a simple webpage I tossed of for about a year before I put my big blog back online! Why were people still going to this page? Further investigation (from the referring sites section of my stats page) revealed a lot of hits from Google image-searches. I started looking at the actual requests and realized that many of these hits were people searching for the term Dwarf Gouramis “a type of freshwater aquarium fish) which was mentioned on that old webpage. The ironic part about it is what happens when you google image search for dwarf gouramis there is a picture of an extremely rare zebra pleco which is actually a link to my website! However the link APPEARS to be to wallpaperfishtalk.com because on my page I just linked to their image.

My conclusion: People are Google image-searching for ‘dwarf gouramis’, and an amazing picture of a zebra pleco is coming up which links to my site (due to the fact that months ago I talked about dwarf gouramis but posted a photo of a zebra pleco) and people (in their awe at this amazing fish) are clicking on it. So what did I do? I pulled a bait-and-switch! You bet I did. Now when you go to indexOld2.php it just forwards you to my current website – mua ha ha ha ha

PS: I’m appending to this entry at 2:17pm to note that I made a wonderful breakthrough in the lab today. Due to intellectual property protection blah blah and the fact that I don’t want anyone else to beat me to my research goal I will not describe what this is, I’ll just say that it took months of preparation and today – presto! It worked beautifully =oD


     

Head-on

I know I wrote less than an hour ago but I found this and had to put it on my site because it is so freaking awesome. How do I randomly find the coolest crap on the internet? I was actually google image-searching for wrist-clamp ECG electrodes and I found this guy.

Apparently this is art by Cai Guo-Qiang seen in the Deutsche Guggenheim in Berlin.


     

I'm in Love with InkScape

It’s 2:15 am and I can’t sleep, so what do I do? I hope on my laptop and try out new linux software! First of all, I wanted to note that I’ve been afflicted by the mysterious case of the disappearing xmms. Xmms is a linux-based audio player nearly identical to >”Winamp. Traditionally (several months ago) I could just type sudo apt-get install xmms; xmms and xmms would install and run on my Ubuntu system with a user-friendly frontend. Now it seems that xmms is gone – replaced by xmms2 which appears to be an audio server with no front end. Wha? I didn’t put much effort into trying to figure out how to get a front end to xmms2, but brief Googling suggested that xmms2 doesn’t actually have a front-end. Today I realised that you have to install a completely separate package to get a front-end, based on xmms2. It basically acts just like xmms did (pictured). The program is called audacious, and can be installed with sudo apt-get install audacious on an Ubuntu system. Yay! Back to normal.
response to inquiry: the songs in the playlist is a short collection of songs by Splashdown (an extinct late-90s indie band I fell in love with when I was ~13) – believe it or not, all of their music can be downloaded from this website – super awesome huh? I especially recommend halfworld, ironspy, running with scissors, and waterbead (in that order). A few songs in the list are actually from Universal Hall Pass which is a different band with the same lead singer (Melissa Kaplan).

I have to admit that tonight I was blown away by the awesomeness of Inkscape – a vector drawing tool (similar to Adobe Illustrator) which is going to become my next best friend. Like I said, it does pretty much what Illustrator does, but for free! (Illustrator is about $250) It does so much cool stuff and I just realised it would be so freaking awesome to design a website layout using it. I have to admit, for the first 20 minutes I was totally lost – I had a hard time figuring out how to draw a line! But after a little more time, it became really natural, and this program is – jeez – I can’t get over how useful this can be. I decided to get used to this program by drawing-out a schematic of the circuit from my DIY ECG Project (The result is posted at the bottom of this entry, and a screenshot of the creation process is pictured to the side). I know that I will have tremendous use for this software, possibly in the creation of diagrams of the autonomic nervous system for my master’s thesis or perhaps even for a publication… [ponders] Okay I have to get to bed!

Take it from me. Download InkScape (it looks like they have a Windows version, btw) and if you have Ubuntu, install audacious for your music. Scott out.


     

Using PHP to Create Apache-Style Access.log

THIS CODE HAS BEEN UPDATED!
THIS CODE HAS BEEN UPDATED!
THIS CODE HAS BEEN UPDATED!

>>> CHECK OUT THE NEW CODE < << [Generate Apache-Style HTTP Access Logs via SQL and PHP]

OBSOLETE CODE IS BELOW…

My web server blocks access to my apache-generated visitor logs (commonly stored in “access.log”). Therefore, many great site usage stats generators (such as awstats – see this example) cannot be used to analyze web traffic to my site. (How many people go what pages? Where do they come from? What search phrases do they type into Google to find my website?) My web host does allow PHP, and access to php.ini, so I figured that I could generate my own access.log using PHP code. I succeeded, but had a hard time doing this because it’s not clearly documented elsewhere – so I’ll make it clear.

Sample line from access.log generated by my PHP script:
132.170.10.227 – – [22/Jan/2009:11:58:49 +0800] “GET /blog/2005-06-29-eva-05-attack-scotts-sanity/ HTTP/1.1” 200 – “http://www.google.com/search?hl=en&client=firefox-a&rls=org.mozilla%3Aen-US%3Aofficial&hs=8Lk&q=swharden+eva-05&btnG=Search” “Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.5) Gecko/2008120122 Firefox/3.0.5”

All I had to do was insert the following line at the end of my php.ini file:

  

 auto_append_file = "/home/content/n/i/b/nibjb/html/logme.php"  

 

And I placed logme.php in my root folder with the following code:

  

 $logwriter_logformat = "combined"; // log format,combined or common  

 $logwriter_logdir = "/home/content/n/i/b/nibjb/html/logs/"; // physical path where your log file located  

 $logwriter_logfilename = "access.log"; // your log file's filename  

 $logwriter_timezone = "+0800"; // your server's time zone. +0800 means GMT+8  

   

 function logwriter_writelog($logstring){  

   

 global $logwriter_logdir,$logwriter_logfilename;  

 $fullpathfilename = $logwriter_logdir.$logwriter_logfilename;  

   

 if (!is_file($fullpathfilename)) {  

 print "Log file doesn't exist or file is corrupt.";  

 return;  

 }  

   

 if (!is_writeable($fullpathfilename)) {  

 print "Log file is not writable,please change its permission.";  

 return;  

 }  

   

 if($fp = @fopen($fullpathfilename, "a")) {  

 flock($fp, 2);  

 fputs($fp, $logstring);  

 fclose($fp);  

 }  

 }  

   

 function logwriter_handlevar($varname,$defaultvalue) {  

 $tempvar = getenv($varname);  

 if(!empty($tempvar)) {  

 return $tempvar;  

 } else {  

 return $defaultvalue;  

 }  

 }  

   

 if (!empty($REMOTE_HOST)) {  

 $logwriter_remote_vistor = $REMOTE_HOST;  

 }else{  

 $logwriter_remote_vistor = logwriter_handlevar("REMOTE_ADDR","-");  

 }  

   

 $logwriter_remote_ident = logwriter_handlevar("REMOTE_IDENT","-");  

 $logwriter_remote_user = logwriter_handlevar("REMOTE_USER","-");  

 $logwriter_date = date("d/M/Y:H:i:s");  

   

 $logwriter_server_port = logwriter_handlevar("SERVER_PORT","80");  

 if($logwriter_server_port!="80") {  

 $logwriter_server_port = <a href="".$logwriter_server_port;"></a>  

 }else{  

 $logwriter_server_port = "";  

 }  

   

 $logwriter_request_method = logwriter_handlevar("REQUEST_METHOD","GET");  

 $logwriter_request_uri = logwriter_handlevar("REQUEST_URI","");  

 $logwriter_server_protocol = logwriter_handlevar("SERVER_PROTOCOL","HTTP/1.1");  

   

 if ($logwriter_logformat=="common") {  

 $logwriter_logstring = "$logwriter_remote_vistor $logwriter_remote_ident $logwriter_remote_user [$logwriter_date $logwriter_timezone] "$logwriter_request_method $logwriter_request_uri $logwriter_server_protocol" 200 - 

 ";  

 }else{  

   

 $logwriter_http_referer = logwriter_handlevar("HTTP_REFERER","-");  

 $logwriter_http_user_agent = logwriter_handlevar("HTTP_USER_AGENT","");  

   

 $logwriter_logstring = "$logwriter_remote_vistor $logwriter_remote_ident $logwriter_remote_user [$logwriter_date $logwriter_timezone] "$logwriter_request_method $logwriter_request_uri $logwriter_server_protocol" 200 - "$logwriter_http_referer" "$logwriter_http_user_agent" 

 ";  

   

 }  

   

 logwriter_writelog($logwriter_logstring);  

 

Note that the PHP code must be surrounded with < ? php ?> as demonstrated here

The result? As you can tell, my logme.php dumps data to www.swharden.com/logs/access.log – if you browse a few pages on my website, or even use Google to search for me (ie: google for ‘swharden’ and ‘minidisc’) you can see yourself in the logfile – pretty cool huh? Once I have a good volume of log data I’ll demonstrate how to turn it into useful information.


     

Signal Filtering with Python

UPDATE: An improved ECG design was posted in August, 2016.
Check out: http://www.swharden.com/wp/2016-08-08-diy-ecg-with-1-op-amp/

It’s time for a lecture. I’ve been spending a lot of time creating a DIY dlectrocardiogram and it produces fairly noisy signals. I’ve spent some time and effort researching the best ways to clean-up these signals, and the results are incredibly useful! Therefore, I’ve decided to lightly document these results in a blog entry.

Here’s an example of my magic! I take a noisy recording and turn it into a beautiful trace. See the example figure with the blue traces. How is this possible? Well I’ll explain it for you. Mostly, it boils down to eliminating excess high-frequency sine waves which are in the original recording due to electromagnetic noise. A major source of noise can be from the alternating current passing through wires traveling through the walls of your house or building. My original ECG circuit was highly susceptible to this kind of interference, but my improved ECG circuit eliminates most of this noise. However, noise is still in the trace (see the figure to the left), and it needed to be removed.

The key is the FFT (Fast Fourier Transformation) algorithm which can get pretty intimidating to research at first! I’ll simplify this process. Let’s say you have a trace with repeating sine-wave-shaped noise. The output of the FFT transformation of the signal is the breakdown of the signal by frequency. Check out this FFT trace of a noisy signal from a few posts ago (top graph). High peaks represent frequencies which are common. See the enormous peak around 60 Hz? (Hz means “per second” by the way, so 60 Hz is a sine wave that repeats 60 times a second) That’s from my AC noise. Other peaks (shown in colored bands) are other electromagnetic noise sources, such as wireless networks, TVs, telephones, and your computer processor. The heart produces changes in electricity that are very slow (the heartbeat is about 1 Hz, or 1 beat per second), so if we can eliminate all of the sine waves with frequencies higher than what we want to isolate we can get a pretty clear trace. This is called a band-stop filter (we block-out certain bands of frequencies) A band-pass filter is the opposite, where we only allow frequencies which are below (low-pass) or above (high-pass) a given frequency. By eliminating each of the peaks in the colored regions (setting each value to 0), then performing an inverse fast Fourier transformation (going backwards from frequency back to time), the result is the signal trace (seen as light gray on the bottom graph) with those high-frequency sine waves removed! (the gray trace on the bottom graph). A little touch-up smoothing makes a great trace (black trace on the bottom graph).

Here’s some Python code to get you started in cleaning-up your noisy signals! The image below is the output of the Python code at the bottom of this entry. This python file requires that test.wav (~700kb) (an actual ECG recording of my heartbeat) be saved in the same folder. Brief descriptions of each portion of the graph will follow.

(A) The original signal we want to isolate. (IE: our actual heart signal)

(B) Some electrical noise. (3 sine waves of different amplitudes and periods)

(C) Electrical noise (what happens when you add those 3 sine waves together)

(D) Static (random noise generated by a random number generator)

(E) Signal (A) plus static (D)

(F) Signal (A) plus static (D) plus electrical noise (C)

(G) Total FFT trace of (F). Note the low frequency peak due to the signal and electrical noise (near 0) and the high frequency peak due to static (near 10,000)

(H) This is a zoomed-in region of (F) showing 4 peaks (one for the original signal and 3 for high frequency noise). By blocking-out (set it to 0) everything above 10Hz (red), we isolate the peak we want (signal). This is a low-pass filter.

(I) Performing an inverse FFT (iFFT) on the low-pass iFFT, we get a nice trace which is our original signal!

(J) Comparison of our iFFT with our original signal shows that the amplitude is kinda messed up. If we normalize each of these (set minimum to 0, maximum to 1) they line up. Awesome!

(K) How close were we? Graphing the difference of iFFT and the original signal shows that usually we’re not far off. The ends are a problem though, but if our data analysis trims off these ends then our center looks great.

Here’s the code I used to make the image:

 import numpy, scipy, pylab, random

 # This script demonstrates how to use band-pass (low-pass)
 # filtering to eliminate electrical noise and static
 # from signal data!

 ##################
 ### PROCESSING ###
 ##################

 xs=numpy.arange(1,100,.01) #generate Xs (0.00,0.01,0.02,0.03,...,100.0)
 signal = sin1=numpy.sin(xs*.3) #(A)
 sin1=numpy.sin(xs) # (B) sin1
 sin2=numpy.sin(xs*2.33)*.333 # (B) sin2
 sin3=numpy.sin(xs*2.77)*.777 # (B) sin3
 noise=sin1+sin2+sin3 # (C)
 static = (numpy.random.random_sample((len(xs)))-.5)*.2 # (D)
 sigstat=static+signal # (E)
 rawsignal=sigstat+noise # (F)
 fft=scipy.fft(rawsignal) # (G) and (H)
 bp=fft[:]
 for i in range(len(bp)): # (H-red)
     if i>=10:bp[i]=0
 ibp=scipy.ifft(bp) # (I), (J), (K) and (L)

 ################
 ### GRAPHING ###
 ################

 h,w=6,2
 pylab.figure(figsize=(12,9))
 pylab.subplots_adjust(hspace=.7)

 pylab.subplot(h,w,1);pylab.title("(A) Original Signal")
 pylab.plot(xs,signal)

 pylab.subplot(h,w,3);pylab.title("(B) Electrical Noise Sources (3 Sine Waves)")
 pylab.plot(xs,sin1,label="sin1")
 pylab.plot(xs,sin2,label="sin2")
 pylab.plot(xs,sin3,label="sin3")
 pylab.legend()

 pylab.subplot(h,w,5);pylab.title("(C) Electrical Noise (3 sine waves added together)")
 pylab.plot(xs,noise)

 pylab.subplot(h,w,7);pylab.title("(D) Static (random noise)")
 pylab.plot(xs,static)
 pylab.axis([None,None,-1,1])

 pylab.subplot(h,w,9);pylab.title("(E) Signal + Static")
 pylab.plot(xs,sigstat)

 pylab.subplot(h,w,11);pylab.title("(F) Recording (Signal + Static + Electrical Noise)")
 pylab.plot(xs,rawsignal)

 pylab.subplot(h,w,2);pylab.title("(G) FFT of Recording")
 fft=scipy.fft(rawsignal)
 pylab.plot(abs(fft))
 pylab.text(200,3000,"signals",verticalalignment='top')
 pylab.text(9500,3000,"static",verticalalignment='top',
            horizontalalignment='right')

 pylab.subplot(h,w,4);pylab.title("(H) Low-Pass FFT")
 pylab.plot(abs(fft))
 pylab.text(17,3000,"sin1",verticalalignment='top',horizontalalignment='left')
 pylab.text(37,2000,"sin2",verticalalignment='top',horizontalalignment='center')
 pylab.text(45,3000,"sin3",verticalalignment='top',horizontalalignment='left')
 pylab.text(6,3000,"signal",verticalalignment='top',horizontalalignment='left')
 pylab.axvspan(10,10000,fc='r',alpha='.5')
 pylab.axis([0,60,None,None])

 pylab.subplot(h,w,6);pylab.title("(I) Inverse FFT")
 pylab.plot(ibp)

 pylab.subplot(h,w,8);pylab.title("(J) Signal vs. iFFT")
 pylab.plot(signal,'k',label="signal",alpha=.5)
 pylab.plot(ibp,'b',label="ifft",alpha=.5)

 pylab.subplot(h,w,10);pylab.title("(K) Normalized Signal vs. iFFT")
 pylab.plot(signal/max(signal),'k',label="signal",alpha=.5)
 pylab.plot(ibp/max(ibp),'b',label="ifft",alpha=.5)

 pylab.subplot(h,w,12);pylab.title("(L) Difference / Error")
 pylab.plot(signal/max(signal)-ibp/max(ibp),'k')

 pylab.savefig("SIG.png",dpi=200)
 pylab.show()

     

DIY ECG Detected an Irregular Heartbeat

UPDATE: An improved ECG design was posted in August, 2016.
Check out: http://www.swharden.com/wp/2016-08-08-diy-ecg-with-1-op-amp/

Am I going to die? It’s unlikely. Upon analyzing ~20 minutes of heartbeat data (some of which is depicted in the previous entry) I found a peculiarity. Technically this could be some kind of noise (a ‘pop’ in the microphone signal due to the shuffling of wires or a momentary disconnect from the electrodes or perhaps even a static shock to my body from something), but because this peculiarity happened only once in 20 minutes I’m not ruling out the possibility that this is the first irregular heartbeat I captured with my DIY ECG. Note that single-beat irregularities are common, and that this does not alarm me so much as fascinates me. Below is the section of the data which contains this irregular beat.

In the spirit of improvement I wonder how much more interesting this project would be if I were to combine the already-designed ECG machine with a sensor to detect the physical effect of the heart’s beating on my vasculature. in other words, can I combine my electrical traces with physical traces? (Blood pressure or blood flow) I found an interesting site that shows how someone built a DIY blood flow meter using a piezo film pulse sensor. Pretty clever I must say… but I think I draw my limit at what I’ve done. Although blood flow would be interesting to analyze (does the murmur depicted above produce an alteration in normal blood flow?), it’s not worth the time, hassle or expense of building.


     

DIY ECG Improvements

UPDATE: An improved ECG design was posted in August, 2016.
Check out: http://www.swharden.com/wp/2016-08-08-diy-ecg-with-1-op-amp/

No 3-day weekend would be complete without a project that’s, well, virtually useless. I present to you my new and improved ECG machine! Instead of using a single op-amp circuit like the previous entries which gave me decent but staticky traces, I decided to build a more advanced ECG circuit documented by Jason Nguyen which boasted 6 op amps! (I’d only been using one) Luckily I picked up a couple LM 324 quad op amp chips at radioshack for about $1.40 each, so I had everything I needed. I’ll skip to the results. In short, they’re gorgeous. Noise is almost nothing, so true details of the trace are visible. I can now clearly see the P-Q-R-S-T features in the wave (before the P was invisible). I’ll detail how I did this in a later entry. For now, here are some photos of the little device and a video I uploaded to YouTube. It’s not fancy.

UPDATE: Upon analyzing ~20 minutes of heartbeat data I found a peculiarity. Technically this could be some kind of noise (a ‘pop’ in the microphone signal due to the shuffling of wires or a momentary disconnect from the electrodes or perhaps even a static shock to my body from something), but because this peculiarity happened only once in 20 minutes I’m not ruling out the possibility that this is the first irregular heartbeat I captured with my DIY ECG. Note that single-beat irregularities are common, and that this does not alarm me so much as fascinates me. Below is the section of the data which contains this irregular beat.