There’s nothing wrong with learning either of those tools, but if you really don’t want to, there are options.  If the server is running FTP, you can use something like Transmit to open the file in a local editor and saves will be automatically uploaded to the server.  Unfortunately, FTP is a very old and VERY insecure protocol that should not be used anymore.  What else can we do?

Using Secure Shell (SSH) Tunneling, we can establish an SSH session that routes arbitrary traffic through it to a specified port for any use we want.  Thanks to a nifty set of scripts called rsub, modified originally from TextMate’s rmate, we can run a little utility server on our local machine that interacts with your remote server for you and lets you open up remote files and save them back, all through an encrypted channel.

What Do I Do?

1. As of writing, these instructions work only for Sublime Text 2.  If I get a chance I’ll look into forking rsub for the newly released ST3 (which runs Python3).
2. If you don’t already have Sublime Text’s wonderful package manager, install it.
3. Hit Ctrl+Shift+P, start typing “install” and select “Install Package”
4. Start typing “rsub” and select it.
5. Once it’s installed, get on your terminal and do

   nano ~/.ssh/config

6. Paste the following lines:

   Host your_remote_server.com
       RemoteForward 52698 127.0.0.1:52698

7. Save (ctrl+w) and SSH into your server (ssh username@your_remote_server.com).
8. ‘Install’ the rsub remote script:

   sudo wget -O /usr/local/bin/rsub https://raw.github.com/aurora/rmate/master/rmate

9. Make that script executable:

   sudo chmod +x /usr/local/bin/rsub

10. Lastly, run rsub on the remote file you want to edit locally:

    rsub ~/my_project/my_file.html

    and it should magically open in Sublime Text!

Let me know if this works for you! Enjoy!

#!/bin/bash
for file in *.rtf ; do
filename=$(basename "$file") /usr/sbin/cupsfilter "$file" > "$filename.pdf"
done

• Getting started with the RN-XV WiFi Module & Node.js
• WiFi Joystick GitHub Repo
• Using the RN-XV WiFi Module as a Remote Switch

Thanks to everyone for coming and to Brad Stenger and everyone at the Times for inviting me!

The Arduino Button library (Github Repo) makes it easy to do some very common but rather tedious tasks. Usually when you interact with a button (such as a momentary switch), you mainly want to detect the state change, not just the current state. You have to do something like:

int lastState = 0;
void loop(){
    int currentState = digitalRead(11);
    if(currentState != lastState){
        // do something
    }
    lastState = currentState;
}

It’s not hard, just tedious. This new and improved Button library makes this much simpler but adds so much more. Now you can do it this way:

Button button = Button(12);

void onPress(Button& b){
	Serial.print("onPress: ");
	Serial.println(b.pin);
	// will print out "onPress: 12"
}

void setup(){
  Serial.begin(9600);
  // Assign callback function
  button.pressHandler(onPress);
}

void loop(){
  // update the buttons' internals
  button.process();
}

Features

• Object-oriented design

  Button myButton(11);

• Automatic pull-up setting

  Button myButton(11, BUTTON_PULLUP_INTERNAL);

• Simplified state-change detection:

  if(button.isPressed()) ...

• Callback model

  button.pressHandler(onPress)

• Built-in debouncing

  // Sets 50ms debounce duration
  Button button = Button(12, BUTTON_PULLUP_INTERNAL, true, 50);

Installing

To install, download the library, extract it to ~/Documents/Arduino/libraries and rename the folder “Button.” (Github generates a different name for the zip link.) Restart Arduino if it was already open.

I hope you find this useful! Please report any bugs using the Github issue tracker.

Here’s an example Arduino sketch that demonstrates how to read from and write to this part of memory:

• Connecting to the RPi’s GPIO header: I used an old floppy disk drive IDE ribbon cable.  It has 34 pins, but the RPi’s header is only 26 pins, so part of the connector is unused. I soldered some breadboard-friendly header pins onto the other end, which is working pretty well so far. Bear in mind that some IDE cables may be more complicated than they look. Before powering anything up, make sure you check that each conductor is indeed separate and you’re not accidentally grounding or shorting anything. You can always make your own by getting some 26-conductor IDC connectors and using a vice to crimp it onto a piece of ribbon cable.
   
• Pin Connections: …are confusing! There’s a master table here, and a diagram here.  Looking at the diagram, my breakout header starts with 3.3V and moves left to right, top to bottom.  Here are the pin connections from my header as pictured:
  • Pin 2: 5V
  • Pin 3: “GPIO0″. Connected to one end of the switch (the other end is connected to ground, since this GPIO pin has an internal pull-up resistor.  This means that when the switch is not closed, the pin reads as “High,” and when closed, “Low.”
  • Pin 6: GND (note that it’s jumpered to my ground rail on my breakout board)
  • Pin 7: “GPIO4″. The anode of the LED through a 220-ohm resistor.
• I’ll use this breakout board setup for all the following examples.  Different libraries/tools use different pin numbers, adding to the confusion, so I’ll try to clear it up.  Also note that I’m doing this through an SSH session, so there’s no monitor attached to the RPi. See my beginning instructions here if you don’t already have an SSH connection to your Pi.
• Important Note: The RPi Wiki takes pains to remind you that these GPIO pins are unbuffered and unprotected, so if you short something out, you could fry your whole Pi, so be careful!  There are a number of other breakout boards being developed that should make this safer.
• Important Note: Any program that accesses the GPIO pins must be run as root, so if you get an error, remember to “sudo” your command.
• Python: One of my preferred languages, so I figured I’d try it out. First, install pip (Python package installer):

  • sudo curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | python

  • Next, install the RPi.GPIO Python module:

  • sudo pip install rpi.gpio

  • Now, you can enter the python interpreter (sudo python) and do stuff like:

  • import RPi.GPIO as GPIO
    GPIO.setup(7, GPIO.OUT)
    GPIO.output(7, True)
    GPIO.output(7,False)

• Bash: Something I’ve always loved about Unix is the idea that everything is a file.  On the Raspberry Pi, the GPIO pins are files too! With the pictured breadboard setup, we can do the following to turn the LED on and off (note that this uses the “BCM” pin numbering but the breadboard stays the same!):
  • (You can’t just put sudo before each command because the second command that the output is directed to would not be run as root. So, for simplicity, we drop into root first.)

    sudo su -
    echo "4" > /sys/class/gpio/export
    echo "4" > /sys/class/gpio/export
    echo "out" > /sys/class/gpio/gpio4/direction
    echo "1" > /sys/class/gpio/gpio4/value
    echo "0" > /sys/class/gpio/gpio4/value

  • To read from an input, ‘cat’ it like any other file!

    echo "0" > /sys/class/gpio/export
    echo "in" > /sys/class/gpio/gpio0/direction
    cat /sys/class/gpio/gpio0/value

• C: Good old C.  The native example for C is really hairy, but luckily a plucky fellow named Gordon wrote an Arduino-like library just for the Raspberry Pi!  Here’s what you need to do:
  • Download and install the library:

    cd /tmp
    wget http://project-downloads.drogon.net/files/wiringPi.tgz
    
    tar xfz wiringPi.tgz
    cd wiringPi/wiringPi
    make
    sudo make install
    cd ../gpio
    make
    sudo make install

  • Your Pi’s system now has the wiringPi library installed, so we can write a little program that uses it.

    cd ~
    nano blink.c

  • Type or paste in this program:
    
  • And compile it:

    cc -o blink blink.c -L/usr/local/lib -lwiringPi

  • And run it:

    sudo ./blink

  • You should have a happily blinking LED. Yay! Now for something more interesting:
    
• Where’s my analogRead?  Sadly, unlike an Arduino, the RPi doesn’t have an onboard ADC (Analog to Digital Converter). However, some of the breakout boards being designed will include an external ADC, such as the Gertboard.  You can add your own external ADC, such as this one, by using the SPI bus on the RPi (the MOSI, MISO and SCK pins).
• That’s all for now! Hope this helps, and as always, let me know if it works or you run into any problems.

1. Firstly, your SD card’s partition is probably not large enough to accomodate all the files we’ll need, so we have to expand it to fit your card first.  From a terminal session on your Pi:

   1. printf "d\n3\nd\n2\nn\np\n2\n157696\n\nw\n" | sudo fdisk -cu /dev/mmcblk0

   2. sudo reboot

   3. sudo resize2fs /dev/mmcblk0p2

2. We need to add the repositories for the source to aptitude:

   sudo nano /etc/apt/sources.list

   Move to the bottom and paste this in and save (ctrl+o):

   deb-src http://ftp.uk.debian.org/debian/ squeeze main
   deb http://backports.debian.org/debian-backports squeeze-backports main

3. Update your aptitude cache:

   sudo apt-get update

4. We’ll need  to install a whole bunch of dependencies for building Pd and all the various externals.  This took like 4 days to manually figure out:

   sudo apt-get install rsync autoconf libfftw3-dev liblua5.1-0-dev swig libvorbis-dev ladspa-sdk libspeex-dev libmp3lame-dev lua5.1

5. Copy the source:

   rsync -av --delete rsync://128.238.56.50/distros/pd-extended/ pd-extended/

6. Since it will take a while, you may want to use this command to detach the process from your terminal session and log the output to a file:

   nohup rsync -av --delete rsync://128.238.56.50/distros/pd-extended/ pd-extended/ > rsync.log &

7. Build the main Pd dependencies:

   sudo apt-get build-dep puredata gem pdp

8. For some reason I had to change one of the externals’ makefile to get it to build correctly. Open /externals/OSCx/src/Makefile (I used nano), go to line 20 and remove “-lpd” so it looks like this:

   LIBS = -L../../../pd/bin -lc -lm

9. OK, we’re now ready to actually start building. This will take a long time, hours most likely. I did it piecemeal so I can’t say for sure how long it takes from start to finish.

10. cd pd-extended/packages/linux_make

11. nohup make install > makeinstall.log &

12. While you’re still logged in, you can monitor that logfile by doing

    tail -f makeinstall.log

13. Once that finishes, you should see “linux_make install succeeded!” Yay! If you encounter any errors please post them here and we’ll see what I missed.
14. Now we can make the actual Debian package that you can install like any other program:

    nohup make package > makepackage.log &

15. If you previously installed Puredata vanilla (as per my previous post), you’ll need to uninstall that first:

    sudo apt-get --purge remove puredata

16. For convenience I uploaded this package to puredata.info.  All you have to do is download that file to your RPi:

    wget -O Pd-0.43.1-extended-20120606.deb http://download.puredata.info/pd-extended-rpi/releases/1.0/Pd-0.43.1-extended-20120606.deb

17. Finally, let’s install it:

    sudo dpkg -i Pd-0.43.1-extended-20120606.deb

18. If everything goes well, you now have Pd-extended on your Raspberry Pi! Here’s a new test patch that uses Freeverb~ for you to test, like so:

    pd-extended -nogui -noadc -alsa testPatchExtended.pd

19. Presently, I’m getting some serious noise and I think it has something to do with the ALSA driver still being in beta. Looking into it. If any other linux hackers have any ideas, please let me know!