Tag: raspbian

  • Processing 2.1 + Oracle Java + Raspberry Pi + Serial + Arduino = ☺

    Hey! This is very old and there’s an officially supported version out now coming out very soon.

    Update for Raspberry Pi 2/Processing 2.2.1/Processing 3.0.5: Raspbian now ships with Java 8, and Processing only likes Java 7. oracle-java7-jdk is still in the repos, so install that, and follow the instructions below. It’s a bit flakey, but when it runs, runs quite fast on the Raspberry Pi 2. You might have more luck running Processing.js or p5.js in the browser.

    With Sun Oracle hardfloat Java now available, Processing now runs at a decent clip on the Raspberry Pi. My old instructions are now very obsolete. Here are current, tested instructions for installing it under Raspbian.

    [This is a particular solution to installing a Serial/Firmata-enabled Processing 2.1 distribution on a Raspberry Pi. Processing still has issues with other aspects of visual programming (particularly video) that I’m not addressing here.]

    A lot of software is installed here, and much of it depends on previous steps. Don’t jump in mid-way and expect it to work.

    Update the system

    Always a good plan if you’re doing major upgrades:

    sudo apt-get update
    sudo apt-get dist-upgrade

    Install Sun Oracle Java

    sudo apt-get install oracle-java7-jdk

    Check if the right version is installed as default: java -version should give

    java version "1.7.0_40"
    Java(TM) SE Runtime Environment (build 1.7.0_40-b43)
    Java HotSpot(TM) Client VM (build 24.0-b56, mixed mode)

    If you get anything else, you need to make Sun Oracle’s version the default:

    sudo update-alternatives --config java

    Download & Install Processing

    Go to Download \ Processing.org and get the Linux 32-bit version.  It’s big; about 100 MB. I’m going to install it in my home directory, so the base path will be ~/processing-2.1. Extract it:

    tar xvzf processing-2.1-linux32.tgz

    Now you have to remove the included x86 Java runtime, and replace it with the Raspberry Pi’s armhf one:

    rm -rf ~/processing-2.1/java 
    ln -s /usr/lib/jvm/jdk-7-oracle-armhf ~/processing-2.1/java

    You should now have a Processing installation that will run, but there’s some more we need to get serial and Arduino support.

    Install the  java Simple Serial connector

    Download jSSC-2.6.0-Release.zip and extract it:

    unzip jSSC-2.6.0-Release.zip

    Now overwrite the jssc.jar that ships with Processing with the one you just downloaded:

    mv jSSC-2.6.0-Release/jssc.jar ~/processing-2.1/modes/java/libraries/serial/library/

    (You can remove the jSSC folder now: rm -r jSSC-2.6.0-Release)

    Test Processing’s serial support

    You’re almost there! Fire up Processing:

    ~/processing-2.1/processing

    and try Perhaps the World’s Most Boring Processing Sketchâ„¢:

    // Example by Tom Igoe
    
    import processing.serial.*;
    
    // The serial port
    Serial myPort;
    
    // List all the available serial ports
    println(Serial.list());
    

    Screenshot from 2014-01-07 20:08:32When this runs (it’s a little slow), you should get a single line of output, which should start /dev/tty___:

    /dev/ttyACM0

    (I have an Arduino Leonardo attached, which usually appears as an ACM device.)

    Installing Arduino/Firmata support

    (I’m not going to go into uploading Firmata onto your Arduino here. All I can recommend is that you use the newest version at firmata/arduino, rather than the old code bundled with your Arduino distribution.)

    Exit Processing, and download processing-arduino.zip from firmata/processing. Extract it into your Processing sketchbook:

    unzip processing-arduino.zip -d ~/sketchbook/libraries/

    For tedious reasons, you also have to rename one of the files:

    mv  ~/sketchbook/libraries/arduino/library/Arduino.jar  ~/sketchbook/libraries/arduino/library/arduino.jar

    Start up Processing again, and  save Most Probably the World’s Second Least Interesting Processing Programâ„¢:

    import processing.serial.*;
    import cc.arduino.*;
    Arduino arduino;
    int ledPin = 13;
    
    void setup()
    {
      println(Arduino.list());
      arduino = new Arduino(this, Arduino.list()[0], 57600);
      arduino.pinMode(ledPin, Arduino.OUTPUT);
    }
    
    void draw()
    {
      arduino.digitalWrite(ledPin, Arduino.HIGH);
      delay(1000);
      arduino.digitalWrite(ledPin, Arduino.LOW);
      delay(1000);
    }
    

    Screenshot from 2014-01-07 21:13:54
    What this sketch does is emulate the µC’s “Hello World” program, Blink. It flashes the board’s LED once per second. Boring? Yes. But if it worked, you have a working Processing 2.1 installation on your Raspberry Pi. Go forth and make more interesting things.
    (Props to bitcraftlab/wolfing for the basic outline for installing Processing, and for samaygoenka for the prodding needed to update and test the Processing installation process. If you’re still stuck, the Processing 2.0 Forum and the Raspberry Pi Forum are good places to ask.)

  • My Raspberry Pi talks to my Oscilloscope

    Hey! This post is completely ancient. It doesn’t even use Python 3. Advice given here might be well out of date.


    … it complains that the oscilloscope is always making waves.

    DS1EB134907266_0

    Ahem. Anyway. I have a Rigol DS1102E 100 MHz Digital Oscilloscope. For such a cheap device, it’s remarkable that you can control it using USB Test & Measurement Class commands. I’d been wanting to use a Raspberry Pi as a headless data acquisition box with the oscilloscope for a while, but Raspbian doesn’t ship with the usbtmc kernel module. I thought I was stuck.

    Alex Forencich turned up in the forum with an all-Python solution: Python USBTMC (source: alexforencich / python-usbtmc). I got this working quite nicely today on both the Raspberry Pi and my Ubuntu laptop. Here’s how I installed it:

    1. Check your device’s USB code with lsusb:
      $ lsusb
      Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.
      ….
      Bus 001 Device 004: ID 1ab1:0588 Rigol Technologies DS1000 SERIES
    2. Ensure that libusb-1.0 is installed:
      sudo apt-get install libusb-1.0-0
    3. Create a new group, usbtmc:
      sudo groupadd usbtmc
    4. Add yourself to this group:
      sudo usermod -a -G usbtmc pi
    5. As root, create a file /etc/udev/rules.d/usbtmc.rules. You’ll need to put in your device’s ID values:
      # USBTMC instruments
      # Rigol DS1100 – ID 1ab1:0588 Rigol Technologies DS1000 SERIES
      SUBSYSTEMS==”usb”, ACTION==”add”, ATTRS{idVendor}==”1ab1″, ATTRS{idProduct}==”0588″, GROUP=”usbtmc”, MODE=”0660″
      (all of the SUBSYSTEMS to MODE= should be one one line)
    6. Download and install the latest pyusb (Raspbian version is rather old):
      git clone https://github.com/walac/pyusb.git
      cd pyusb
      python setup.py build
      sudo python setup.py install
    7. Now get python-usbtmc:
      git clone https://github.com/alexforencich/python-usbtmc.git
      cd python-usbtmc
      python setup.py build
      sudo python setup.py install
    8. For this simple demo, you’ll need to convert the USB vendor IDs to decimal:
      0x1ab1 = 6833
      0x0588 = 1416
    9. Now, start python as root (sudo python) then type:
      import usbtmc
      instr =  usbtmc.Instrument(6833, 1416)
      print(instr.ask(“*IDN?”))
    10. This should return something like:
      Rigol Technologies,DS1102E,DS1EB13490xxxx,00.02.06.00.01

    If you get the status line, congratulations! You now have a fully working usbtmc link. I haven’t had much time to play with this, but I know I can make really nice screenshots to an attached USB drive using the command: instr.write(“:HARDcopy”). Many more commands can be found in the DS1000D/E Programming Guide, available on Rigol‘s site.

    I had a couple of problems, though:

    1. The library seems to need root privileges, despite the udev rule thing. After creating the udev rule, you will need to reboot. This is the simplest way of getting it to work without being root.
    2. Reading from the ‘scope’s memory  chokes on non-UTF8 characters. If I do:
      rawdata = instr.ask(“:WAV:DATA? CHAN1”)[10:]
      I get a lengthy Python error which ends:
      …
      File “/usr/lib/python2.7/encodings/utf_8.py”, line 16, in decode
          return codecs.utf_8_decode(input, errors, True)
      UnicodeDecodeError: ‘utf8’ codec can’t decode byte 0x99 in position 10: invalid start byte
      I have no idea what that means, or how to fix it. Alex suggested using ask_raw instead of ask, and the data comes through with no complaints.

    I’ve still got to work my way through the Rigol’s data format, but other people have done that before:

    1. Controlling a Rigol oscilloscope using Linux and Python | C i b o M a h t o . c o m
    2. Ken Shirriff’s blog: Four Rigol oscilloscope hacks with Python

    I’ll post any updates here, along with the Raspberry Pi forum topic: USB Test & Measurement class (usbtmc) driver?

    Incidentally, if you’re working with WFM data dumps from the Rigol ‘scopes (and you should, because they make storing data to USB drives quick), mabl/pyRigolWFM is basically magic. Not merely can it describe and decode those binary files, it can do pretty graphics with no thought required:

    made by pyRigolWFMHat tip for the mention: MP3 Options & Oscilloscope Interfacing For Raspberry Pi @Raspberry_Pi #piday #raspberrypi « adafruit industries blog

    Update, 2013-12-20: I’ve successfully managed to run most of Ken’s examples with Alex’s code. The major modification you have to do is use ask_raw instead of ask. Example code shown below:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    
    """
    Download data from a Rigol DS1102E oscilloscope and graph with matplotlib
             using  Alex Forencich's python-usbtmc pure python driver
                    https://github.com/alexforencich/python-usbtmc
    scruss - 2013-12-20
    
    based on
    Download data from a Rigol DS1052E oscilloscope and graph with matplotlib.
    By Ken Shirriff, http://righto.com/rigol
    
    which in turn was
    Based on http://www.cibomahto.com/2010/04/controlling-a-rigol-oscilloscope-using-linux-and-python/
    by Cibo Mahto.
    """
    
    import usbtmc
    import time
    import numpy
    import matplotlib.pyplot as plot
    
    # initialise device
    instr =  usbtmc.Instrument(0x1ab1, 0x0588) # Rigol DS1102E
    
    # read data
    instr.write(":STOP")
    instr.write(":WAV:POIN:MODE RAW")
    # first ten bytes are header, so skip
    rawdata = instr.ask_raw(":WAV:DATA? CHAN1")[10:]
    data_size = len(rawdata)
    
    # get metadata
    sample_rate = float(instr.ask_raw(':ACQ:SAMP?'))
    timescale = float(instr.ask_raw(":TIM:SCAL?"))
    timeoffset = float(instr.ask_raw(":TIM:OFFS?"))
    voltscale = float(instr.ask_raw(':CHAN1:SCAL?'))
    voltoffset = float(instr.ask_raw(":CHAN1:OFFS?"))
    
    # show metadata
    print "Data size:      ", data_size
    print "Sample rate:    ", sample_rate
    print "Time scale:     ", timescale
    print "Time offset:    ", timeoffset
    print "Voltage offset: ", voltoffset
    print "Voltage scale:  ", voltscale
    
    # convert data from (inverted) bytes to an array of scaled floats
    # this magic from Matthew Mets
    data = numpy.frombuffer(rawdata, 'B')
    data = data * -1 + 255
    data = (data - 130.0 - voltoffset/voltscale*25) / 25 * voltscale
    
    # creat array of matching timestamps
    time = numpy.linspace(timeoffset - 6 * timescale, timeoffset + 6 * timescale,
                          num=len(data))
    
    # scale time series and label accordingly
    if (time[-1] < 1e-3):
        time = time * 1e6
        tUnit = "µS"
    elif (time[-1] < 1):
        time = time * 1e3
        tUnit = "mS"
    else:
        tUnit = "S"
    
    # Plot the data
    plot.plot(time, data)
    plot.title("Oscilloscope Channel 1")
    plot.ylabel("Voltage (V)")
    plot.xlabel("Time (" + tUnit + ")")
    plot.xlim(time[0], time[-1])
    plot.show()
    
  • Running X11-Basic (almost perfectly) on Raspberry Pi

    Update: Markus Hoffmann uploaded a new version of X11Basic-1.20.tar.gz to SourceForge that addresses most of these problems. I’ve edited the article to remove the obsolete bits.


    More than 20 years ago, I really liked GFA-Basic. It ran blindingly fast on the Atari ST, and when it didn’t crash on the Amiga, it ran blindingly fast there too. I even wrote a review of it for comp.sys.amiga.programmer, which you can read to this day in all its textual glory. One of the e-mail addresses in that article still works, too.

    I still sometimes think in BASIC, and there is much wringing of hands (not by me, really) that there isn’t a good interpreter for Raspbian on the Raspberry Pi. So when I found X11-Basic — a cross-platform GFA-Basic-like system — I had to take a look.

    While I have managed to get X11-Basic demos to run, I have to say it’s not running super well. I’ll show you how to install X11-Basic 1.20 and get it (mostly) running, but it’s a bit rough on the ARM. Incidentally, these instructions also work on Ubuntu 12.mumble LTS on x86.

    First, you need to install some (okay, a lot of) packages:

    sudo apt-get install libreadline-dev tcsh libncurses5-dev xutils-dev libc6-dev libsdl1.2-dev libtool

    Now download and extract the package:

    tar xvzf X11Basic-1.20.tar.gz
    cd X11Basic-1.20

    For X11Basic-1.20, you have to issue an extra command before the standard ‘./configure ; make ; make install‘ sequence:

    sudo mkdir -p /usr/local/share/man/man1
    ./configure
    make
    sudo make install

    This is enough to make a working xbasic interpreter. I made some screenshots of some of the graphics demos —

    Screen Shot 2013-03-08 at 16.34.51 Screen Shot 2013-03-08 at 14.59.37 Screen Shot 2013-03-08 at 14.57.21 Screen Shot 2013-03-08 at 14.54.08 Screen Shot 2013-03-08 at 14.49.48As you can see, there’s some screen corruption, but most demos just worked. Incidentally, the Mandelbrot one took almost 1¼ hours to run. Took me right back, that did (or it would have, if I hadn’t been outside bombing about in the slush on my bicycle while it churned away).

    In order to see just how fast the interpreter is, I ran the formerly fearsome Personal Computer World Benchmark #8 under X11-Basic. PCW#8 used to bring 8-bit home computers to their knees, typically taking more than a minute to run. Here’s the code, indented a bit and with a timing wrapper added:

    	LET start=TIMER
    	LET K=0
    L30:
    	LET K=K+1
    	LET A=K^2
    	LET B=LN(K)
    	LET C=SIN(K)
    	IF K<1000
    		GOTO L30
    	ENDIF
    	PRINT TIMER-start
    	QUIT
    

    (yeah, GFA-style BASIC isn’t too pretty …)

    It takes about ¼s to run. The old BBC B was supposed to take about 50s. By comparison, X11-Basic on a manky old dual-core Atom took 0.04s.

    The native compiler xbc seems to work. To make a standalone binary of the above code, you do:

    xbc -o PCWBenchmark PCWBenchmark.xbas

    The compiled binary runs roughly twice as fast as the interpreted code. Not blazing fast, but a useful increase.

    Unfortunately, the bytecode compiler xbbc doesn’t actually do anything on the Raspberry Pi yet. So here I leave it up to you to play with X11-Basic, and see what it can and can’t do.

  • A Murder of Crows on your Raspberry Pi with Boodler

    Boodler is rather fun. It generates ambient music based on user-defined or downloaded ‘soundscapes’. If you’ve got a modern (HTML5/Opus-capable) browser, you can hear a streaming demo here: http://repeater.xiph.org:8000/clock.opus. It’s using the FM3 Buddha Machine samples in this demo, but it can run lots more: a tree full of crows, a thunderstorm, dripping water, …

    It’s pretty easy to run on a Raspberry Pi running a recent version of Raspbian. The only technical glitch I had was that there’s something deeply confused about ALSA sound handling on the Raspberry Pi. I’m sure it’ll get fixed soon, but for now, you have to use PulseAudio. (If you want to read about my ALSA woes, go here.)

    The installation prerequisites are simple:

    sudo apt-get install pulseaudio pulseaudio-utils libpulse-dev python-dev

    Now download and configure Boodler:

    wget http://boodler.org/dl/Boodler-2.0.4.tar.gz
    tar xvzf Boodler-2.0.4.tar.gz
    cd Boodler-2.0.4
    python setup.py build

    It takes a while to do this, but make sure it does something useful when it’s building the various sound drivers. You don’t want it to say:

    skipping 'boodle.cboodle_pulse' extension

    If it says that, you haven’t installed Pulseaudio. Go back and check your apt-get line.

    Once it’s built, now install it:

    sudo python setup.py install

    Now test it:

    boodler --hardware --output pulse --testsound

    Not merely should you get some pleasant tones from your Raspberry Pi’s audio, but you sound get some informative and non-threatening terminal output. Mine looks like:

    Boodler: PulseAudio sound driver.
     PulseAudio library: 2.0.0.
     Sample rate is 44100 fps.
     Samples are 16-bit little-endian.
     Buffer size is 32768.
     21:37:46 (root) Running "Boodler test sound"

    If that works, let’s get those crows a-cawin’. Download the soundscapes you need:

    boodle-mgr install http://boodler.org/lib/org.boodler.old.crow.1.0.boop
    boodle-mgr install http://boodler.org/lib/com.eblong.zarf.crows.1.0.boop

    and run it:

    boodler --output pulse com.eblong.zarf.crows/ParliamentOfCrows

    Crows everywhere!

    I really like the Buddha Machine samples. It’s quite big (> 80 MB), so this next set will take a while to download:

    boodle-mgr install  http://boodler.org/lib/com.azulebanana.buddhamachine.1.5.1.boop
    boodle-mgr install http://boodler.org/lib/com.azulebanana.buddhaagent.1.5.1.boop

    It’s worth the wait:

    boodler --output pulse com.azulebanana.buddhaagent/ChangingLoops

    Boodler has tons of options, prebuilt packages, and instructions to build your own: Boodler Documentation.

    One thing I’ve tried to get working, but failed, is streaming from Boodler via icecast. Sure, I can install and run it, it’s just that the results are, um, undesirable. If you want to have a play, here’s how to install icecast:

    sudo apt-get install icecast2 ices2 libshout3-dev

    Icecast will configure itself, and ask for a couple of passwords. You’ll have to rebuild and reinstall Boodler for it to catch the new configuration. You can then try streaming:

    boodler --output shout --define shout-password=mypassword --define shout-mount='/boodler-buddha.ogg' com.azulebanana.buddhaagent/ChangingLoops

    If you open a web browser at this address http://raspberrypi:8000/ you should see a config page listing your boodler-buddha.ogg stream. Click on the M3U link next to it, and your streaming music player should start making a joyful noise …

    … except in my case, something went very wrong, and it started to produce industrial ultra-glitch nightmare noise: boodler-streaming_test-fail. I’m sure it’s fixable with some tweaking, but I’m not there yet.

  • The Quite Rubbish Clock

    Hey! This article is really old and probably doesn’t work any more: things have changed a lot in Raspberry Pi world since 2013

    Update 3: code for the demo video is here.

    Update 2: In which I actually post working code.

    Update: Eep! This post was featured on the Raspberry Pi blog today. Thanks, Liz!

    And now for something completely different:

    … a clock that isn’t human readable. You’ll need a QR code reader to be able to tell the time.

    Nokia screen on Raspberry Pi

    This, however, is not the prime purpose of the exercise. I was looking for an excuse to try some direct hardware projects with the GPIO, and I remembered I had a couple of Nokia-style surplus LCDs lying about that could be pressed into service. These LCDs aren’t great: 84×48 pixels, 3V3 logic, driven by SPI via an 8-pin header which includes PWM-controllable LED backlighting. They are cheap, and available almost everywhere: DealExtreme ($5.36), SparkFun ($9.95), Adafruit ($10, but includes a level shifter, which you really need if you’re using a 5V logic Arduino), Solarbotics ($10) and Creatron (about $12; but you can walk right in and buy one). Despite being quite difficult to use, helpful people have written drivers to make these behave like tiny dot-addressable screens.

    I’d been following the discussion on the Raspberry Pi forum about driving the Nokia LCD from a Raspberry Pi. Only when user bgreat posted some compact code that was supposed to run really fast did I dig out the LCD board and jumper wires. Building on bgreat’s nokiaSPI.py class and a few other bits of code, here’s what I built to make this singularly pointless clock:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    # qrclock - The Quite Rubbish Clock for Raspberry Pi - scruss, 2013-01-19
    
    import time
    # need to use git://github.com/mozillazg/python-qrcode.git
    import qrcode
    from PIL import Image
    import ImageOps
    # uses bgreat's SPI code; see
    # raspberrypi.org/phpBB3/viewtopic.php?f=32&amp;amp;amp;amp;t=9814&amp;amp;amp;amp;p=262274&amp;amp;amp;amp;hilit=nokia#p261925
    import nokiaSPI
    
    noki = nokiaSPI.NokiaSPI()              # create display device
    qr = qrcode.QRCode(version=1,           # V.1 QR Code: 21x21 px
                       error_correction=qrcode.constants.ERROR_CORRECT_M,
                       box_size=2, border=1)
    bg = Image.new('1', (84, 48))           # blank (black) image background
    
    while 1:
        qr.clear()
        newbg = bg.copy()                   # copy blank background
        s = time.strftime('%Y-%m-%d %H:%M:%S')
        qr.add_data(s)                      # make QR Code of YYYY-MM-DD HH:MM:SS
        qr.make()
        qrim = qr.make_image()              # convert qrcode object to PIL image
        qrim = qrim.convert('L')            # make greyscale
        qrim = ImageOps.invert(qrim)        # invert colours: B-&amp;amp;amp;gt;W and W-&amp;amp;amp;gt;B
        qrim = qrim.convert('1')            # convert back to 1-bit
        newbg.paste(qrim, (18, 0))          # paste QR Code into blank background
        noki.show_image(newbg)              # display code on LCD
        time.sleep(0.4)                     # pause before next display
    

    (Convenient archive of all the source: qrclock2.zip, really including bgreat’s nokiaSPI class this time …)

    To get all this working on your Raspberry Pi, there’s a fair amount of configuration. The best references are bgreat’s own comments in the thread, but I’ve tried to include everything here.

    Enabling the SPI kernel module

    As root, edit the kernel module blacklist file:

    sudo vi /etc/modprobe.d/raspi-blacklist.conf

    Comment out the spi-bcm2708 line so it looks like this:

    #blacklist spi-bcm2708

    Save the file so that the module will load on future reboots. To enable the module now, enter:

    sudo modprobe spi-bcm2708

    Now, if you run the lsmod command, you should see something like:

    Module                  Size  Used by
    spi_bcm2708             4421  0

    Installing the WiringPi, SPI and other required packages

    WiringPi by Gordon is one of the neater Raspberry Pi-specific modules, as it allows relatively easy access to the Raspberry Pi’s GPIO pins. For Raspbian, there are a few other imaging libraries and package management tools you’ll need to install here:

    sudo apt-get install python-imaging python-imaging-tk python-pip python-dev git
    sudo pip install spidev
    sudo pip install wiringpi

    Installing the Python QR code library

    Finding a library that provided all the right functions was the hardest part here. I ended up using mozillazg‘s fork of lincolnloop‘s python-qrcode module. mozillazg’s fork lets you use most of the lovely PIL methods, while the original hides most of them. Since I had to do some image compositing and colour remapping to make the image appear correct on the Nokia screen, the new fork was very helpful.

    To install it:

    git clone git://github.com/mozillazg/python-qrcode.git
    cd python-qrcode/
    sudo python ./setup.py install

    The tiny 84×48 resolution of the Nokia screen doesn’t give you many options for sizing QR codes. For the time display of the clock, a 21×21 module Version 1 code with two pixels per module and one module margin just fits into 48 pixels. Using a medium level of error correction, you can fit the 19-character message (such as “2013-01-19 18:56:59”) into this tiny screen with a very good chance of it being read by any QR code reader.

    (In the video, there’s a much larger QR code that’s a link to this blog post. That’s a Version 7 code [45×45 modules] at one pixel per module and no margin. This doesn’t meet Denso Wave’s readability guidelines, but the Nokia screen has large blank margins which seem to help. It won’t read on every phone, but you’re here at this link now, so you don’t need it …)

    Wiring it all up

    (Do I really need to say that you’ll be messing around with the inner delicate bits of your Raspberry Pi here, and if you do something wrong, you could end up with a dead Raspberry Pi? No? Okay. Just make sure you take some static precautions and you really should have the thing shut down and powered off.)

    You’ll need 8 female-female right-angled ones). Note that the thick border of the LCD is the top of the screen. These boards are made who-knows-where by who-knows-whom, and there’s a huge variety of labels and layouts on the pins. My one appears to be yet another variant, and is labelled:

    1. VCC
    2. GND
    3. SCE
    4. RST
    5. D/C
    6. DNK(MOSI)
    7. SCLK
    8. LED
    screen labels

    This is how I wired it (from comments in bgreat’s code and the GPIO reference):

     LCD Pin       Function      Pi GPIO Pin #   Pi Pin Name
    ============= ============= =============== =============
     1 VCC         Vcc            1              3.3 V
     2 GND         Ground        25              GND
     3 SCE         Chip Enable   24              GPIO08 SPI0_CE0_N
     4 RST         Reset         11              GPIO17
     5 D/C         Data/Command  15              GPIO22
     6 DNK(MOSI)   Data In       19              GPIO10 SPI0_MOSI
     7 SCLK        Serial Clock  23              GPIO11 SPI0_SCLK
     8 LED         Backlight     12              GPIO18 PWM0
    GPIO wiring
    back of screen

    Wire it up, and fire up the program:

    sudo ./qrclock.py

    Yes, code that accesses GPIO needs to be run as root. Pesky, but helps you avoid running code that accidentally scrams the nuclear power station you’re controlling from your Raspberry Pi …

  • Raspberry Pi as a USB audio capture device

    The Raspberry Pi’s hardware and software support has come a long way in the few months it has been in the wild. I first tried this application in the summer, and the results were dismal. Now, thanks much improved USB driver support under Raspbian, I’m pleased to say it works flawlessly.

    Earlier this year, I bought a turntable (ack!) for transferring vinyl to mp3. I have a TC-772 USB phono preamp, which spits out a 48 kHz stereo audio stream. If you plug the USB output of the preamp into a Rapberry Pi (running Raspbian Wheezy with all the updates), it’s instantly recognized as an audio device:

    $ lsusb
    Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
    Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp. 
    Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. 
    Bus 001 Device 004: ID 08bb:2902 Texas Instruments Japan PCM2902 Audio Codec

    If you install the ALSA recording utilities (sudo apt-get install alsa-utils pulseaudio – this should pull in a whole bunch of necessary packages), you can record directly from this device with the following command:

    arecord -D 'pulse' -V stereo -c 2 -f dat -d 900 out.wav

    which records from the ‘pulse’ audio device, displaying a stereo text VU meter (handy for setting levels), writing to a two channel 16-bit 48 kHz file called ‘out.wav’ for a maximum of 900 seconds (15 minutes). arecord has a baffling number of recording source options; arecord -L will show them. ‘pulse’ was the first one I tried.

    So how does it sound? Here’s a 30 second excerpt from the only single I owned for years, The Music Tapes‘ “The Television Tells Us/Freeing Song by Reindeer”: Freeing Song by Reindeer – excerpt [mp3]. I’ve saved an even smaller snippet as lossless FLAC so you can see that the waveform’s pretty clean: FreeingSongbyReindeer-tiny_excerpt [flac].

    Sounds pretty good. Not quite as good as having Julian play it in your house, I’ll allow, but not bad for a first try with a $35 computer.