PyMata

PyMata is a high performance, multi-threaded, non-blocking Python client for the Firmata Protocol that supports the complete StandardFirmata protocol.

A new version for Python 3.5, pymata_aio, can be found here.

The API can be viewed on the wiki.

Major features

• Implements the entire Firmata 2.4.1 protocol.
• Python 2.7+ and Python 3.4+ compatibility through a shared code set. (If you are running Python 3.4 on Linux, please see note below).
• Easy to use and intuitive API. You can view the PyMata API Documentation here or view in the Documentation/html directory.
• Custom support for stepper motors, Sonar Ping Devices (HC-SR04), Piezo devices and Rotary Encoders.
  • Requires the use of FirmataPlus for PyMata - installation instructions may be found here.
• Wiring diagrams are provided for all examples in the examples directory.
• Digial and Analog Transient Signal Monitoring Via Data Latches:
  • They provide "one-shot" notification when either a digital or analog pin meets a user defined threshold.
  • Analog latches compare each data change to a user specified value.
    • Comparison operators are <, >, <= and >=
  • Digital latches compare a data change to either a high or low, specified by the user.
  • Latches can easily be re-armed to detect the next transient data change.
  • Latches can be either manually read or a callback can be associated with a latch for immediate notification.
• Optional callbacks provide asynchronous notification of data updates.

Callbacks

Check out the example code on the wiki.

• Digital input pins.
• Analog input pins.
• Encoder changes.
• I2C read data changes.
• SONAR (HC-SR04) distance changes.
• Analog latch condition achieved.
• Digital latch condition achieved.
• Callbacks return data reports in a single list format.
• Polling methods and callbacks are available simultaneously and can be used in a mixed polled/callback environment.
• Callbacks return data in a single list.

The callback data return values

Control-C Signal Handler

Below is a sample Control-C signal handler that can be added to a PyMata Application. It suppresses exceptions being reported as a result of the user entering a Control-C to abort the application.

import sys
import signal
# followed by another imports your application requires

# create a PyMata instance
# set the COM port string specifically for your platform
board = PyMata("/dev/ttyACM0")

# signal handler function called when Control-C occurs
def signal_handler(signal, frame):
    print('You pressed Ctrl+C!!!!')
    if board != None:
        board.reset()
    sys.exit(0)

# listen for SIGINT
signal.signal(signal.SIGINT, signal_handler)

# Your Application Continues Below This Point

Misc

• Want to extend PyMata? See Our Instructables Article explaining how stepper motor support was added. Use it as a guide to customize PyMata for your own needs.
• Check Out Mr. Y's Blog Here for all the latest news!

Special Note For Linux Users Wishing to Use Python 3.5

pymata_aio is now available and for Python 3.5.

Check out the pymata_aio wiki!

This project was developed with Pycharm