Here is a photo of the stereo unit as a whole.

Stereo unit

And this was the main problem.

Auxiliary input jack

Before taking anything apart, it’s important to disconnect the ground from the battery.  This helps prevent any accidental short circuits.

Ground cable removed

I was able to find some information online about how to remove the stereo.  It’s surprisingly simple for the newer Nissan Altimas.  In almost a scary way.  It made me realize just how easy it would be for someone to steal the stereo if they were so inclined.

The first step was to remove the plastic panel around the air vents.  The ideal tool would be a plastic pry bar but I didn’t have one of those.  I used a really old Visa gift card to start prying the plastic away, then I used a flat screwdriver for more strength.  I used the plastic card to protect the plastic from the hard metal screwdriver.  I didn’t want to scratch or dent the plastic panels if I could help it.

Prying the vent panel off

Coming apart

I had to pry apart both sides of the panel.  At some point I heard some snapping sounds that were quite scary but it seems it is actually perfectly normal.  Once I got past those snaps the panel just sort of slid out towards the back of the car.  Then I was able to lift it up.

Vents removed

Once the panel was removed, I could see the two phillips screws that hold the stereo bracket in place on top.

Top screws

Next I had to remove the bottom plastic panel to expose the bottom two screws.  This is done much in the same way as the top panel, only I found it to be a bit easier.

Removing the bottom panel

Bottom screws

Next I covered the shifter area in cloth (lab coat) to protect it from getting scratched when I pulled out the stereo.

Protective lab coat

Then it was time to remove the screws.

Removing the screws

Once all four screws were removed, I was able to pull out the stereo.  It actually snapped in around the sides so it took a bit more effort than I anticipated to pull it out.

Stereo removed

There were a total of four plugs connected to the unit.  One is for the proprietary Nissan antenna connector, one is for the AC controls, and two go to the stereo itself.

Plugs

The plugs were in there pretty good but after some wiggling and finger strength I got them all out.

Empty dash

Front view

Side view

Back view

Some of the plugs

Once I had the thing out of the car I had to figure out how to take it apart in order to get to the stereo jack.  My first inspection led me to believe I had to remove four torx screws on either side of the unit.  It seemed like these were holding the main stereo into the whole assembly and removing them would allow me to slide out the stereo piece to access the audio jack.

Side torx screws

I managed to remove the four left side screws, but I ended up stripping out one of the screws on the right side because the torx bit I had didn’t fit perfectly into the screw.  Oops. At this point I thought I might have been screwed but further inspection showed that I might not actually have to remove those side screws after all.  I decided to remove the top metal panel to get a look inside of the stereo.

Top screw

Inside the stereo

Once I got a look inside I was able to see that the audio jack wasn’t actually physically connected to that large unit anyway.  The jack is in the small square whole near the top center of the below photo.

Can't reach the audio jack

I inspected the unit further and decided that the front panel looked like it should be able to come off.  I found two small phillips screws on either side holding it on, so I removed them.

Front panel screws

Then I realized that there were four more black torx screws holding the front panel to the main metal unit.  I didn’t want to risk stripping them out and I couldn’t find the right size bit anywhere in the shop.  Luckily we are only two minutes from Harbor Freight!  I drove down there (with gaping dashboard) and managed to find some security bits that included the proper sized bit.

Harbor Freight saves the day!

So now it was time to remove the torx screws.  There were two on the top.

Top front torx screw

And two on the bottom.

Bottom front torx screw

Once all the screws were removed, the plastic was still holding on snug.  I looked around and saw that there were some small snaps holding it in place around the edges of the unit.  The below photo shows some of the snaps after I pried up the plastic to get it off.

Front panel snaps

Once all the snaps were pried up, the unit just came apart into three pieces.

Three pieces

This allowed me to get direct access to the solder joints of the audio jack.

Audio jack solder joints

Surprisingly, they didn’t look too bad.  This made me worry a bit because I was hoping to just fix a solder joint or two and be done with this project.  I plugged in the stereo plug and used a continuity tester to see which solder joints corresponded to ground, left, and right channels.

Testing continuity

I was able to find the ground and left channels, but not the right.  This made sense because the right channel was the one having problems.  For the hell of it, I decided to just reflow all of the solder joints and see if it would magically fix the problem.  I tested continuity again and got the same result as last time.  That indicated to me that the problem was actually inside of the audio jack and not just a solder joint.  Time to take this thing apart even further!

First I removed the PCB from the front plastic bezel.

PCB removed

Audio jack

Audio jack with rubber pulled back

With plug inserted

Once I had the PCB separated from the bezel I was able to remove the audio jack.  I used some desoldering braid to make quick work of the job.

Audio jack removed

Audio jack

After inspecting the jack, I saw some snaps on either side that looked like they would allow me to get inside of the actual jack.  This was a good sign because if I couldn’t get inside then I was going to have to replace this jack with a duplicate, which I didn’t have.

Jack separated

In the below photograph you can see the metal contacts around the outside of the jack.

Stereo cable plugged in

I tested continuity again on all of the plug’s pins and still the right channel was not working.  I had to figure out which one of the pins went to the right channel and remove it.  I just used some pliers to slide out the metal piece.

The culprit!

That tiny piece of metal ended up being the cause of the problem.  I think it somehow got bent out of shape and wasn’t making contact properly.  I tried a few things to help the problem.  First I sanded the edge to get rid of some of the corrosion but that didn’t work.  Then I put a small blob of solder on top of the edge to raise it up higher in hopes that it would press against the plug better.  That only made it more difficult to push the plug in and resulted in the metal piece bending further.  Then I noticed that the inside of the jack looked like it was a bit curved.  Like if I pushed in the metal shim it would bend up toward the plug due to the curved design.  I removed the solder and tried straightening out the metal shim so it would go further into the jack.  This seemed to work.  It took a lot of trial and error to find the exact way the shim had to be bent.  If it wasn’t bent enough then the stereo plug barely snapped into place and could fall out easily.  If it was bent too much then the stereo plug was really difficult to push in and sometimes would even bend the shim back out of the way again.  I finally got it into a place that I thought would work for me.  A continuity test proved it.

I soldered the jack back onto the PCB and did another continuity test just to be sure it would work.  It worked.  I put the stereo unit back together and re-inserted it into my car. I hooked up the battery ground cable again and turned on the stereo… It turned on!  The buttons all seemed to be working!  Now the moment of truth.  I plugged my cell phone into the auxiliary input jack and started playing some music.  The quality was superb.  I got both left and right channels and it sounded so much better than it did before I was blown away.  I forgot how good the cell phone audio was supposed to sound coming through the stereo.  I screwed the stereo back into the dash and replaced the vent and bottom panels.

Back together again!

A job well done!  The stereo got the last laugh though.  Removing the power caused it to forget what time it was and also forget all of my saved radio stations.  Easy enough to fix.  It’s hard to believe all of that work had to be done because of one tiny piece of metal.  I’m hoping it won’t get bent again.  If it does, I’m going to have to try and just replace that audio jack.  I’m keeping my fingers crossed though.

The first step was to make the base mask.  I wanted it to fit my face perfectly, so naturally it had to be molded to my face.  My Internet research showed that the simplest way to get this result was to cover my face in petroleum jelly and then layer plaster strips on my face until they dried.  The jelly prevents the strips from sticking to my face or any of the hairs.  I obtained the plaster strips from our local Michael’s store.

Plaster and Petroleum Jelly

First, I covered my face in the petroleum jelly.  I paid special attention to places like my eyebrows and hairline where there was more hair that could possibly get dried into the mask.

Jelly face

Next I had to start layering the strips onto my face.  I tried to make sure they cris-crossed often to improve the strength of the mask.  I had some help from Shannon with this part.  That is until we kept making each other laugh.  Laughing is a good way to wrinkle the mask  so I had to boot her out of the room until it dried.  We didn’t get too many photos of this process since it was so messy.

Start with a cross

Covering up more

Almost done

Fully layered

Once I had all the layers on and it had dried enough, it was time to try and remove the mask.  This involved me wiggling my face all around in weird ways to get the mask to detach.  It seemed to stick to my forehead the most, but it came off with relative ease.

I let the mask dry overnight.  The next day, I used some paper towels to try and wipe off most of the petroleum jelly from the inside of the mask.  The mask was actually pretty strong with just the plaster.  After I removed the jelly I cut the mask down a bit to pretty it up and get rid of any parts I just didn’t want.

Dried mask

Dried mask from the side

Next I decided to try and build up some features onto the mask to make it more interesting.  I used black craft foam to build up some cheek bones and eyebrows.  I cut out some shapes from paper as a template and then cut them out of the foam.  I glued the first layer of foam to the mask using super glue.  Then I glued the rest of the layers together to build up the features.

Craft foam cheek bones

Craft foam eyebrows

Once I had the features built up, I had to cover the mask up in Wonderflex.  Wonderflex is this awesome material I found online.  It’s a stiff plastic sheet that becomes soft and sticky when heated.  You can use a heat gun to make the plastic malleable, and then apply it to a surface and use your fingers to mold it to shape.  The plastic is self-adhesive so it sticks to the object you are molding too.  I decided to use this stuff to smooth out the mask and get rid of that rough plaster texture.  I figured the plastic would also smooth out the cheek bones and eyebrows.

I first cut a piece of Wonderflex that I thought would be big enough for the entire mask.

Mask and Wonderflex

The Wonderflex has a smooth side and a rough side.  I wanted to put the smooth side on the outside so the mask would have a smoother texture.

Close up of the Wonderflex

I didn’t get a lot of photos of this process because I was finishing the mask on the day of the event so I was in a rush.  You can get a basic idea of what I did with the few photos that I did take.  I ended up having to cut my one sheet of Wonderflex down into smaller pieces.  I was hoping to use just one piece to prevent any seams from showing on the mask but the mask had so many features it proved difficult.

It seemed like the best approach was to just get the Wonderflex to stick to the mask and get a basic shape around all of the features.  It helped to wrap the Wonderflex around the edges of the mask to help it stick down.  Once I had an entire piece of Wonderflex stuck down it was easier to reheat areas and smooth it all out with my fingers.  This stuff is so great in that you can reheat it as many times as you want.  I also found that if you heated it and pressed it enough, you could basically squish two pieces of Wonderflex into each other and almost completely remove any seams.

Getting close to done

Trying to just cover the mask

Wonderflex wrapped around the eye holes

Just needs a bit more smoothing

Much better

The next step was to paint the mask.  The cosplay website that sold the Wonderflex recommended using acrylic paint.  I bought some red and black paints from Michael’s so I would match Shannon’s outfit and got to work.  I didn’t get any photos of this process because time was starting to run really short and my hands got pretty messy with the paint.

After the paint was applied, I had to add feathers.  What proper Mardi Gras mask doesn’t have feathers?  I added a couple of black and red feathers for flair using super glue.  The super glue didn’t work out too well because once it fully dried, it left some white residue on the front of the mask.  I’m thinking I can probably just paint over that if I ever want to use this mask again though.

Painted with feathers glued on

Glue residue after it fully dried

Next I super glued some felt to the inside of the mask.  The idea was that it would cover up the plaster and hopefully provide a softer surface against my skin.  This didn’t work as well as I had hoped.  The felt I put in the forehead area stuck pretty well, but the felt in the cheeks didn’t stick enough and I ended up having to remove that felt because I ran out of time before the party.

The final step was to add some sort of strap to hold the mask to my face.  I used my Leatherman knife to poke some holes in the sides of the mask to attach some lace.  I found some suede black lace at Michael’s that I thought would give a fancier touch to the mask.  I just poked the lace through with a small screwdriver and tied it to the holes.  Voila! Mask complete!

Lace tied from the back

Lace view from the front

Once thing I wish I had noticed before I started this project was that the super glue says on the packaging not to use it for fabrics.  Apparently the glue eats through the fabric and doesn’t work as you would hope.  I learned this the hard way by using the glue to hold the felt in place.  When I got to the party I assumed the glue had completely dried since it had been about 45 minutes to an hour but I was WRONG.  I wore the mask for about 45 minutes or so and then took it off.  What I saw after that was a bit disconcerting.

White spots

Those white spots on my forehead are from the super glue.  It hadn’t dried to the felt but it dried really fast once it made contact with my skin!  Luckily, the mask didn’t actually glue itself to my face.  The glue just seeped through the felt and dried to my skin.  I ended up leaving the party early to go remove the glue from my face to ensure I didn’t break out in some kind of rash.  I had to rub acetone onto my face (probably not the best idea) in order to dissolve the glue.  I removed most of it with the acetone and now a few days later there is barely anything left of it.  My skin seems fine so far, but consider this a lesson learned the hard way.  Don’t use super glue on fabrics, especially if those fabrics are going to be pressed against your skin!

Me and Shannon in the photo booth

I thought I had fixed the crashing problem I was experiencing, but when I showed up to work after the weekend the script had crashed again.  This time the error was different though:

Traceback (most recent call last):
  File "splunkMeter.py", line 41, in
    result = result[1]
IndexError: list index out of range

This error is different from the last one.  It occurs on a different line.  I looked through the script and realized my stupid mistake.  Of course it crashed, basically the entire rest of the script relies on the fact that a result was returned.  If no result was returned then not only would the original line fail but so would this one.  The simple fix was to just include the rest of the script under that IF block.  Here is the new version of the script:

import time
import splunk.auth
import splunk.search
import sys, os, serial

#change these to fit your installation
COM_PORT = 'COM3'
DEFAULT_BAUDRATE = 9600

SPLUNK_LICENSE_LIMIT = "10240"
SPLUNK_USERNAME = ''
SPLUNK_PASSWORD = ''
SPLUNK_URL = 'https://:8089'
SPLUNK_SEARCH = 'search index=_internal metrics kb series!=_* "group=per_index_thruput" series=main | eval indexed_mb = kb / 1024 | stats sum(indexed_mb)'

# Open the serial port (Teensy)
ser = serial.Serial(COM_PORT)

# loop forever
while True:

	# Authenticate to splunk server
	key = splunk.auth.getSessionKey(SPLUNK_USERNAME, SPLUNK_PASSWORD, hostPath=SPLUNK_URL)

	# Set up the Splunk search (@d means return all results from today)
	job = splunk.search.dispatch(SPLUNK_SEARCH, earliest_time='@d', hostPath=SPLUNK_URL)

	# wait for the search to finish
	while not job.isDone:
	    time.sleep(.25)

	# Without this IF, the script crashes at night.  I think once the day
	# changes there are 0 results so the script crashes.
	if job.count > 0:
		# get the first result (only result) and convert it to a string
		result = str(job.results[0])

		# Split the result into two pieces because Splunk returns the time and the number we want.
		result = result.split('=', 1)
		# We only want the actual license usage, not the time
		result = result[1]

		# Turn the string into a float, round to the nearest 0 and then convert it to an into to drop the decimal
		intResult = int(round(float(result)))

		# Close out the Splunk job
		job.cancel()

		# This section sends the data to the Teensy.
	        ser.write("m") #send "m" to tell the Teensy to expect the "mb" variable
		time.sleep(0.1)
	        ser.write(str(intResult)) #convert the splunk result to a string and send it to the Teensy
	        time.sleep(1)
	        ser.write("t") #send "t" to tell the Teensy to expect the "totalMB" variable
		time.sleep(0.1)
	        ser.write(SPLUNK_LICENSE_LIMIT) #tell the Teensy what your license limit is.
		time.sleep(0.5)        

		# For debugging purposes
		print intResult

ser.close()

At least, I think that should fix it.  It’s working so far but I guess I’ll know after letting it run overnight for a few more days.  We’ll see!

Ever since I got the Splunk LED meter up and running, I had a problem with it.  The problem was that every morning when I came into work, the LEDs were lit up as though the license was at it’s highest point from the day before.  If I looked at the Python script output, there was always an error.  This comment from Bryan made me think that perhaps the problem was Windows power management shutting down the USB port at night.  I tried disabling the power management for USB ports but that did not help.  Although, it’s good to know about that for future projects.

I looked closer at the Python error I was getting:

Traceback (most recent call last):
 File "splunkMeter.py", line 33, in <module>
 result = str(job.results[0])
 File "C:\Program Files\Splunk\Python-2.6\Lib\site-packages\splunk\search\__ini
t__.py", line 1343, in __getitem__
 raise IndexError
IndexError

“IndexError”.  The problem was with the line “result = str(job.results[0])”.  Usually when you see some kind of Index error, it means that the index you tried to access doesn’t exist. I thought about why this would happen in this case.  The Splunk job automatically fills the “results” array with all of the results that are returned from the search.  If job.results[0] is invalid, that would probably mean that zero results were returned to Splunk.  But how could that happen?  I thought about it some more and realized that the result is generated from the events that the search finds.  If you actually plug the search

search index=_internal metrics kb series!=_* "group=per_index_thruput" series=main | eval indexed_mb = kb / 1024 | stats sum(indexed_mb)

into Splunk, you can see that one result is returned but there is one event found for every 30 seconds or so.  Since there is that 30 second gap between events, I figured that once the clock turns past midnight, my script runs the search and finds zero results for the current day because no events were logged in the first 3-5 seconds of the day.  Since no events were found, the index[0] is not created and Python crashes.  To resolve this problem, I took the portion of the splunkMeter.py code that looks like:

# get the first result (only result) and convert it to a string
result = str(job.results[0])

and I changed it to:

# Without this IF, the script crashes at night.  I think once the
# day changes there are 0 results so the script crashes.
if job.count > 0:
	# get the first result (only result) and convert it to a string
	result = str(job.results[0])

This code makes sure that at least one event was found from the search.  If one event was found, then we know the search generated a result and we can proceed.  If zero events were found, then we know that no result was generated and we can’t do anything yet.

I tested this change last night and when I came into the office this morning my meter was still running with no crashes.  I’m guessing that fixed the problem, but I will know for sure if I leave my workstation on all weekend and it is still running on Monday.

I was able to finish the Splunk LED meter on Monday.  There were two things I had left to do.  The first thing was to add some kind of diffusing screen to the project housing.  The second (the harder part) was to figure out how to get the license usage data from Splunk and send that to the Teensy via serial.  Let’s start with the easy part.

First I had to figure out a way to hold to top of the LED strip against the back of the housing.  I ended up cutting a slit at the top of the housing and just sticking a thin piece of card into the slit.  The slit is tight enough to hold the card in place and the card keeps the strip pressed against the back of the housing.

Card holding the strip in place

Side view of the card

Next I decided to keep the Teensy inside of the housing rather than hanging outside of it like I did previously.  The reason is that I am afraid the stress on the Teensy will eventually cause the solder joints to break.

Teensy inside the housing

I decided to use wax paper as a diffusing screen since I had it at home already.  I cut a length of paper long enough for the plastic housing.  I simply wrapped it around the outside of the housing and taped it in the back.

Wax paper taped

Then I cut it to size so it wouldn’t stick off the top or bottom too much.  I originally had a different method for this that only diffused the front of the casing and not the sides.  I decided it would be nice to have the sides diffused as well so I could see the meter status from other areas on the room rather than just right in front of the meter.

The next step to complete the housing was to figure out how to mount it to my monitor.  I had to work with what I had at my desk so I ended up with a really MacGyver’d solution.  I used a part of a plastic fork to attach the top of the meter to the top of my monitor with the help of some Scotch tape.  I then used more tape at the bottom of the meter to keep it flat against the side of the monitor.  It works… but it’s not ideal.  It looks slapped together up close, mostly because of the broken plastic fork, but it gets the job done.

Monitor mount

Now the tricky part was writing the code.  I originally tried using Curl to authenticate to the Splunk web interface but I had problems with this.  I think the main problem is that Splunk provides you with a cookie and session ID and I just couldn’t figure out how to get Curl to set and use the cookie properly.  I tried a bunch of different things but nothing seemed to work.

Next I decided to try authentication to the web server via Python.  Same problem.  I tried a few different methods but nothing would authenticate to the web site properly.  Did I mention I’m not really a coder and have barely used Python?

Finally, after some searching around on the web, I discovered that Splunk actually provides you with Python libraries to perform Splunk searches from within Python scripts.    Here’s a great resource for information on this.  This actually makes a lot of sense considering much of Splunk is written in Python.  With this information I was sure I could get the script working using Python.

The main problem was I did not have Python installed on my Windows workstation.  I had it installed in a co-linux installation on my workstation but it turns out co-linux doesn’t work with USB to Serial devices.  I thought about installing Python on my workstation but I couldn’t see where to actually download the Splunk python libraries.  The only way I knew to get them was to install the full version of Splunk.  The Universal Forwarder doesn’t come with them.  Since the full version of Splunk comes with it’s own version of Python I figured I might as well do that.  So I installed the full version of Splunk on my workstation and promptly disabled all of it’s services from running or starting automatically.

Now I had Python installed with the Splunk libraries.  I wrote a script to just pull the information I needed from Splunk and print it to the screen so I could make sure the libraries worked.

# splunkSearchTest.py by Rick Osgood
#
# This script will attempt to search Splunk for the current
# Splunk license usage amount.  It will get the result and
# print it to STDOUT.
#
# For more information, visit http://www.richardosgood.com
#

import time
import splunk.auth
import splunk.search

# Set Variables
username = 'SPLUNK USERNAME HERE'
password = 'SPLUNK PASSWORD HERE'
searchTerms = 'search index=_internal metrics kb series!=_* "group=per_index_thruput" series=main | eval indexed_mb = kb / 1024 | stats sum(indexed_mb)'
url = 'https://SPLUNK_URL_HERE:8089'

# Authenticate to Splunk
key = splunk.auth.getSessionKey(username, password, hostPath=url)

# Run the search
job = splunk.search.dispatch(searchTerms, earliest_time='@d', hostPath=url)

# Wait for the search to complete
while not job.isDone:
    time.sleep(.25)

# Get the first (only) result
result = job.results[0]

# Convert to a string
endResult = str(result)

# Split the result into it's two parts
endResult = endResult.split('=', 1)
# Only take the second part (it contains the actual number I want)
endResult = endResult[1]

# Round the decimal value and drop the decimal completely
intResult = int(round(float(endResult)))

# Print the result
print intResult

# Kill the Splunk job
job.cancel()

The comments in the script are pretty self explanatory.  The Splunk libraries made it so easy to get what I needed.  Once I had that working, I wrote another test script to get serial communication working between a Python script on my workstation and the Teensy hooked up via USB.

# splunkSerialTest.py by Rick Osgood
#
# This script will send test data to the Teensy Arduino for
# the Splunk meter. It will loop forever until the script
# either dies on its own or you end it with Ctrl+C.
#
# For more information, visit http://www.richardosgood.com
#

import time
import sys, os, serial

# Change these to fit your installation
COM_PORT = 'COM3'
DEFAULT_BAUDRATE = 9600

# This is needed so the Teensy knows the percentages
SPLUNK_LICENSE_LIMIT = 10240
mb = 0

# Open the serial port (Teensy)
ser = serial.Serial(COM_PORT)

# loop forever
while True:

	# This section sends the data to the Teensy.
        ser.write("m") #send "m" to tell the Teensy to expect the "mb" variable
	time.sleep(0.1)
        ser.write(str(mb)) #convert the splunk result to a string and send it to the Teensy
        time.sleep(0.5)
        ser.write("t") #send "t" to tell the Teensy to expect the "totalMB" variable
	time.sleep(0.1)
        ser.write(SPLUNK_LICENSE_LIMIT) #tell the Teensy what your license limit is.
	time.sleep(0.5)        

	print mb
        # Increment forever so we can test the LED meter
	mb = mb + 103

# close serial port
ser.close()

That script should slowly fill up the LED meter.  This is useful for testing the serial communication and also for testing the Teensy code to make sure it lights up as expected.  If you try to run this script with the default Splunk Python installation it will fail.  That is because the version of Python that comes with Splunk does not have the pySerial library installed.  I was unable to get it installed using the usual methods, but I tried just copying the libraries over into the Splunk Python library directory and that seemed to do the trick. Also, you have to run the scripts using the Splunk executable because Python is only installed with Splunk, not as a standalone installation. Here is a quick run down of how to get these scripts up and running on a windows system:

1. Install the full version of Splunk on the workstation.
2. Download and extract pySerial
3. Copy the pySerial-2.6\directory folder to “C:\Program Files\Splunk\Python-2.6\Lib\serial”
4. Put the Python scripts you want to run in the “Splunk\bin\” directory
5. Execute the scripts with “splunk cmd python SPLUNK_SCRIPT.py” from the “Splunk\bin\” directory

Once I had that script up and running, I was able to verify that Serial communication to the Teensy was working properly and also the Teensy code was working properly because the LEDs were lighting up as expected.  The final step was to combine those two scripts into one.

# splunkMeter.py by Rick Osgood
#
# This script will grab the current Splunk license usage and
# send it to a Teensy Arduino. It will loop forever until the
# script either dies on its own or you end it with Ctrl+C.
#
# For more information, visit http://www.richardosgood.com
#

import time
import splunk.auth
import splunk.search
import sys, os, serial

#change these to fit your installation
COM_PORT = 'COM3'
DEFAULT_BAUDRATE = 9600

SPLUNK_LICENSE_LIMIT = "10240"
SPLUNK_USERNAME = 'USERNAME'
SPLUNK_PASSWORD = 'PASSWORD'
SPLUNK_URL = 'https://SPLUNKURL:8089'
SPLUNK_SEARCH = 'search index=_internal metrics kb series!=_* "group=per_index_thruput" series=main | eval indexed_mb = kb / 1024 | stats sum(indexed_mb)'

# Open the serial port (Teensy)
ser = serial.Serial(COM_PORT)

# loop forever
while True:

	# Authenticate to splunk server
	key = splunk.auth.getSessionKey(SPLUNK_USERNAME, SPLUNK_PASSWORD, hostPath=SPLUNK_URL)

	# Set up the Splunk search (@d means return all results from today)
	job = splunk.search.dispatch(SPLUNK_SEARCH, earliest_time='@d', hostPath=SPLUNK_URL)

	# wait for the search to finish
	while not job.isDone:
	    time.sleep(.25)

	# get the first result (only result) and convert it to a string
	result = str(job.results[0])

	# Split the result into two pieces because Splunk returns the time and the number we want.
	result = result.split('=', 1)
	# We only want the actual license usage, not the time
	result = result[1]

	# Turn the string into a float, round to the nearest 0 and then convert it to an int to drop the decimal
	intResult = int(round(float(result)))

	# Close out the Splunk job
	job.cancel()

	# This section sends the data to the Teensy.
        ser.write("m") #send "m" to tell the Teensy to expect the "mb" variable
	time.sleep(0.1)
        ser.write(str(intResult)) #convert the splunk result to a string and send it to the Teensy
        time.sleep(1)
        ser.write("t") #send "t" to tell the Teensy to expect the "totalMB" variable
	time.sleep(0.1)
        ser.write(SPLUNK_LICENSE_LIMIT) #tell the Teensy what your license limit is.
	time.sleep(0.5)        

	# For debugging purposes
	print intResult

ser.close()

That did the trick!  If I hook up the Teensy to my workstation and run that script, it seems to work perfectly.  It will grab the Splunk license usage every few seconds and send it to the Splunk Meter.  It might be a good idea to put a long delay in the Python script so it doesn’t work the Splunk server so hard.  Our license usage increases so slowly that I could probably have it check the Splunk server every 5 or 10 minutes instead of every few seconds and it would work just as well.  I’ve noticed that when I lock my workstation overnight and come back in the morning, the Python script crashes.  I’m not sure what’s causing that yet.  It might be that the Serial port closes after a while or something.  It’s not a big deal yet because I can just restart the script in the morning when I come into the office.

So what does it look like?  It was difficult to capture what it truly looks like with my cell phone camera.  The lights are bright enough that they seem to saturate the camera so it is difficult to determine their colors.  With the overhead lights off you can make out the individual LEDs on camera.

With the lights off

The above photo does not accurately represent our license usage at that time.  I was running the test script so I could get more LEDs to light up.  The photo below does accurately represent our license usage, which you can see highlighted on my monitor.

Another photo

I also took a video of my test script running so you can see the LED bar fill up and then run the animation.  Again, it’s difficult to really determine the colors on camera but it looks great in person.

If I were to improve this project in any way, it would probably be to make a prettier case for it.  Right now it looks kind of slapped together, which is a shame because it really is a useful project.  Also, the way it is mounted to my monitor could use some improvements.  Other than that, I love it!

Let’s start out with the housing.  I went to Walmart to look around for something that might work.  I was thinking some kind of clear plastic tube would work well.  I could just slide the LED strip down the tube, fasten it in there somehow and then cut the tube to the proper length.  After some searching around, I noticed this.

Welding Electrodes

Welding Electrodes Close Up

I found that box of welding electrodes on the shelf in the hardware isle at Walmart and I figured that plastic case would work perfectly.  The case is clear, strong, but easy to cut if needed.  Also, it can expand and contract in length so it can be easily adjusted to fit the LED strip length.  This whole package of electrodes was less than $5.00 so I figured I might as well give it a shot.  And now we have some welding electrodes at Eugene Maker Space in case we ever find a use for them.

Next I dumped out the electrodes and realized I was going to have to get rid of the sticky label from the plastic housing.  This was pretty tedious.  The best way to remove these labels is to start peeling at a corner and then SLOWLY peel the entire thing away, being careful not to rip it as you go.  After a few minutes of tedious peeling, I had my plastic case.

Plastic case with LED strip for comparison

Next I had to shorten the LED strip.  The strip had 12 LEDs but for this project I wanted 10 LEDs.  One LED would represent one GB of license usage.  These strips are really neat in that you can cut them at a specified place after every two LEDs.  This way you can make strings of LEDs that are as short as you want, as long as each string is a multiple of 2.  To cut the strip, I first located the dividing line.

Dividing line in white

You can see the white dividing line above.  Next I had to cut through the flexible plastic housing and the flexible PCB.  It’s pretty easy to cut through this stuff as long as you have a sharp knife.  The knife in my Leatherman was plenty sharp enough for the job.

Cutting through the plastic

Cutting through the back side

Success!

Next I drilled a hole in the bottom of the plastic casing so I would be able to plug the USB cable into the LED strip while it was inside the casing.

Hole drilled

I realized later that it would be best to have the Teensy hanging out of the casing so that I could press the reset button in order to update the firmware as I was writing the code.  It would have been a huge pain to take the strip in and out every time I had to program it.  I used my knife to cut a slit in the bottom of the casing big enough for the Teensy to slide through so it will hang out of the bottom.

Teensy hanging out

LED strip in housing

I still have some more work to do on the housing for this project, but the basics are done.  I want to add some kind of diffusing screen on the front of the housing to diffuse the LED light so it is not so bright and blinding.  I think it will also add to the looks of the completed project.  I also need to find a way to mount the strip to the back of the housing so it stays straight and flat rather than wavy.

I spent most of my time on Sunday on the firmware side of this project.  I ended up with three different versions of the Teensy firmware that each act a bit differently.  For the first version, at each GB mark a new LED will light up green.  Once the license limit has been reached, the bar starts over and starts lighting up the LEDs red.

That worked, but I thought I could do better.  I also thought that it wasn’t really necessary to keep track of the license limit any more once the limit was reached.  The way Splunk licensing works, once you go over the limit that’s it.  It doesn’t matter how far over it you go.  So having the LEDs light up one after the other once the license is reached is kind of pointless.  Kevin gave me the idea to have the strip do animations once the limit has been reached.  I liked this idea because an animation would really grab your attention.  So the second version of the firmware lights up one LED per GB in a green color and then once the limit is reached it will display an animation in red.

I still thought I could do better, so I worked on a third version of the firmware.  This version still does an animation once the limit has been reached.  The difference is that the LEDs don’t just light up green.  Each “level” will light up green until that level has reached 50% capacity.  Then it will turn yellow to let you know you are half way to the next level.  Once it reaches 90%, it will turn red.  When it reaches 100%, the LED stays red and the next LED lights up green.  So at the end, all of the LEDs will be red until you go over the license limit and the animation starts.  This is the version of the code I liked the best, so that’s the one I used.  Here is the code.

/*
SplunkMeter REV_C
By: Rick Osgood

This sketch waits to receive 'm' via serial.  Once it receives 'm' it waits for the license usage
value.  It also waits to receive 't' via serial.  Once it receives 't' it waits for the total
license value.  For example, 'm' might be 1024 and 't' might be 10240.  It then uses those values
to figure out which LEDs to light up and which colors.
*/

// HL1606strip is an adaptation of LEDstrip from  http://code.google.com/p/ledstrip/
#include "HL1606strip.h"

// use -any- 3 pins!
#define STRIP_D 2
#define STRIP_C 1
#define STRIP_L 6

#define NUMLEDS 10

// Pin S is not really used in this sketch since it doesnt use the built in PWM fade
// The last argument is the number of LEDs in the strip. Each chip has 2 LEDs, and the number
// of chips/LEDs per meter varies so make sure to count them! if you have the wrong number
// the strip will act a little strangely, with the end pixels not showing up the way you like
HL1606strip strip = HL1606strip(STRIP_D, STRIP_L, STRIP_C, 12);

int mb = 0;
int totalMB = 0;
int minMB = 0;  // This will be 1/NUMLEDS of the totalMB

void setup(void) {
  Serial.begin(9600);
  stripOn(GREEN);
  delay(1000);
  stripOff();
  delay(1000);
  stripOn(RED);
  delay(1000);
  stripOff();

  mb = -1; // -1 so we know when we haven't updated it
  totalMB = -1; // -1 so we know when we haven't updated it
}

void loop(void) { 

  int temp = waitForMB();
  if (temp == 1) {
    mb = getMB();
  } else if (temp == 2) {
    totalMB = getTotalMB();
  }

  // if both values were updated
  if (mb != -1 && totalMB != -1) {
    minMB = totalMB / NUMLEDS;
    mb = scaleDown(mb, totalMB);
    Serial.print("MB scaled down: ");
    Serial.println(mb);
    lightStrip(mb);

    mb = -1; // -1 so we know when we haven't updated it
    totalMB = -1; // -1 so we know when we haven't updated it
  }

}

/**********************************************/

int waitForMB() {
  if (Serial.available() > 0) {
    char temp;

    // read the incoming data:
    temp = Serial.read();

    if (temp == 'm') {
      return 1;
    } else if (temp == 't') {
      return 2;
    }
  }
  return 0;
}

int getMB () {
  Serial.println("Send mb:");
  int temp = getNumber();
  return temp;
}

int getTotalMB() {
  Serial.println("Send totalMB:");
  int temp = getNumber();
  return temp;
}

int getNumber() {
  int number=0;
  int temp=0;

  if (Serial.available() > 0) {

    char buffer[6]={0,0,0,0,0,0}; // Will store each digit of the number

    // read the incoming data:
    for (int i = 0; i < 6; i++) {
      buffer[i] = Serial.read();
    }  

    number = atoi(buffer); // Convert received number string to an int

    // for debugging only:
    Serial.print("I received: ");
    Serial.println(number, DEC);

    return number;
  } else {
    return -1;
  }
}

int scaleDown(int num, int totalNum) {
  // Scale the value and return the result in how many LEDs should be lit up
  //int temp = map(num, 1, totalNum+1, 1, (NUMLEDS * 10)+ 1);
  //int temp = map(num, 1, 100, 1, 100);

  long temp = long(num) * (NUMLEDS * 10) / long(totalNum);

  temp = constrain(temp, 1, NUMLEDS * 10);

//  if (num < minMB) { // For some reason even if num < minMB it still returns 1 unless num = 0
//    return 0;
//  }
  return temp;
}

void lightStrip(int num) {
  int temp = 0;

  // First turn everything off
  stripOff();

  // If it's < NUMLEDS then we light up green
  if (num/10 < NUMLEDS) { // Divide by 10 because we multiplied in scaleDown()
    for (int i = 0; i < num/10; i++) {
      strip.setLEDcolor(i, RED);
    }

    // Set the color of the last LED
    temp = num - (10 * (num / 10)); // Trying to get the ones digit. I.E. 25 would result in 5.
    if (temp < 5) {
      strip.setLEDcolor(num/10, GREEN);
    } else if (temp < 9) {
      strip.setLEDcolor(num/10, YELLOW);
    } else {
      strip.setLEDcolor(num/10, RED);
    }

    strip.writeStrip(); // Now turn on the LEDs that need to be on
  } else {  // If we are NUMLEDS or over then we have reached the license limit and need to alert
    overLicenseAlert();
  }
}  

void overLicenseAlert(){
  for (int j = 0; j < 3; j++) {
    for (int i = 0; i < 5; i++) {
      stripOff();
      strip.setLEDcolor(4 - i, RED);
      strip.setLEDcolor(5 + i, RED);
      strip.writeStrip();
      delay(100);
    }
    stripOff();
  }
  stripOff();
}

// turn everything off (fill with BLACK)
void stripOff(void) {
  // turn all LEDs off!
  for (uint8_t i=0; i < strip.numLEDs(); i++) {
      strip.setLEDcolor(i, BLACK);
  }
  strip.writeStrip();
}

// turn everything on (fill with GREEN for testing)
void stripOn(int color) {
  // turn all LEDs on
  for (uint8_t i=0; i < strip.numLEDs(); i++) {
      strip.setLEDcolor(i, color);
  }
  strip.writeStrip();
}

That was about it for the work I did on Sunday.  I was able to test out the code on the Teensy by opening a serial terminal connection to the Teensy and entering the data manually.  You just enter “m” to let it know you are going to enter the “mb” variable, then enter the number for mb.  Then you enter “t” to let the Teensy know you are going to enter the data for the “totalMB” variable, and then again submit the actual number.  Once the Teensy has registered both numbers it will light up appropriately and stay lit that way until it receives new data.

Next I have to add a diffusing screen to the housing and write the software that will run on the computer.  The software will be tricky because I’m not much of a programmer.  I need to find a way to get the license data from Splunk and then send that over serial to the Teensy.  I think I might try to use Python since I have used it for serial communication in the past and it was pretty simple.  More updates soon!

RGB LED Strip and Teensy Arduino

A few weeks back I had an idea to build an LED meter to display our Splunk license usage at work.  Splunk is an application we use to collect and monitor logs all across our systems.  I currently have a web dashboard that will tell me what our license usage is.  A normal day follows a relatively standard license usage pattern.  It generally rises at a certain rate and hits a certain log volume by the end of the day.  If the log volume is higher or lower than usual, it is a basic signal that something may be wrong on the network.  The problem with the web dashboard is that I have to remember to open that tab and refresh it every so often in order to keep tabs on it.  I figured if I could just have an LED bar on the side of my monitor keeping tabs on the license usage for me, my brain would naturally get used to daily patterns and be able to notice subconsciously when something is wrong.  Last night was our open house night at Eugene Maker Space and I finally had some time to start working on this project.

The first thing I had to do was figure out how I was going to build this thing.  I knew that Adafruit sold some nice RGB LED strips so I figured those would be perfect for the LED bar.  They are already in a strip and they are super easy to interface with a microcontroller.  For my microcontroller I decided to use an Arduino since they are cheap, simple to use and I am the most familiar with it.  However, rather than use a normal Arduino I decided to use one of my Teensy Arduinos that I bought a few months back.  The Teensy acts just like a normal Arduino for the most part.  It is just way smaller and has a build in USB interface in it’s tiny package.  It can also support USB serial communication as well as emulate a keyboard or mouse!  For this project, I figure I will end up just using the USB connection for serial communication and perhaps power.

Those are really the only two parts I need for this project.  The LED strip should be able to interface directly to the Teensy with no supporting circuitry.  My friend @willbradley in Arizona was kind enough to send me an RGB LED strip that is just about the right length for this project.  The strip he sent me is the old model of this strip sold by Adafruit.  The Adafruit tutorial for using the old version of the strip is located here.  I had used the newer version of the strip before and it was dead simple.  The older version has an extra pin I had to interface with called the “latch” pin in order to get it working.

I had a heck of a time getting this to work.  There were multiple problems.  The main problem I had was getting the ”advanced” PWM Adafruit libraries to work with this strip on the Teensy.  I’m not sure why but I just could not get it to work right.  Originally I had the wires soldered to the wrong pins on the Teensy but I finally figured out which pins were needed and I still couldn’t get it to work right.  I had to use the build in hardware SPI pins and even though I was, it just didn’t seem to ever work properly.  Sometimes the strip would light up but never in a pattern that made sense for the example code.

Here are some shots of the solder connections on the Teensy.  You can see that the Data and Clock pins of the RGB strip are soldered to the Teensy’s pins 1 and 2 which should be correct.

Teensy from the front

Teensy from the back

RGB LED strip connections

After a couple hours of debugging and swapping pins and soldering and desoldering I finally noticed that there was a more basic library I could try.  I must have skimmed right past that part in the tutorial.  The downside to the basic library is that it doesn’t support PWM control, meaning that you only get about 7 colors to choose from instead of millions.  Also, it doesn’t directly support dimming the lights which could be an issue if the USB port doesn’t provide enough current to light up all of the LEDs in full brightness at once.  I figured that I would go ahead and try it any way since for this project I really only need Green, Red, Yellow and maybe one other color.  All of those colors can be created without PWM.  The basic library does not use hardware SPI because it doesn’t need that high speed.  Therefore, you can choose any output pins in software to use to control the LED strip.  This makes things much easier because I don’t have to desolder and move the wires around if I attach them to the wrong place.

I downloaded and installed the Adafruit Basic library for the LED strip.  After restarting the Arduino app I was ready to go.  I loaded up the one example program that came with the library and modified the pin settings in the code to the pins that I used.  I also changed the number of LEDs in the strip from 32 to 12 since my strip only has 12 LEDs on it.  I flashed over the code and lo and behold, it worked!  After a few hours I finally had some basic animation patterns working on this thing.

I managed to get it working just before I had decided to leave the shop.  Now that I have the basic animations working I need to get some code written and working to control the strip the way I want.  I’m hoping to use serial communication to control the strip.  I want the Arduino code to just listen for two number values.  One value is the total license we are allowed from Splunk.  The second value will be our current license usage.  Then the Arduino will use those two numbers to figure out how many LEDs to light up and what colors those LEDs should be.  I’ll post another update once I have made more progress.

Raja!

Camera collar

We recently started letting our cat go outside and we started wondering what she actually does out there.  She tends to wander off for an hour or so and we have no idea where she goes or what she is doing.  I borrowed a mini color video camera from Eugene Maker Space and and attached it to my cat’s collar.  I put up a blog post about that a couple weeks ago.  I finally got some longer video uploaded to share.

The aspect ratio is weird because the video camera had to be mounted sideways in order to be securely fastened.  I had to rotate the video after it was uploaded to YouTube.  Also, the date and time are completely wrong because I haven’t figured out how to set them yet.

Bacon roses

I decided to make my girlfriend some bacon roses for Valentine’s day this year.  I wanted to do something different and something she wouldn’t expect.  I had seen this idea on Instructables a few months before and I knew I would have to try it some day.  I did some things a bit differently though and I figured I might as well detail the process I took here.  Most of these photos aren’t very good.  That’s a result of me rushing to get these bacon roses completed before my girlfriend got home from work combined with the fact that my house has terrible lighting for photos.

First off, I had to get a cupcake pan and poke a hole in each spot.  The Instructable recommended using a mini muffin pan but I forgot that when I was at Walmart and I purchased a regular sized cupcake pan instead.

Cupcake tin with holes

The dots in the center of each spot are holes that I poked using a hammer and a large nail. The hole is supposed to allow the bacon grease to drain out of the pan while the bacon is baking.  The Instructable suggesting drilling out the holes, but a commenter suggested using a nail to avoid creating metal shavings that may get into the food.  I liked that idea better and thought it would be easier to pound a few holes in the metal rather than try to drill them out.

Tools

After washing out the pan, I had to prepare the bacon.  I followed the Instructable exactly for this part.  I just rolled up each strip of bacon individually starting at the wider end.  Once I rolled a strip of bacon, I pressed it into one of the muffin spots with the fat side down.  When you press them in the bottom flares out a bit and helps create the rosebud look as well as helps the bacon stand up.

Raw bacon

The Instructable recommended placing a broiling pan underneath the cupcake pan to both allow the grease to drain out and to also catch the grease from falling into the oven.  I don’t have a boiling pan so I used a cookie sheet covered in foil instead.  I then created two large rolls of foil to use as stands to hold the cupcake pan up above the cookie sheet.  Without those, there would be less room underneath the cupcake pan and the grease would have a harder time draining.

Foil sheet with risers

Once the bacon was prepared I stuck them in the oven for 40 minutes at 350 degrees.  While that was cooking, I prepared the rose stems.

I bought the same roses listed in the Instructable.  They cost me $0.97 at Walmart for one “bouquet” of seven roses.  I found them over near the crafts section where they had a selection of fake floral arrangements.  I bought two and ended up cutting off one rose from each bouquet because I only had 12 strips of bacon.

Fake roses

Close up

The first step was to remove all of the rosebuds from the stems.  They slide off pretty easily.

Rosebuds removed

Next I had to take apart each rosebud.  This part was pretty easy to figure out.  It was tougher to take apart but these plastic pieces are pretty strong so I really didn’t have to worry about breaking anything.

Flower pieces separated

Once all of the pieces were separated, I put all of the green pieces back together and stuck the empty rose leaves back onto the stems.

Green pieces reassembled

Here is a shot of all 14 rose stems waiting for the bacon to finish cooking.

Ready for the bacon

After 40 minutes I was worried that the bacon hadn’t cooked enough.  I had a problem where my holes weren’t big enough and the bacon grease didn’t drain.  This seemed to result in the fatty part of the bacon at the bottom of the pan not cooking as much as the top.  Unfortunately Shannon was going to be home in about 10 minutes so I really didn’t have time to cook these any longer.  Also, the tops of the rosebuds were already crispy so I was afraid I would burn them.  Also, about half of the buds fell over while cooking.  I was able to stand most of them back up halfway through but it became clear why a mini cupcake pan would have been a better choice.

Bacon all cooked

Soaking up the grease

Once the bacon rosebuds were dried off and cool enough to hold I just slid them onto the rose stems.  I underestimated how heavy these bacon flowers would be and I really needed some kind of gravel or sand or something in the vase to hold them in place.  I managed without it but it was tricky to move the arrangement around without the stems falling over and the bacon falling off.

Fully assembled

I had a few minutes to spare before Shannon got home so I decided to do a bit extra for the presentation.  I took those otherwise wasted fake roses and chopped all of the petals off into individual petals.  I then scattered a bunch of them around the arrangement so she wouldn’t be able to miss it when she got home from work.

The presentation

She seemed to really like the bacon roses and definitely didn’t expect them.  The bacon ended up being a bit under cooked, especially at the center of the rosebud.  Also, the fat was extra chewy since it wasn’t cooked enough and I tend to like my bacon a bit crispier.  Next time I might try cooking the bacon longer or perhaps on a higher temperature setting.  I’ll also have to make the holes bigger so the grease can drain out more easily.

The soldering iron that came with the kit is a very basic “disposable” type.  I figured it would be a great tool to have at the shop though for whenever we do events like this.  I’d rather have people learn to solder on a junker iron than on a nice expensive one.

Soldering Iron

For the design, my original thought was to just use a block of wood and stick a piece of strong wire into it and bend the wire into a curly shape to hold the iron.  We didn’t have strong enough wire at the shop so I decided to try and make something completely out of wood.  Therefore, my materials consisted of one chunk of 2″x4″ board and some screws.

Materials

I first cut a piece of wood about the length of the iron.  I think cut a second piece of wood that was about 1/2 of the length of the first.  I cut a 45 degree angle into the second piece of wood with the miter saw.

Wood pieces

Then I used the drill press to drill a 5/16″ hole in the shorter piece of wood.  This hole was just big enough for the soldering iron to slide through it and stop where the handle of the iron starts.

Drilling a hole

Hole drilled out

The final step was to attach the two pieces together.  This part was a pain because of the angles.  I didn’t want to use glue because I hate waiting for glue to dry.  I opted to try screwing them together.  There was really no good way for me to clamp the work down to the bench with the tools I had on hand.  Also, I was feeling lazy so I did not pre-drill the holes which made the whole thing more difficult.

Attaching the pieces

The final piece works but since the screws are not countersunk, it is wobbly on the table.  Also, since I didn’t have a good way to hold the pieces together while I was attaching them, there is a small gap between the pieces of wood that looks horrible.  The smaller piece also ended up rotating a bit and is obviously crooked when looking at it in person.

Final piece

The end result was something that works, but not well enough that I am actually going to use it.  In fact, I already threw this thing away.  I wasn’t even going to document this but I figured that 1) it is funny and 2) it’s important to keep track of our failures because we learn more from our failures than we do from our successes.  I learned that I need more practice working with wood and that I need to be less lazy when building things.

Tada!