function getCurrentFile() {
  var filename = document.location.href;
  var tail = (filename.indexOf(".", (filename.indexOf(".edu")+1)) == -1) ? filename.length : filename.lastIndexOf(".");
  return (filename.lastIndexOf("/") >= (filename.length - 1)) ? (filename.substring( filename.substring(0, filename.length - 2).lastIndexOf("/")+1, filename.lastIndexOf("/"))).toLowerCase() : (filename.substring(filename.lastIndexOf("/")+1, tail)).toLowerCase();
}

This function returns the current filename (minus the file extension) in all lower-case. Feel free to modify it to suit your needs. It also works properly even when a URL does not have a file extension (such as with some asp-based sites), or when there is no filename present (returns the folder name). This function is great for highlighting menu items based on which page the user is currently browsing.

I have a Canon HF200 video camera and it outputs HD video, but it’s in .MTS file format. This is a pain because there are no good free video converters or editors for .MTS files. But using Avidemux, an open-source video converter, I was able to edit and convert my video to .mp4 while keeping my sanity and my money.

If you know your way around avidemux, pay attention to black colored text.

If you need extra help along the way, or I have something pointless to say, it will be in gray.

1 – Open the File

The first thing you have to do is import your video into Avidemux by one of two methods:

1) file –> open –> your-video.MTS

2) drag and drop the video file into avidemux

A dialog will appear saying, “This looks like MPEG, Do you want to index it?”… say “yes”

Avidemux will then tell you that it has detected H.264, say “yes”  to it’s other mode.

2 – Set Encoding Options

For the Video encoder you should use MPEG-4 AVC

For Audio I recommend AAC (Faac) and a bitrate of 192, (I’ll tell you right now AC3 does NOT work with youtube).

Use mp4 for the encapsulation (not avi like in the above pic).

Configure –> General

Use CRF (Constant Rate Factor) around 16 – 20. A CRF of 16 produces a larger file size; the higher the number, the less the quality and file size.

Configure –> Motion

Use UHS (Uneven Hexagonal Search) and SR (Subpixel Refinement) of 9 for best results.

3 – Fix Frame Rate Issues

Here is where everyone has the problem of “Why is the video half speed!?”

Well, that’s because avidemux doesn’t like you, and that Avidemux decided to treat the predictive and reference frames differently.

The way I fixed this was to double the video frame rate:

Main menu –> Video –> Frame Rate

According to my TI-89, 29.97 * 2 = 59.94 (or I just did it in my head, but think the 89 is a powerful tool, especially if you’re an electrical engineer)

Well… now your video is the right speed… but why is the file so large?

Go to video filters, transform –> Resample fps (back to 29.97).

Yeah, I know, I went extra wide screen with my video, so I feel like a ninja when I watch it, big deal.

I used other filters as well to reduce the resolution and trim the unneeded parts of the video to save space.

4 – Save the Video

File –> Save –> Save Video

Make sure you use the .mp4 extension.

That’s all, enjoy your well-compressed .mp4 video!

I happened to scavenge a couple of SLG2016′s from some old workstation debug displays. After finally locating a datasheet, I realized that they used the standard ASCII charset, so they are extremely easy to drive. Note: The SLG2016 differs from the SLR2016, SLO2016, and SLY2016 only by LED color.

The only downside to these displays is that they use quite a few pins (7 data lines, 2 digit select lines, write line, and optional blanking line). For now, I’m driving the display with all pins in parallel on a tiny88 which has plenty of pins; however I plan on using a shift register to cut down on data bus pin usage in the future. The displays only need the data lines to be held stable during a write cycle, making shift registers well-suited to this task.

To flash the attiny88, I’m using a Bus Pirate (pictured above) flashed with the STK500v2 emulation firmware. This allows me to use avr-gcc with AVR Studio to program the chip.

Here is some code I used to test the displays, using PORTD for data lines, and the 2 LSB’s of PORTC for digit select lines. This is the first time I’ve worked with AVRs outside of the Arduino environment, so pardon any flagrant errors and drop me a comment if you have any suggestions.

#define F_CPU 1000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

void wr();
void wrChar(char toWrite, int dig);
void wrWord(char *word);
void scrollWord(char *word);
void delay_ms(uint16_t ms);

int main (void){
  DDRC=0xFF;
  DDRD=0xFF;
  PORTD=0x00;
  PORTC=0x00;

  // Loop through a few strings for testing
  while(1){
    wrWord("Helo");
    delay_ms(500);
    wrWord("*?%$");
    delay_ms(500);
  }
}

// Toggle write pin (PC0)
void wr() {
  PORTD &= ~(1<<7);
  delay_ms(1);
  PORTD |= (1<<7);
}

// Write char to position
void wrChar(char toWrite, int pos){
  PORTC = pos;  // Set digit select lines
  PORTD = toWrite;  // Set data lines
  wr();  // Toggle write pin
}

// Write 4-char word
void wrWord(char *word){
  for(int i=3; i>=0; i--){
    wrChar(word[i], 3-i);
  }
}

// Generic delay function
void delay_ms(uint16_t ms) {
  while (ms) {
    _delay_ms(1);
    ms--;
  }
}

I’m currently working on building a EMC2-controlled CNC machine with mostly parts I have on hand. I decided to use Victor 883′s to control my servos, but EMC2 does not put out the RC-style PWM signal that victors are driven with. Thankfully, hardware in EMC2 is configured with HAL, allowing the software to work with nearly any hardware. Below are the values and configuration I used. If you are planning on using other RC-style motor controllers, you’ll need to calculate these values yourself.

If you are planning on using an RC-style motor controller for a CNC machine, note that you will likely not get the precision achieved by professional servo controllers or homemade h-bridges. However, I have achieved excellent accuracy with the Victor 883 motor controller, my semi-tuned PID loop consistently gets +/-.0032″ accuracy.

Duty cycle range for Victor 883 (as measured)

Maximum duty cycle: 95.29%
Minimum duty cycle: 56.08%

Scale and Offset Values (scale/offset from [-1, 1] to [.5608, .9529] )

Scale amount: .1952
Offset amount: .7554

X-axis Configuration Example

# PWM output for X-axis
linksp Xpwm => parport.0.pin-02-out

setp pwmgen.0.pwm-freq 490.0 # seems to work well

# Minimum and maximum duty cycle for the Victor 883
setp pwmgen.0.max-dc .9529
setp pwmgen.0.min-dc .5608

# Scale and offset pwm signal
setp pwmgen.0.scale .1952
setp pwmgen.0.offset .7554

There are numerous guides about setting up Google Voice and an incoming sip number for free outgoing calling. Sadly, all of the guides I found were written for FreePBX or some other Asterisk bundle, and also used a shell script to do much of the work (scary!). I have compiled the minimal amount that you need to put in your asterisk conf files to make things work, GUI-free and variant-independent.

Prerequisites

First off, you need a sip number. I recommend sipgate or ipkall (I use sipgate, it’s much more user-friendly). If you google around, you’ll find out how to set up your sipgate/ipkall number as an incoming number in asterisk, I won’t waste time covering it here.

Secondly, you need a google voice number. Once you get said number, turn off call presentation. Also, assign the account a password that you don’t mind having plaintext in a conf file. In addition, you must add your incoming sip number as a phone in google voice. I’d recommend connecting a softphone to your sip number to set this up with google’s verification call, or redirect all incoming calls in Asterisk to your extension.

Thirdly, you need pygooglevoice. Download and install it, or use python’s easy_install command.

The outgoing rule

Now for the actual configuration. First you need to set up an outgoing call rule, so all calls to the outside world (in this case, 10-digit numbers preceded with a “9″) are directed though google voice.

[CallingRule_LocalCalls]
exten = _9XXXXXXXXXX,1,Goto(custom-gv,${EXTEN:-10},1)

Explanation: Any outgoing 10-digit number prefixed with a 9 will match this rule and go to the custom-gv section which we will set up later. The number that was dialed is passed (the “-10″ excludes the 9 prefix from this) at the first dialplan rule.

The GV dialer

Now we need to set up the custom-gv section:

[custom-gv]
exten => _X.,1,Verbose(0, Custom-GV Preparing to call and park call at number ${EXTEN})
exten => _X.,n,Wait(1)
exten => _X.,n,Playback(pls-wait-connect-call)
exten => _X.,n,System(gvoice -e me@me.com -p GVPassword call ${EXTEN} IncomingNum &)
exten => _X.,n,Set(PARKINGEXTEN=701)
exten => _X.,n,Park()

Explanation: After you dial an outgoing number, you’ll be dropped in here. The Verbose() function tosses some output in debug level 0 and up (see the console for this output). The System() command dials the number with google voice. Make sure you change the items in strikethrough to your own personal information. The call is then parked on extension 701 (70X extensions for parking are default. Switch to your parking extension range if you are using non-default options).

Routing GV callbacks

Now you need to set up an incoming call rule. Direct all incoming calls from your sip number at this rule.

[incoming-call-sifter]
exten = s,1,NoOp(CIDredirect)
exten = s,2,Verbose(0, Got incoming CID ${CALLERID(num)}, redirecting…)
exten = s,3,GotoIf($["${CALLERID(num)}" == "GVNumber"]?custom-park,s,1)
exten = s,4,Goto(section-to-route-normal-incoming-calls,s,1)

Explanation: If your google voice number rings your PBX, you know that it’s connecting you to the call you just dialed, so we need to reconnect it to the extension you dialed from. We’ll handle linking of the incoming GV call and your outgoing call (which is now parked) in the next section (custom-park).

Bringing it all together

The custom-park section links a google voice incoming call (which is actually ringing the person you originally dialed) with your original outgoing call (which is parked).

[custom-park]
exten => s,1,Verbose(0, Got incoming GV Callback! Connecting to your original outgoing call…)
exten => s,2,ParkedCall(701)

Explanation: After you dialed your external number, your call was parked as google voice started dialing the other number. This section joins your outgoing call with google voice’s incoming call, so you are connected to the party you originally dialed.

You’re done!

Well that turned out to be a bit longer than I expected, but if you know what you’re doing, you can just ignore the italicized text.

It looks like getting free data access on iDen handsets is going to end, likely on or before 6/20/10 according to this Sprint document (credit Engadget). Coincidentally, this is the same day that the Motorola i1 is released, the first Android phone on the iDen network. With this phone, Sprint would needed to lock down iDen data access a bit harder than blocking the phone’s built-in browser (the status quo), so the change will affect all phones on the iDen network (Boost and Nextel).

This also means that getting mobile connectivity for your Arduino will no longer be free. Boost mobile’s data rates run at $.35/day.

Update: 6/20 has passed, and I still have data access.

I’ve started constructing the basic electronics for the CNC machine I’m working on. It’s going to be a cheap machine made with what I have on hand, so don’t expect anything too amazing . Here are some random build photos…

CAT5 signalling cable for quadrature encoder, motor PWM, and limit switches for a single axis

All communication for motor controllers (PWM), encoders, and limit switches is being done over CAT5 cable, just because it’s pluggable, easy to use, and longer or shorter cables can be swapped in. Currently it looks like I can live with 1 CAT5 cable per axis.

Victor 883 Speed Controller, by Innovation First

For motor controllers, I’m using Victor 883′s. The controllers are currently running at 12v, but will run at 24v once I get some appropriate power supplies. These controllers weren’t intended for precise positioning and motion control (they are RC-style, meant for competitive robotics), but they perform amazingly well after some HAL PWM adjustments to EMC2.

EMC2, E-stop button, and my crazy parallel port breakout

Speaking of which, I am using EMC2 to control my CNC machine. Communication is all over the parallel port, saving me a ton of cash that would otherwise be spent on an FPGA card (although I’ll be needing another parallel port PCI card). EMC2 provides a ton of functionality and, unlike all other software of its type, it allows low-level HAL descriptors for motor controllers, encoders, and any other hardware. This allows you to move some complexity from your hardware into your software, or to modify the software to use old or unsupported hardware.

EMC2 Motor Controller Test from Ethan Zonca on Vimeo.

I’ll be posting more information on the project as the summer progresses, although I expect progress to be quite slow.

Animal Collective – Daily Routine

Freelance Whales – Generator First Floor

TV on the Radio – Staring at the Sun

30 Seconds to Mars – This is War

Chiddy Bang – The Opposite of Adults

Mute Math – Stall Out

Black Gold – Detroit

Aqualung – Brighter Than Sunshine

Well, the school year is over, so I thought I’d post up some information about my (extremely cheap and junky-looking but functional) door opener.

The door handle is turned by one 24v globe motor (which have encoders that I’m sadly not using at the moment), and is pulled open by another identical motor. A very affordable ($30) SparkFun RFID reader is attached to the back the door so cards can be scanned from the outside. An arduino controls the process, and drives motors and a cooling fan with 3 darlington transistors.

Power supply case housing arduino and circuitry, along with door-pulling motor and ridiculously ugly tie-dye duct tape

The arduino was attached to an old Dell laptop, which ran the Apache webserver. A small password-protected php web interface was created to allow door opening from anywhere on campus. KDE4 widgets allowed door opening from computers inside the room, letting my roommate and I avoid walking less than 8 feet (or less) away to open the door for someone.

Touchscreen mounted to wall, password widget not shown. And no, I did not actually go to school in Munich, Germany

I also put a password-protected KDE4 widget on our touchscreen mounted on the wall outside of our room, so if one of us forgot our RFID card, we could type in a password on the touchscreen, and the door would open. Fun stuff.

Unfortunately I don’t have too many pictures, and the entire thing is disassembled now. Hopefully next year I’ll improve it (encoders and PID for motion control?) and post some more information.