Tag: tkinter

  • python + Arduino + Tk: Toggling an LED

    Whoa! This is so old I don’t even know where to start!

    • It’s using Python 2, so if it works at all it probably won’t for much longer, and Tkinter is something completely different under Python 3
      (grrreat planning there, Python guys …)
    • pyfirmata is likely ancient history too.

    Phil sent me a note last week asking how to turn an LED on or off using Python talking through Firmata to an Arduino. This was harder than it looked.

    It turns out the hard part is getting the value from the Tkinter Checkbutton itself. It seems that some widgets don’t return values directly, so you must read the widget’s value with a get() method. This appears to work:

    #!/usr/bin/python
    # turn an LED on/off with a Tk Checkbutton - scruss 2012/11/13
    # Connection:
    # - small LED connected from D3, through a resistor, to GND
    
    import pyfirmata
    from Tkinter import *
    
    # Create a new board, specifying serial port
    # board = pyfirmata.Arduino('/dev/ttyACM0') # Raspberry Pi
    board = pyfirmata.Arduino('/dev/tty.usbmodem411') # Mac
    
    root = Tk()
    var = BooleanVar()
    
    # set up pins
    pin3 = board.get_pin('d:3:o') # D3 On/Off Output (LED)
    
    def set_led():  # set LED on/off
        ledval = var.get()
        print "Toggled", ledval
        pin3.write(ledval)
    
    # now set up GUI
    b = Checkbutton(root, text = "LED", command = set_led,
                    variable = var)
    b.pack(anchor = CENTER)
    
    root.mainloop()
    

    This is explained quite well here: Tkinter Checkbutton doesn’t change my variable – Stack Overflow. I also learnt a couple of things about my previous programs:

    • You don’t really need to set up an Iterator unless you’re reading analogue inputs
    • My “clever” cleanup-on-exit code actually made the script hang on Mac OS.
  • Servo Control from pyfirmata + arduino

    Hey! This article is really old! So old, in fact, that I clearly thought that saying (ahem) “w00t w00t” was a good idea. Information here may be misleading and possibly wrong. You probably want to be using a newer client library and you definitely want to use an Arduino IDE ≥ 1.6 and not the ancient one that comes with Raspbian.

    pyFirmata‘s documentation is, to be charitable, sparse. After writing Raspberry Pi, Python & Arduino *and* a GUI (which should be making an appearance in The MagPi soon, w00t w00t yeet!), I looked at pyFirmata again to see what it could do. That pretty much meant digging through the source.

    Firmata can drive hobby servos, and if you’re not driving too many, you can run them straight from the Arduino with no additional power. I used a standard cheapo-but-decent Futaba S3003, which gives you about 180° of motion. The particular one I tried started to make little growly noises past 175°, so in the example below, that’s hardcoded as the limit.

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    # move a servo from a Tk slider - scruss 2012-10-28
    
    import pyfirmata
    from Tkinter import *
    
    # don't forget to change the serial port to suit
    board = pyfirmata.Arduino('/dev/tty.usbmodem26271')
    
    # start an iterator thread so
    # serial buffer doesn't overflow
    iter8 = pyfirmata.util.Iterator(board)
    iter8.start()
    
    # set up pin D9 as Servo Output
    pin9 = board.get_pin('d:9:s')
    
    def move_servo(a):
        pin9.write(a)
    
    # set up GUI
    root = Tk()
    
    # draw a nice big slider for servo position
    scale = Scale(root,
        command = move_servo,
        to = 175,
        orient = HORIZONTAL,
        length = 400,
        label = 'Angle')
    scale.pack(anchor = CENTER)
    
    # run Tk event loop
    root.mainloop()
    

    The code above makes a slider (oh, okay, a Tkinter Scale widget) that moves the servo connected to Arduino pin D9 through its whole range. To set the servo position, you just need to write the angle value to the pin.

    I haven’t tried this with the Raspberry Pi yet. It wouldn’t surprise me if it needed external power to drive the Arduino and the servo. This might be a good excuse to use my Omega-328U board — it’s Arduino code compatible, runs from an external power supply, and has Signal-Voltage-Ground (SVG) connectors that the servo cable would just plug straight into.

  • Raspberry Pi, Python & Arduino *and* a GUI …

    Whee! This entry was the basis of the cover article of The MagPi issue 7. Read it on Issuu, or download the PDF.

    Okay, so maybe I can stop answering the StackExchange question “How to attach an Arduino?” now. While I got the Arduino working with pyFirmata on the Raspberry Pi before, it wasn’t that pretty. With a TkInter front end, it actually looks like some effort was involved. You can happily brighten and dim the LED attached to the Arduino all you want, while the temperature quietly updates on the screen independent of your LED frobbing.

    I’d never used TkInter before. For tiny simple things like this, it’s not that hard. Every widget needs a callback; either a subroutine it calls every time it is activated, or a variable that the widget’s value is tied to. In this case, the Scale widget merely calls a function set_brightness() that sets a PWM value on the Arduino.

    Updating the temperature was more difficult, though. After TkInter has set up its GUI, it runs in a loop, waiting for user events to trigger callback events. It doesn’t really allow you to run another loop alongside its main event loop. What you have to do then is set up a routine which is called periodically using TkInter’s after() function, which calls a subroutine after a set amount of time. If this subroutine ends with another call to after() to call itself again, it will maintain its own event loop separate from TkInter’s GUI loop. This is what I do in the get_temp() subroutine, which schedules itself after a ½ second.

    
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    
    # graphical test of pyfirmata and Arduino; read from an LM35 on A0,
    #                                          brighten an LED on D3 using PWM
    # Connections:
    # - small LED connected from D3, through a 1kΩ resistor to GND;
    # - LM35: +Vs -> +5V, Vout -> A0, and GND -> GND.
    # scruss, 2012-08-16 - tested on Raspberry Pi and Arduino Uno
    
    import pyfirmata
    import sys                              # just for script name and window
    from Tkinter import *
    
    # Create a new board, specifying serial port
    board = pyfirmata.Arduino('/dev/ttyACM0')
    
    # start an iterator thread so that serial buffer doesn't overflow
    it = pyfirmata.util.Iterator(board)
    it.start()
    
    # set up pins
    pin0=board.get_pin('a:0:i')             # A0 Input      (LM35)
    pin3=board.get_pin('d:3:p')             # D3 PWM Output (LED)
    
    # IMPORTANT! discard first reads until A0 gets something valid
    while pin0.read() is None:
        pass
    
    def get_temp():                         # LM35 reading in °C to label
        selection = "Temperature: %6.1f °C" % (pin0.read() * 5 * 100)
        label.config(text = selection)
        root.after(500, get_temp)           # reschedule after half second
    
    def set_brightness(x):  # set LED; range 0 .. 100 called by Scale widget
        y=float(x)
        pin3.write(y / 100.0)               # pyfirmata expects 0 .. 1.0
    
    def cleanup():                          # on exit
        print("Shutting down ...")
        pin3.write(0)                       # turn LED back off
        board.exit()
    
    # now set up GUI
    root = Tk()
    root.wm_title(sys.argv[0])              # set window title to program name
    root.wm_protocol("WM_DELETE_WINDOW", cleanup) # cleanup called on exit
    scale = Scale( root, command=set_brightness, orient=HORIZONTAL, length=400,
                   label='Brightness')      # a nice big slider for LED brightness
    scale.pack(anchor=CENTER)
    
    label = Label(root)
    label.pack(anchor='nw')                 # place label up against scale widget
    
    root.after(500, get_temp)               # start temperature read loop
    root.mainloop()
    
    

    The program takes a few seconds to start on the Raspberry Pi, mainly because initializing pyFirmata over a serial line and waiting for the duff values to subside takes time. I tried to exit the program gracefully in the cleanup() subroutine, but sometimes one of the loops (I suspect pyFirmata’s iterator) doesn’t want to quit, so it takes a few clicks to exit.

    The program also seems to chew up a fair bit of CPU on the Raspberry Pi; I had it at around 40% usage just sitting idle. I guess those serial ports don’t read themselves, and you have to remember that this computer is basically no more powerful than a phone.

    So there you are; a simple demo of how to control an output and read an input on an Arduino, from a Raspberry Pi, written in Python (the Raspberry Pi’s official language) with a simple GUI. Considering I’d never written a line of Python before the beginning of this month, I think I’m doing not too badly.