pyFirmata2 2.4.2
pip install pyFirmata2 Copy PIP instructions
Released: Nov 19, 2021
Use your Arduino as a data acquisition card under Python
Navigation
Project links
Statistics
View statistics for this project via Libraries.io, or by using our public dataset on Google BigQuery
License: MIT License
Author: Bernd Porr
Maintainers
Classifiers
- Intended Audience
- Developers
- License
- OSI Approved :: MIT License
- Operating System
- OS Independent
- Programming Language
- Python :: 3
- Topic
- Utilities
Project description
PyFirmata2 turns your Arduino into a data acquisition card controlled by Python.
Up to 1kHz precise sampling at the analogue ports for digital filtering.
Just upload the default firmata sketch into your Arduino and you are all set.
pyFirmata2 is an updated version of pyFirmata which replaces loops with callbacks. Instead of unreliable “sleep” commands in a loop the Python application registers callbacks which are then called every time after new data has arrived. This means for the analogue channels the callbacks are called at the specified sampling rate while the digital ports call the callback functions after a state change at the port (from 0 to 1 or 1 to 0).
This API has been used in my Digital Signal Processing (DSP) class to practise realtime filtering of analogue sensor data. Examples can be viewed on the YouTube channel of the class: https://www.youtube.com/user/DSPcourse
Installation
Upload firmata
Start the IDE and upload the standard firmata sketch into your Arduino with:
Install pyfirmata2
The preferred way to install is with pip / pip3 . Under Linux:
and under Windows/Mac type:
You can also install from source with:
Under Linux type:
Under Windows / Mac:
Usage
Please go to https://github.com/berndporr/pyFirmata2 for the documentation and in particular the example code.
Example code
It’s strongly recommended to check out the example code at https://github.com/berndporr/pyFirmata2/tree/master/examples to see how the callbacks work.
Credits
The original pyFirmata was written by Tino de Bruijn. The realtime sampling / callback has been added by Bernd Porr.
Firmata Tutorial: How to Use Firmata on Arduino Compatible Boards¶
What is Firmata¶
Firmata is an intermediate protocol that connects an embedded system to a host computer, and the protocol channel uses a serial port by default. The Arduino platform is the standard reference implementation for Firmata. The Arduino IDE comes with the support for Firmata.
This could work perfectly with Odyssey-X86 with its onboard Arduino Core meaning that you can control the Arduino Core simply using Firmata protocol with different programming languages too! In this tutorial, it’s based on Windows OS.
Burning the Firmata Firmware via Arduino IDE¶
The Arduino IDE >= 1.6.X version comes with the Firmata firmware so we can use Arduino IDE to burn the firmata firmware into Arduino core.
You can download Arduino IDE from here.
- Open Arduino IDE and navigate to Examples -> Firmata -> StandardFirmata :
- The StandardFirmata.ino will appear. Select the correct board and port and click Upload:
If you haven’t installed the board library for Odyssey please follow this to install the board.
- Once uploaded, it should look something like this:
Now, the Arduino Firmata firmware is flashed into the Arduino core on Odyssey-X86!
Testing the Firmata Firmware¶
To test the Firmata firmware, you can navigate to the Microsoft Store, search and download the Windows Remote Arduino Experience. Once downloaded, you can connect to the Arduino Core by selecting the USB connection, board and baudrate:
Once connected, you can connect LED to the corresponded pins to test the firmware:
Using Python to Interpret Firmata¶
There are libraries that implement the Firmata protocol in order to communicate (from a computer, smartphone or tablet for example) with Firmata firmware running on a microcontroller platform.
pyFirmata is a Python interface for the Firmata protocol and runs on python3.
pyFirmata Installation¶
Python3 is required for this.
Install with pip:
To Blink an LED connected on D13¶
Note: Change the COM4 to your Arduino USB COM.
For a simple LED module, you can use the Grove — LED module to test!
To read Analog Signals on A0¶
PWM Outputs on D6¶
Output a PWM signal to a LED connected at D6.
Now you can use python script (or even other languages) to control your Arduino core on Odyssey-X86, which makes it very useful in some situations where real time requirements are less important (i.e Using python to build a Web Sever, and using Arduino to control a relay).
Note: For more API reference, please visit pyFirmata API.
For more advanced python usage of Firmata, you can consider using pymata4.
Using JavaScript to Interpret Firmata¶
Just like using Python to control Arduino Core via the Firmata protocol, you can also choose other languages that you are familiar with to program, such as JavaScript! This is implemented by the official Firmata team and you can find out more information at firmata.js.
Getting Started with firmata.js¶
Make sure that node.js is installed on the PC.
To blink an LED connected on D13¶
To read Analog Signals on A0¶
To test the analog signals, you can simply use the Grove — Rotary Angle Sensor!
PWM Outputs on D6¶
I2C Signals¶
firmata.js also support I2C and UART communications, here provides an example using with Grove — 3-Axis Digital Accelerometer(ADXL345)(В±16g):
- Hardware Connection:
tino/pyFirmata
Use Git or checkout with SVN using the web URL.
Work fast with our official CLI. Learn more.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Latest commit
Git stats
Files
Failed to load latest commit information.
README.rst
pyFirmata is a Python interface for the Firmata protocol. It is fully compatible with Firmata 2.1, and has some functionality of version 2.2. It runs on Python 2.7, 3.6 and 3.7.
Test & coverage status:
The preferred way to install is with pip:
You can also install from source with python setup.py install . You will need to have setuptools installed:
To use analog ports, it is probably handy to start an iterator thread. Otherwise the board will keep sending data to your serial, until it overflows:
If you use a pin more often, it can be worth it to use the get_pin method of the board. It let’s you specify what pin you need by a string, composed of ‘a’ or ‘d’ (depending on wether you need an analog or digital pin), the pin number, and the mode (‘i’ for input, ‘o’ for output, ‘p’ for pwm). All seperated by : . Eg. a:0:i for analog 0 as input or d:3:p for digital pin 3 as pwm.:
If you want to use a board with a different layout than the standard Arduino or the Arduino Mega (for which there exist the shortcut classes pyfirmata.Arduino and pyfirmata.ArduinoMega ), instantiate the Board class with a dictionary as the layout argument. This is the layout dict for the Mega for example:
The next things on my list are to implement the new protocol changes in firmata:
berndporr/pyFirmata2
Use Git or checkout with SVN using the web URL.
Work fast with our official CLI. Learn more.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
This branch is 130 commits ahead of tino:master.
Open a pull request to contribute your changes upstream.
Latest commit
Git stats
Files
Failed to load latest commit information.
README.md
PyFirmata2 turns your Arduino into a data acquisition card controlled by Python.
Up to 1kHz precise sampling at the analogue ports for digital filtering.
Just upload the default firmata sketch into your Arduino and you are all set.
No loops and «sleep» commands: pyFirmata2 is an updated version of pyFirmata which replaces loops with callbacks. Instead of unreliable and disruptive «sleep» commands in a loop the Python application registers callbacks with pyfirmata2 which are then called every time new data has arrived. This means for the analogue channels the callbacks are called at the specified sampling rate while the digital ports call the callback functions after a state change at the port (from 0 to 1 or 1 to 0).
This API has been used in the Digital Signal Processing (DSP) class to practise realtime filtering of analogue sensor data. Examples can be viewed on the YouTube channel of the class: https://www.youtube.com/user/DSPcourse
Start the IDE and upload the standard firmata sketch into your Arduino with:
The preferred way to install is with pip / pip3 . Under Linux:
and under Windows/Mac type:
You can also install from source with:
Under Linux type:
Under Windows / Mac:
Create an instance of the Arduino class:
which automatically detects the serial port of the Arduino.
If this fails you can also specify the serial port manually, for example:
Under Linux this is usually /dev/ttyACM0 . Under Windows this is a COM port, for example COM4 . On a MAC it’s /dev/ttys000 , /dev/cu.usbmodem14101 or check for the latest addition: ls -l -t /dev/* .
Starting sampling at a given sampling interval
In order to sample analogue data you need to specify a sampling interval in ms which then applies to all channels. The smallest interval is 1ms:
Calling samplingOn() without its argument sets the sampling interval to 19ms.
Enabling and reading from analogue or digital input pins
To receive data register a callback handler and then enable it:
where myCallback(data) is then called every time after data has been received and is timed by the arduino itself. For analogue inputs that’s at the given sampling rate and for digital ones at state changes from 0 to 1 or 1 to 0.
Writing to a digital port
Digital ports can be written to at any time:
For any other functionality (PWM or servo) use the pin class below.
The command get_pin requests the class of a pin by specifying a string, composed of ‘a’ or ‘d’ (depending on if you need an analog or digital pin), the pin number, and the mode:
- ‘i’ for input (digital or analogue)
- ‘u’ for input with pullup (digital)
- ‘o’ for output (digital)
- ‘p’ for pwm (digital)
- ‘s’ for servo (digital) All seperated by : , for example:
Values for analogue ports and PWM are 0..1, for servo between 0 and 180 (degrees) and for digital ports True & False .
Closing the board
To close the serial port to the Arduino use the exit command:
The directory https://github.com/berndporr/pyFirmata2/tree/master/examples contains two realtime Oscilloscopes with precise sampling rate, a digital port reader, the ubiquitous flashing LED program, pwm, servo control and a program which prints data using the callback handler.
Spyder / pyCharm / IDEs
Start your program from the console / terminal and never within an IDE. Here is an example for Windows:
The problem with IDEs is that they won’t let your Python program terminate properly which leaves the serial port in an undefined state. If you then re-run your program it won’t be able to talk to your Arduino. In the worst case you need to reboot your computer. Bottomline: use your IDE for editing, run the program from the console / terminal.
After an update still the old version is being used
If you use the —user option to install / update packages Python might keep older versions.
Solution: Do a pip uninstall pyfirmata2 multiple times until no version is left on your computer. Then install it again as described above.
The original pyFirmata was written by Tino de Bruijn and is recommended if you’d rather prefer loops and sleep()-commands.
About
Turn your Arduino into a realtime data acquisition card under Python
Arduino Standard Firmata Tutorial
This tutorial is an introduction to Arduino Firmata, with a focus on Standard Firmata.
First I’ll explain to you when and why to use Firmata for Arduino. After that, you’ll see how to quickly setup Standard Firmata on your Arduino. And then you’ll create a client on your computer to actually communicate and give commands to your Arduino.
For this tutorial I’ll use an Arduino Uno board.
Table of Contents
Why using Arduino (Standard) Firmata?
The need for communication
First of all, if your Arduino application is a program that doesn’t need to communicate with any other device, then you won’t need to use Firmata.
Now, let’s say you want to control your Arduino from another machine – here we’ll simply use your computer. You want all the logic of your program to be on your computer, while the Arduino board only executes orders (actuates hardware pins), and gives back some information (reads hardware pins). Basically you want to make your Arduino more “dynamic”, and export the “brain” of the Arduino into your computer. Put in other words, you want to write the firmware logic on your computer, not on the Arduino.
In this case you need to implement some sort of communication. The most straightforward communication is Serial via USB. That’s probably what you’ve used when learning some Arduino basics. And it works fine. You can send messages to the Arduino (bytes, int, string, etc) and also receive messages.
You are learning how to use Arduino to build your own projects?
Check out Arduino For Beginners and learn step by step.
Now, Arduino Firmata is a layer added on top of Serial communication. The library uses the Firmata protocol which communicates over Serial.
Arduino Firmata is kind of a high level interface to simplify things, and makes writing code easier and quicker for you. You could write your own library based on Serial, or you could use Firmata.
What is StandardFirmata for Arduino?
In this tutorial we’ll focus on Standard Firmata. This is a sketch based on the Firmata library (based on the Firmata protocol) which will allow you to control all Arduino pins from your computer. You’ll be able to change a pin’s mode, state, read the pin, etc.
And all that without writing any code on the Arduino side. It’s already done for you.
The Arduino will act like a server (receives requests and sends data), and your computer will act like a client (sends requests and receives data).
For example, if you want to set pin 13 to OUTPUT, and set its state to HIGH, then that’s something you’ll do in your computer using a Firmata client. The command will be sent to Arduino which will actually execute it.
Install StandardFirmata on Arduino
Let’s upload the StandardFirmata library on your Arduino board.
First, make sure you’ve installed the Arduino IDE on your computer. You can download the Arduino IDE from the official Arduino download page. Choose the system (Windows, Mac, Linux) you’re currently using, download, and execute the installer. If you already have Arduino IDE installed on your computer, make sure the version is recent (update if needed).
Now, open your Arduino IDE, and connect your Arduino board to your computer. Select the proper board under “Tools” > “Boards” (here Arduino Uno), and the port where the board is connected. On Windows, you’ll often see something as COMX. It can vary depending on your system, and what else is plugged to your computer.
Now that you have your Arduino board correctly detected by the Arduino IDE, you can open the StandardFirmata sketch, from the available examples.
If you can’t see “Firmata” under “Examples” it means that the Firmata library is not installed. It also surely means that your Arduino IDE is not up to date, since for recent releases, Firmata is automatically included. So, you can either update your Arduino IDE, or check under “Sketch” > “Include Library” > “Manage Libraries…”.
Write “firmata” in the search bar, and you’ll find the Firmata library (Firmata Built-In by Firmata Developers). If not installed, select the latest version and click on the “Install” button.
Now that you have Firmata on your Arduino IDE, select the StandardFirmata sketch example. This will open a new window with a pretty long program. Actually you don’t need to read this program. All you have to do it to upload it to your Arduino board.
Click on the “Upload” button.
Now, Firmata is running on your Arduino. That’s all you need to do on the Arduino side!
Test Arduino Firmata without any code
You can download a simple program to test if your Arduino is correctly working with StandardFirmata.
Go to this Firmata wiki page, scroll under “Firmata Test Program”, and download the program accordingly to your computer system.
No need to install it, you can just click on it to launch it. Don’t forget to keep your Arduino board connected to your computer with an USB cable.
At first you won’t see any of the pins. Click on “Port”, and select the port you’re using for Arduino (in my case: COM4 on Windows 10). Note: if you’re using Serial communication with another program, first close the communication before you can use it here. Also, if you want to upload something new to your board, make sure you first close this test program, because the upload mechanism also uses Serial.
So, once the communication is setup, you can interact with all available pins on the Arduino!
The most simple test you can do here is to set pin 13 as OUTPUT, and set its state to HIGH. Pin 13 on Arduino Uno is connected to the built in LED. So, by clicking on HIGH and then LOW, you should see the LED blink on your board.
Write a client program with pyfirmata
Setup pyfirmata
Using the GUI test program is nice, but not quite practical if you want to control the Arduino from your own programs.
As for now you’ve only see the server side: A sketch uploaded to the Arduino board, which uses the Firmata protocol.
Now, to talk to your board, you need to write some sort of client code on your computer.
Basically you have to communicate using the Firmata protocol over Serial communication. That can sounds quite difficult to do at first, but don’t worry, there are also client libraries available for you that will handle all the communication out of the box!
For example, pyfirmata is a famous Python library to use Firmata as a client. There are libraries available in many languages (list here), but for this tutorial we’ll only focus on writing a Python client.
To install pyfirmata:
Basic code with pyfirmata
Here we’ll simply try to make the Blink example (blink LED 13 every second) using Python and the pyfirmata module.
Let’s break down this code line by line:
First we import the Arduino functionalities from pyfirmata.
To initiate the communication, simply use the Arduino() function from pyfirmata, to which you give one parameter: the port you’re using for your Arduino board. This is the same port you used to upload the program to your board.
Once the communication is successfully started (it can take some time), we display a log line on the terminal.
And here we have the blink LED Python code. The code structure is exactly the same as the blink LED example in Arduino language.
When writing board.digital[13].write(1) , for example, pyfirmata will create a request using the Firmata protocol. It will send it to the Arduino via Serial communication. The Arduino board will analyse this request and translate it to digitalWrite(13, HIGH); .
Now, simply run your Python code and see the built-in LED blink on your Arduino board!
You can find all the available functions on the pyfirmata documentation website.
Going further with Arduino Firmata
With this tutorial you should have a simple, but good overview of how to use Firmata with Arduino. It’s quite basic, but with that knowledge you can start developing more complex projects and applications.
Any application that requires a lot of computation power, as well as hardware handling, is a possible candidate for using Firmata. The “brain” board/machine will handle all the logic, and give appropriate commands to the hardware actuator, in this case the Arduino board.
You can go further by:
- Using Firmata between a Raspberry Pi board and an Arduino board.
- Implementing a client in different languages (JavaScript, Java, Php, …) to communicate with your Arduino in web/desktop/Android apps.
- Diving deeper into the Firmata protocol to understand how it’s made and how it’s implemented by Arduino.
Also, note that Firmata is not the answer to all problems. In some applications which require communication, you’ll find that a custom Serial communication, or a different protocol (custom or not) might be more appropriate. How will you know that? Practice, and practice, and more practice!
Did you find this tutorial useful?
Do you want to learn Arduino from scratch?
If yes, this course is for you:
Did you find this tutorial useful?
Do you want to become better at programming robots, with Arduino, Raspberry Pi, or ROS2?
If yes, subscribe to receive exclusive content and special offers!