Follow these instructions from resque readme (apache, ngnix) and check out current resque repo. Now update following two files:
1. Add gem "resque-scheduler","2.0.0.d" to Gemfile
2. Run bundle
3. Add require 'resque_scheduler' to config.ru

Restart you webserver and are ready to go – Happy scheduling!

Both file after editing:

#!/usr/bin/env ruby
require 'logger'

$LOAD_PATH.unshift ::File.expand_path(::File.dirname(__FILE__) + '/lib')
require 'resque/server'

# Set the RESQUECONFIG env variable if you've a `resque.rb` or similar
# config file you want loaded on boot.
if ENV['RESQUECONFIG'] && ::File.exists?(::File.expand_path(ENV['RESQUECONFIG']))
  load ::File.expand_path(ENV['RESQUECONFIG'])
end

require 'resque_scheduler'
                                           
use Rack::ShowExceptions
run Resque::Server.new

source :rubygems

gemspec

group :test do
  gem "rake"
  gem "resque-scheduler","2.0.0.d"
  gem "rack-test", "~> 0.5"
  gem "mocha", "~> 0.9.7"
  gem "leftright", :platforms => :mri_18
  gem "yajl-ruby", "~>0.8.2", :platforms => :mri
  gem "json", "~>1.5.3", :platforms => :jruby
end

I was quite annoyed by the wasted time it took each time I grep the rails routes table.
Wait, can’t this be cached? – Sure it can!
So I came up this nice little alias to cache the output once:

alias route='CF=tmp/routes_cache; [[ ! -s $CF ]] && rake routes > $CF; cat $CF | grep '


now it’s ultra fast, try e.g.:

$ route root

bang!

Alright, I spend some time with my new toy Nabaztag ‘Nabaccia‘

What confused me most: there have been two Firmware version out there. Some project depend on the old one, some other on the, new Jabber based, version.

Here are some interesting projects I’ve found:
http://nabaztools.sourceforge.net/ (outdated, MAC OS X)

http://sourceforge.net/projects/opennab/ (PHP)

http://code.google.com/p/nabazlib/ (python)

http://nabazlab.sourceforge.net/index_en.htm (windows only)

A working Proxyserver: jNabServer

http://code.google.com/p/jnabserver/

A good summery how to start ‘nabazhacking’ is here:

http://www.saraproft.org/?p=912

http://blog.makezine.com/archive/2006/03/more_nabaztag_hacking.html

A very detailed look into the electronics of the rabbit:

http://www.petertyser.com/2007/03/11/nabaztag-nabaztagtag-dissection/

Forums:
http://nabaztag.forumactif.fr/ (french)
http://www.mynabaztag.de (german)
http://www.nabaztalk.com (english)

Blogs:
http://www.nabaztag-blog.de (german)

Quite complete list of other sources:

http://www.nabzone.com/?frG=/liens.php

My first tests went quite well. The Rainbowduino comes with a ready to use the program/sketch which allows you basic controls via I2C bus easily, like writing letters & lines in different color and light strength. But soon I hit the limits when it came so single control each LED to my will. So no doubt, I had to dig deeper in understanding how to control the Rainbowduino. Here a short summery of my results:

To understand how the Rainbowduino works, I kind of reverseengineered the sketch by seeedstudio which came with the controller. As usual for driving those Matrixes, PWM is used as basic concept. This means the frame image is created row by row by high frequency, so human eye puts it all together to one single image.

To simplify this process I created the Rainbowduino.h Library, which comes with some nice methods to set frames and draw those to the Rainbowduino. It’s part of the mtXcontrol firmware an can be downloaded from github

How it works:
To tell rainbowduino which row to draw the method ‘open_row’ is called. As each row is represented by a one output PIN, this method sets the according PIN to high, all others to low. Unfortunately the row pins are not all on one port: rows 1-3 are on PORTB Bit 1-3, rows 4-8 are on PORTD Bit 4-8. This makes the method kind of bit ugly

After the row is selected, its time to set the pixels. One pixel consists of 3 LEDs: red, green & blue. Each LED has to be separately to high or low to mix the final color (e.g. red + green is yellow). First all blue values of a row are set, then red and finally green. This happens in serial on PORTC. First bit is the value input, second bit is clock, bit 3 the write mode bit and bit 4 to display the shifted value. Call the method ‘draw_row’ to display a row. First parameter is the row number (0-7), second the intensity (1-16) and then the red, blue & green values for the row. e.g passing the color values 1,0,0 would light the first pixel red and all other off, where as 255, 255, 255 would light up all LED and all colors, to the full row would be white.

To store the row values the Library comes with a frame buffer for 10 frames. (That the amount of frames we can store to EEPROM without compression as well). You can pre fill the buffer and set the frame number to display. By calling draw() the frame of the current _frame number is drawn.

It makes sense to call this function by a timer interrupt to not disturb your actual program progress and to ensure it’s call in regular frequency to avoid different display colors.

To set up the timer, include this in your code:

Rainbowduino rainbow = Rainbowduino(10);  //max 10 Frames

void setup_timer() {
  TCCR2A = 0;
  TCCR2B = 1<<CS22 | 0 <<CS21 | 0<<CS20;
  TIMSK2 = 1<<TOIE2;
  TCNT2 = 0;
  sei();
}

ISR(TIMER2_OVF_vect) {
  rainbow.draw();
}

Now, just fill you frames with

rainbow.set_frame(0, *data);

and your’re ready to go. Have fun!

First tests of the library with earlier version of mtXcontrol, an Editor to create images on the Matrix easily:

Click here to view the embedded video.

Stay tuned for more examples soon…