…code, cg, electronics, projects…

On the Raspberry Pi, just like on the Arduino, the first thing you learn how to do is make an LED blink.  The Raspberry Pi Users Guide walks you through this process, but this was one of the few areas (so far) with the Pi that I ran into trouble, namely over proper access to the GPIO pins, the Pi Cobbler‘s ribbon-header orientation, and how to physically code on the Pi itself.

Look at that LED blink!

GPIO Pin issues

There appears to be two different ways to access the pins via the RPi.GPIO Python library: Via the ‘board pin numbers’ (1->32), or via the ‘GPIO numbers’, which many sites (like this one) refer to.  In addition, hardware expansions like Adafruit’s Pi Cobbler (which I’m using) base their silk-screens on the ‘GPIO numbers’.  Long story short, you simply need to tell your code ahead of time which method you’re using:
To use the physical board numbers:

import RPi.GPIO as GPIO
# Set to use physical board pin nums, rather than GPIO nums:
GPIO.setmode(GPIO.BOARD)

To use the ‘GPIO’ numbers:

import RPi.GPIO as GPIO
# Set to use GPIO nums, rather than physical board nums:
GPIO.setmode(GPIO.BCM)

Pi Cobbler Issues

I got the Pi Cobbler via the Maker Shed’s “Raspberry Pi Starter Kit“.  The kit comes with a lot of good stuff to get your started (including the LED that’s blinking next to me).  The Cobbler cable has a header on each end (one plugs into the Pi, one into the Cobbler itself), and each header has a notch on the side to help you understand how to orient it.  At first glance, it looks like the headers are interchangeable… meaning, you could plug either one into the Pi, or the Cobbler.  Very long story short, that’s not true:  To get the side of the cable with the stripe to line up properly with the GPIO pins on the Pi… only one side will work.  I was convinced I had a defective cable that required me to plug it in backwards.  But two days later I realized if I simply flipped the whole cable around everything ‘just worked’.  The Cobbler documentation stresses you insert the cable with the side with the stripe to the left side of the Pi,… but since I thought mine was screwed up…. chaos ensued.  Funny that I didn’t figure this out until I finished this blog post.  The above pic in fact shows the ‘flipped’ insertion in the Pi before I corrected it.

Coding Issues

The final issue I hit was how to actually code Python on the Pi:  I use Wing IDE Professional, and have grown very used to it… but they have no Linux ARM distribution (that I’m aware of).  Going back to IDLE is painful… and I’ve never been a VIM user.  Based on a previous post I can SSH and VNC into the Pi from my Mac, allowing me to code on the mac and copy\paste over to the Pi for execution… but this is still pretty clunky.  After researching for a while I realized, why don’t I try Adafruit’s Raspberry Pi WebIDE?  Installation was easy based on their tutorial, and I was up and running in no time.

Here is my code to make the LED blink, running in the WebIDE\Pi as I type…

#!/user/bin/env python
"""
gpiooutput.py
Modified from pg 195 of "Raspberry Pi Users Guide"

Make a LED flash on\off.
Hardware Setup:
* LED+ lead hooked to GPIO 17 (board pin 11)
* LED- lead connected to resistor.
* Resistor connected to ground (board pin 6)
"""
import time
import RPi.GPIO as GPIO

# This is the GPIO number.  The actual board pin is number 11.
PINOUT = 17

def main():
    GPIO.setmode(GPIO.BCM) # Set to use GPIO nums, rather than physical board nums
    GPIO.setup(PINOUT, GPIO.OUT)
    print "Blink begins!  Press ctrl+c to exit"
    try:
        i = 1
        while True:
            GPIO.output(PINOUT, True)
            print "Blink %s ON!!"%i
            time.sleep(2)
            GPIO.output(PINOUT, False)
            print "Blink %s OFF!!"%i
            time.sleep(2)
            i += 1
    except KeyboardInterrupt:
        GPIO.output(PINOUT, False)
        print "\nBlink DONE!"
        return

if __name__ == "__main__":
    main()

The WebIDE doesn’t have any fancy features yet (that I’m aware of) like debugging & code-completion, but it is alpha software, so hopefully it will become more robust as time goes on.  On the plus side, it will auto-connect to the Pi over the network (no need for SSH), gives you a built-in terminal for the Pi, and stores all the code  in the cloud via Bitbucket (if you’re into that sort of thing).

And thus, the fruits of my labor:

Raspberry Pi + Pi Cobbler + WebIDE = blinky LED

I recently ran across Kivy, which in a nutshell lets you…. “develop (multi-touch) applications on Windows, Mac, Linux and Android using Python”.

I have yet to use it, but to me, this sounds awesome:  While I love the Processing API and how easy it is to get a sketch onto an Android device, I love writing code in Python even more.  The though of being able to create graphical Python apps that run on both a laptop \ Android device is pretty enticing.

• Kivy philosophy
• Kivy quickstart
• Kivy architecture
• Kivy API

I had to give my brain a break from all the Processing \ Android stuff and get back into Python.  I’ve done a few small apps with PyGame and it’s been an enjoyable process.  But PyGame is SDL based, and because of that never felt as ‘Pythonic’ to me as I’d like.  Plus, and this is a minor gripe, but it really rubs me the wrong way:  There seems to be no way to easily anti-alias PyGame programs.  Without that, to me, they end up looking just a bit too indy for my taste.

I thought I’d go about learning a new Python game development framework, and the one I settled on is pyglet.

Reasons I like pyglet?

• Authored in Python with no external dependencies (other than OpenGL).  It ‘feels moar Python’.
• It’s mainly a big fancy wrapper around OpenGL (which I want to learn).
• I like it’s event system.
• You can anti-alias it!
• It has an even higher-level wrapper API, cocos2d (which I’ll get into later), which adds even more game-framework related abilities.

Things that bum me out about it:

• Unless I’m missing it, has no built-in primitives library.  If you want to draw a line, or a filled circle, you gotta roll your own.  Yes, it has a ‘pyglet.graphics’ library (here, here), but it’s not exactly plug-n-play.
• The API, while great in some areas, doesn’t have all the convenience functions I’m used to with something like Processing, or even PyGame.  But this means I get to learn how to do it, which isn’t a bad thing.
• There is no sprite\rect-based collision systems (unlike PyGame).

So, my pyglet beginnings are below.  I tried to come up with a basic window displaying primitives, anti-aliased.  I found a great primitives library that someone already authored so that filled in my primitives hole.  And I wrote my own ‘utils’ module as I learned stuff, slowly filling in the missing pieces I think I’ll need in the future.

Links:

• Pyglet Programming Guide
• Pyglet API
• Google Code
• ‘2d Drawing Primitives Module‘ (used in the below code)

Here is my ‘utilities’ module:

# pyglet.utils.py
# www.akeric.com - 2011-03-17
# utils to make pyglet easier to work with, help my learning of it.

import pyglet
from pyglet.gl import *

def screenshot(name='screenshot'):
    """
    Take a screenshot

    Parameters:
    name : string : Default 'screenshot'.  Name of the saved image.  Will
        always save as .png
    """
    # Get the 'the back-left color buffer'
    pyglet.image.get_buffer_manager().get_color_buffer().save('%s.png'%name)

def getPixelValue(x, y):
    """
    Return the RGBA 0-255 color value of the pixel at the x,y position.
    """
    # BufferManager, ColorBufferImage
    color_buffer = pyglet.image.get_buffer_manager().get_color_buffer()
    # AbstractImage, ImageData, sequece of bytes
    pix = color_buffer.get_region(x,y,1,1).get_image_data().get_data("RGBA", 4)
    return pix[0], pix[1], pix[2], pix[3]

def drawPoint(x, y, color):
    """
    Based on the (r,g,b) color passed in, draw a point at the given x,y coord.
    """
    pyglet.graphics.draw(1, GL_POINTS,
                         ('v2i', (x, y)),
                         ('c3B', (color[0], color[1], color[2]) ) )

def getSmoothConfig():
    """
    Sets up a configuration that allows of smoothing\antialiasing.
    The return of this is passed to the config parameter of the created window.
    """
    try:
        # Try and create a window config with multisampling (antialiasing)
        config = Config(sample_buffers=1, samples=4,
                        depth_size=16, double_buffer=True)
    except pyglet.window.NoSuchConfigException:
        print "Smooth contex could not be aquiried."
        config = None
    return config

def printEvents(window):
    """
    Debug tool that will print the events to the console.

    window is an instance of a Window object receiving the events.
    """
    window.push_handlers(pyglet.window.event.WindowEventLogger())

def playMusic(music):
    """
    Simple wrapper to play a music (mp3) file.

    music : music file relative to application.
    """
    music = pyglet.resource.media(music)
    music.play()

def setBackgroundColor(color):
    """
    Color is a list of four values, [r,g,b,a], each from 0 -> 1
    """
    pyglet.gl.glClearColor(*color)

And here is my ‘basic window’ which draws primitives. It is a dupe of the primitives drawing example from the primitives.py module, but modified into a new window:

# primitivesTest01.py
# www.akeric.com - 2011-03-17

import sys
import random
import pyglet
from pyglet.gl import *
import primitives # module discussed above
import utils # module from above

FPS = 60
smoothConfig = utils.getSmoothConfig()

class PrimWin(pyglet.window.Window):

    def __init__(self):
        super(PrimWin, self).__init__(fullscreen=False, caption='Primitives Test!', config=smoothConfig)
        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
        self.p = primitives.Pixel(10,10)
        self.c = primitives.Circle(200,100,width=100,color=(0.,.9,0.,1.))
        self.a = primitives.Arc(150,150,radius=100,color=(1.,0.,0.,1.),sweep=90,style=GLU_FILL)
        self.P = primitives.Polygon([(0, 0), (50, 200), (80, 200),(60,100),(100,5)],color=(.3,0.2,0.5,.7))
        self.l = primitives.Line((10,299),(100,25),stroke=8,color=(0,0.,1.,1.))
        # Setup debug framerate display:
        self.fps_display = pyglet.clock.ClockDisplay()
        # Schedule the update of this window, so it will advance in time at the
        # defined framerate.  If we don't, the window will only update on events
        # like mouse motion.
        pyglet.clock.schedule_interval(self.update, 1.0/FPS)

    def on_draw(self):
        # Window event
        self.clear()
        self.c.render()
        self.p.render()
        self.a.render()
        self.P.render()
        self.l.render()
        self.fps_display.draw()

    def on_mouse_motion(self, x, y, dx, dy):
        # Window event
        self.c.x = x
        self.c.y = y

    def update(self, dt):
        # Scheduled event
        self.a.rotation+=1
        self.c.color = [random.random() for i in xrange(3)]+[1]

if __name__ == '__main__':
    PrimWin()
    sys.exit(pyglet.app.run())

And the result of this awesome code is the screenshot at the top of the screen.

Next steps will be to dig more into cocos2d and see if I can come up with something more interesting than the above screenshot to develop.