As development progressed with the addition of the ability to completly configure and script key mapping and automation using ruby, the decision was made to change to the name to Keymando to reflect that it was no longer just a tool for vi users.

So Just What is Keymando?

Keymando is a full-featured input mapping and automation tool for OSX. It is easier to see how Keymando can be used than to try to explain what it does.

Keymando Uses

Keymando is for productivity junkies, programmers, and any else who wants to start using their Mac more efficiently. Here are just a few uses:

• Map familiar shortcuts and hotkeys from one application to another.
• Use mnemonics to trigger automated tasks.
• Text Abbreviations.
• Vi-style hjkl navigation throughout OSX.
• Automate Skype logins and phone calls.
• Quickly insert dates, times, and other data.
• Disable application hotkeys and shortcuts.
• Pretty much anything you want using Ruby to write your own commands!

Features

• Map Keys – Allows for the mapping of key presses to other keys or other arbitrary commands.
• Filtering – Create a set of key mappings for a single application or group of applications.
• Dialogs – Set a global hotkey that prompts for user input then act on it.
• Ruby – Use the easy-to-use programming language, Ruby, to configure Keymando.
• Plugins – Write your own plugins to command your Mac to do what you want.

Plays Well with Others

Easily integrates with applications like Quicksilver, Divvy, and any other application on OSX.

• Quicksilver
• Divvy
• Any application in OSX!

History

Keymando was originally named ViKing due the ability the application had to mimic the vi editor’s navigation style in OSX, a navigation style that kept users’ hands on the home row instead of the arrow keys. Over the last few months ViKing underwent a re-branding effort into its new name, Keymando. This was done because the application has matured into a very useful product that is not only useful to vi(m) users but to everyone.

Future

Version 2 of Keymando is under active development with exicting new features that include:

• Recording and playback user interaction.
• Complete framework to access UI controls.

Sasha felt the need to make a cameo.

Source Code

https://github.com/kevincolyar/sprinklers

Summary

The following is a project that I’ve been wanting to do for a while.  My sprinkler system control box is located in my basement workshop and I wanted to be able to turn my sprinkler system stations off and on without having to run inside and downstairs constantly.  This is annoying when I’m adjusting, fixing, and blowing out sprinklers.

The first Saturday afternoon of this project was spent (stupidly) trying use a transistor to turn on the sprinkler station solenoids.  That was the day I learned you can’t use transistors with AC current. Doh.  This brought progress came to a halt and solid state relays were ordered.  Three days later 10 relays arrived and it only took burning up two of them to finally figure out that I should’ve just started with the Arduino 5V 50mA output pins instead of the higher current, direct USB 5V power.  Finally a single solenoid prototype was complete.

Prototype able to turn on a solenoid through a solid state relay triggered by the Arduino.

After the prototype was complete, it was time to write software.  The Arduino unit is controlled by a very simple ’sketch’ that listens on the usb serial port for a station number to turn on or off.  That’s it.  The other piece of software is the web server that displays a list of toggle buttons that correlate to the eight sprinkler stations.  The web server is a ruby 1.8.7 Sinatra application with basically two actions: on and off, with a station number parameter.  It connects to the Arduino via usb serial and sends the command to turn on or off a station to the Arduino when a button is toggled.

Once the software was complete, I turned my attention to finishing the hardware by adding the rest of the relays to the breadboard and wiring the whole thing up.  Eight 5V 50mA output pins from the Arduino were wired to 20mA – 50mA positive leads on the relay that control the on/off of the relay.  LED were also placed inline as indicators of when the relay was activated.  These LEDs were left over from my Game of Life pumpkin project.

The finished hardware.

The final piece of the puzzle was to tie in the wire coming from the Arduino relays back two the existing sprinkler control box and eventually to the station valve solenoids.

The original sprinkler system control board.

Once all the wiring was complete, this first stage of the project was done.  I was able to go outside, open the website on my iPhone and turn on and off any the sprinkler stations (I hope to post a video of the system in action soon).

More Photos

Making a mess.

The laptop with Ubuntu 10.10 running a ruby 1.8.7 Sinatra app.

Close-up of the Sinatra server log.

The quick and dirty (UGLY) web interface.

What’s Next?

• Implement a scheduling framework
• Implement native iPhone App
• Pull down weather (temp., humidity, rain fall) info from the web to forecast watering schedule
• Implement machine learning to determine optimal watering schedules

“This plugin contains functions/mappings/commands to enable Vim to access several databases. Current databases supported are: Mysql, PostgreSQL, Ingres, Oracle, Oracle Rdb (VMS), Sybase Adaptive Server Anywhere, Sybase Adaptive Server Enterprise, Microsoft SQL Server, DB2, Interbase and SQLite and ODBC are supported.  New to version 5.x of dbext introduces the support for Perl’s DBI layer.  If the database you are using is not *natively* supported by dbext, but has a DBI interface, dbext’s standard feature set is available.  For those already using dbext, the DBI interface should provide a performance boost when running statements against your database.  DBI also provides an ODBC bridge, therefore any ODBC compliant database is also accessible.”

I had a little trouble getting it connected to SQL Server from OSX so here are the steps I took to get it work.  Hopefully it helps someone else.

Get the dbext.vim plugin here

http://www.vim.org/scripts/script.php?script_id=356

Install the perl odbc libs

$ sudo perl -MCPAN -e shell

cpan[1]> install DBI
cpan[2]> install DBD::ODBC

*Note: Make sure you sudo when doing this.  I made the mistake of doing sudo -i which was trying to install the libs to my system perl installation.  This didn’t work because I was using mac ports and vim couldn’t see where the cpan modules were being installed to.

Add your connection string to your .vimrc

let g:dbext_default_profile_myconnection='type=ODBC:user=chucknorris:passwd=roundhouse:dsnname=mydsn:dbname=mydatabase'

Here you specify the dsn you want to connect to.  See my other post for setting your database dsn using FreeTDS and UnixODBC.

I used Mac Ports for this setup so your milage may vary if you’re using something else like Homebrew. Mac Ports installs its files to /opt/local so you’ll have do some translation if you’re using something else.

My project is on Rails 2.3.x and I haven’t tried any of this with Rails 3.x so use at your own risk. Please leave feedback if you know how to getting it working on Rails 3.x setups. Thanks.

Install and Configure FreeTDS

Mac Ports

[shell]
sudo port install freetds +odbc
[/shell]

Debian/Ubuntu

[shell]
sudo apt-get install freetds
[/shell]

Required /opt/local/etc/freetds/freetds.conf entries:

[shell]
[MySqlServerHost]
host = 10.10.1.100
port = 1433
tds version = 8.0
[/shell]

*Note: SQL Server Clusters use port 3008

Install and Configure UnixODBC

Mac Ports

[shell]
sudo port install unixODBC
[/shell]

Debian/Ubuntu

[shell]
sudo apt-get install unixODBC
[/shell]

Required /opt/local/etc/odbc.ini entries:

[shell]
[MyAppDSN]
Driver = FreeTDS
Description = ODBC connection via FreeTDS
Servername = MySqlServerHost
Database = MyAppDatabase
[/shell]

Setup RVM if Needed

If you’re using RVM, and you should be, add this rake file to your project and run:

[shell]
rake rvm:install:all
[/shell]

*See http://www.metaskills.net/2010/7/30/the-rvm-ruby-api for more info.

Configure Rails

config/environment.rb:

[ruby]
config.gem ‘activerecord-sqlserver-adapter’, :version => ‘2.2.22′, :lib => false
config.gem "dbd-odbc", :version => ‘0.2.4′, :lib => false
[/ruby]

config/database.yml:

[ruby]
development:
adapter: sqlserver
mode: odbc
dsn: MyAppDSN
username: chuck
password: norris1
encoding: utf8
[/ruby]

Try

:set foldmethod=manual

and see if that speeds up auto-completion.

The following site has a script to put in your .vimrc that will allow you to keep your foldmethod setting and only adjust it to manual when insert text, which is what is causing the slowness.

http://vim.wikia.com/wiki/Keep_folds_closed_while_inserting_text

Package “com.your.app.id”: Bundle at “YourApp.app/Contents/Frameworks/MacRuby.framework” in Payload not declared in Package info

you can fix it by removing the Current symbolic link and renaming the 0.8 MacRuby folder to Current (see shell script below).  Apparently the Application Loader is trying to load MacRuby’s bundle Info.plist file twice, once for Current and another time for 0.8, which are actually the same directory.

Here is the shell script I currently use to sign and package my app:

#!/bin/sh
APP="MyApp"
BUSINESS="My Bidniz"
TARGET="$APP.app/Contents/Frameworks/MacRuby.framework/Versions/Current"
SOURCE="$APP.app/Contents/Frameworks/MacRuby.framework/Versions/0.8"
 
cd build/Release
 
# Remove symbolic link "Current" and replace it with actual directory.  For some reason the
# Application Loader gets confused and tries to read the MacRuby Info.plist twice, once for each
# directory, Current and 0.8, even though Current is a sym link to 0.8
if [ -h "$TARGET" ]; then
  echo "Removing:"
  rm -v "$TARGET"
  echo "Moving:"
  mv -v "$SOURCE" "$TARGET"
fi
 
codesign -f -s "3rd Party Mac Developer Application: $BUSINESS" "$APP.app"
productbuild --component "$APP.app" /Applications --sign "3rd Party Mac Developer Installer: $BUSINESS" "$APP.pkg"
 
cd ../../

Enter the Chrome Duplicate Tab Detector extension. This extension will open the tab of the site you’re trying to access if it is already present. There was one hitch with the current functionality which was that the url of the existing tab and the one you were opening had to match exactly. This wouldn’t work for sites like Gmail that append parameters to the url when changing folders or composing mail.

So I forked the code, made the small change to fix this, and made it available here:

https://github.com/downloads/kevincolyar/chrome-duplicate-tab-detector/chrome-duplicate-tab-detector.crx

Thanks to mbhutton for creating the original chrome extension.

UPDATE: Now ignores # style parameters like http://www.google.com/reader/view/#stream/feed%2Fhttp%3A%2F%2Ffeedproxy.google.com%2Ffailblog

if you’re using 1.8.7.

All you need to do now is make sure your .vimrc is set for 256 color schemes:

set t_Co=256
colorscheme grb4

Now you’ll have pretty vim color schemes in iTerm2.

* grb4 is Gary Bernhardt’s color scheme found here: https://github.com/garybernhardt/dotfiles

The Build Process

Ingredients
• Pumpkin
• Drill
• Arduino
• Arduino Mux Shield – Give the Arduino 48 inputs/ouputs
• LEDs - These were bigger that I anticipated but still worked
• Resistors – Ended up not needing any
• Wiring – I just used what I could find, some patch cat5 cable mostly
• Drink Straws

Pumpkin after 48 holes drilled and pieces of straws places inside for the leds and wires.

Wires – 5 sections of 3′ patch cable that I scrounged from my wiring supply. I also recommended that you have a puppy around to help you solder.

Leads – Each 3′ section of patch cable had 8 wires that I used for the positive lead that I ran from the arduino to the positive of the led. Each section of 8 leads is one row of the led matrix, which made it easy to program. If I would’ve had more patch cable I could have used each stranded pair as the positive and negative lead, however, I ended up using what I had which was just some small gauge, solid core wiring.

Unfortunately, those are all the pictures I managed to take during the build. All that remains was to run the negative leads, solder all the LEDs, plugin all the leads to the mux shield, and program the Arduino. Getting the mux shield to output up to all 48 pins at the same time was by far the most difficult part of this whole endeavor, but once I figured out the right calls to make, it all came together.

I’d love to hear your feedback. Leave a comment below or contact me.