Cross Platform serial communication using Python (PySerial) and Arduino

Tutorial on How to connect  an Arduino or Microcontroller like AVR ATmega328P,MSP430 ,PIC  with a Windows/Linux PC using serial port (ViCP) and talking with it using Python and pySerial library.

This tutorial will concentrate on Python 3.x.x language and will use Pyserial 3.5 Library to communicate with Arduino

1. First section deals with Arduino to PC communication using Python

2. Second section deals with communicating to bare microcontrollers like AVR, Microchip using Python Serial Library

3. and Last section deals with Linux specific details for Python serial port programming.

Check this article if you are Looking to add a tkinter(ttkbootstrap) GUI for your Python Serial Communication program

Contents

• Introduction 
• what is pySerial Module
• Sourcecodes
• Hardware used
• Installing PySerial on Windows
• Writing data to Serial Port using Python
• Running the Code on Windows
• pySerial Exceptions
• Reading Data from Serial port using Python
• Setting pySerial Read timeouts
• Interfacing Microcontroller with PC
• Interfacing MSP430 with PC
• Interfacing ATmega328P with PC
• DTR RTS Pin Control using pySerial
• Serial Programming on Linux using Python and pySerial

Introduction

Python is an open source, cross platform ,interpreted language that is easy to learn for beginners. One of the many advantages of Python is the sheer number of contributed modules for performing a wide variety of tasks.

It is widely used for building scripts/program to interact with real world objects like USB relays, USB data acquisition devices, USB data loggers and other embedded systems.

Easiest way to interact with serial port devices is over a Virtual Com Port using a USB to Serial Converter IC like

• FTDI FT232RL
• TUSB3410
• or CP2102

Once the necessary drivers are installed you can interact over VCP by reading and writing into it.

One problem with developing code that uses serial port is portability, you can't use the same code in both Windows and Linux. For each operating system (Windows/Linux) you have to write custom codes using the native API's as we have done below

• Win32 Serial Port Programming using Native APi's
• Linux Serial Port programming using Native API's.       
   

pySerial Module

Python provides an easy way to do cross platform serial communication using pySerial module.

The modules hides all the OS specific peculiarities and presents a uniform simple interface for programming the serial port.

The code written with pySerial can run unmodified on Windows,Linux systems and Mac Systems.

Source codes

• Browse Python Serial Comm code from our Github Repo
• Download Python Serial Comm code as zip file 

Please note that the source codes on the website show only the relevant sections to highlight the process of programming the serial port.       
Please use the complete source codes from our github repo when building your own program.

Hardware Used

Here we will be using an Arduino to communicate with the python script running on the PC. You can use both Arduino UNO or Arduino Mega. 

If you want to communicate with a bare microcontroller like ATmega32,ATmega32p,ESP32,Raspberry Pi Pico, MSP430 using Python ,You will need a USB to serial converter like USB2SERIAL.

Python on Windows

In Windows, Python is not installed by default, you can find python binary installers from python.org 

After completing the installation you can type “python” on your command prompt to enter the python shell. (use CTRL + Z to exit from the shell).

Or you can use the built in GUI shell called IDLE. Press CTR+Q to exit from IDLE.

Installing PySerial on Windows using pip

After you have installed the python interpreter, You can install PySerial using pip installer.

 So open up your Windows Command prompt and type in the following command as shown below.

C:\>python -m pip install pyserial

You can also check the installed packages using pip list command.

C:\>python -m pip list 

After installing pySerial, open the python shell and type “import serial”. If you are not getting any error messages, pySerial is installed properly.

Some IDE's like Thonny has built in Python interpreters which work independently from the interpreter installed on your system. They come with pySerial preinstalled.

Writing data to Serial Port using Python and pySerial

Here we will learn to communicate with an Arduino through Serial Port (Virtual COM Port)  from a Windows or Linux PC using Python 3.x.x. 

The PC will transmit some data (ASCII Characters) serially over Virtual COM port to the Arduino UNO using  a Python Script running on a Windows 10 PC as shown in the above image. The Arduino will blink a LED connected to Pin12 on receiving the character ASCII 'A'

PC Side Python Code 

Now on the PC side 

let's open a serial port and write some values to it. The code in python is quite straight forward, you can just read it like plain English.

Open a text editor and type the following lines of code into it .Save the file with a ” .py” extension.

The Below code writes character 'A' to the serial port.

# Python code transmits a byte to Arduino /Microcontroller

import serial
import time

SerialObj = serial.Serial('COM24') # COMxx   format on Windows
                                  # ttyUSBx format on Linux

SerialObj.baudrate = 9600  # set Baud rate to 9600
SerialObj.bytesize = 8     # Number of data bits = 8
SerialObj.parity   ='N'    # No parity
SerialObj.stopbits = 1     # Number of Stop bits = 1
time.sleep(3)

SerialObj.write(b'A')      #transmit 'A' (8bit) to micro/Arduino
SerialObj.close()          # Close the port

Please make sure that you use the correct serial port number. 

In the above code it is COM24, 

Your serial port number may be different .You can find the correct port number using Device Manager on Windows as shown below .

Code Explanation

The first line import serial imports the pySerial module so that your program can use it.

ComPort = serial.Serial('COM24') opens the serial port named COM24.

then we set the various parameters for the serial communication like baudrate, no of stop/start bits,parity etc. Here we will be using the default 9600bps, 8N1 format for communication.

SerialObj.baudrate = 9600  # set Baud rate to 9600
SerialObj.bytesize = 8     # Number of data bits = 8
SerialObj.parity   ='N'    # No parity
SerialObj.stopbits = 1     # Number of Stop bits = 1

Opening the serial port using pySerial will reset the Arduino connected on the port,(here COM24).This is specific to Arduino only .

This is because some of the serial port pins of the USB protocol chip (FT232/ATmega8U/16U) like RTS/DTR are used by the Arduino board to put the ATmega328P in boot mode during programming. When we open the serial port, the signal levels on the RTS/DTR pins of the USB IC may change.

time.sleep(3) # wait for some time ,so the Arduino is ready

So you should wait some time (here 3 seconds) before transmitting the data to the Arduino board. 

In the above code we are using time.sleep(3) function to create the delay.

Serial communication occurs in bytes (8 bits) while Python3+ handles strings in Unicode format which may consume up to 4 bytes.

So to make the characters suitable to send to a microcontroller we have to convert them to byte based chunks.

In the above Example we are sending a byte 'A'. 

Here A is defined as a byte by using b prefix.You can also use the bytearray() function.

SerialObj.write(b'A')      #transmit 'A' (8bit) to micro/Arduino

SerialObj.write(b'A')  function then writes/sends data to your microcontroller /Arduino.

Arduino Side Code

PC and Arduino are connected as shown below using a single USB cable.

On the Arduino side ,

we wait for the Character A and turns the LED connected to Pin12 ON for 2 seconds.

A switch() is used to select the required action.

The partial code is shown below.

if (Serial.available()) 
   {
     
     RxedByte = Serial.read();     
     switch(RxedByte)
     {
       case 'A':  digitalWrite(12,HIGH);
                  delay(1000);
                  digitalWrite(12,LOW);
                  break;
       case 'B': //your code
                  break;
       default:
                  break;
     }//end of switch()
   }//endof if

Please visit our Github for the full code.

Running the Python Code

In Windows,       
You can either run the code from command line,

D:\> python yourSerialTransmitCode.py

or 

by using IDLE       
From IDLE use “File → Open” to open your code file and from “Run → Run Module”. or press F5

Handling Pyserial Serial Port Exceptions

Some times opening the serial port may fail due to various conditions like port in use ,port not found etc .

pySerial comes with the exception serial.SerialException which can be used to identify the error and fail gracefully.

We also have a Video on How to use and handle pySerial Exceptions during serial port programming

The below partial code shows how to use exceptions

try:
   SerialObj = serial.Serial('COM11',9600) # open the Serial Port
   
   
except serial.SerialException as var : # var contains details of issue
   print('An Exception Occured')
   print('Exception Details-> ', var)
   
else:
   print('Serial Port Opened')

Here is an example of the error message you will get when some other process is using the port you are trying to access.

When Port number is wrong. 

%Run is due to the IDE (here Thonny) running the code on the terminal.

Reading Data from Serial port using Python and Pyserial

Here we will be sending a text string "Hello from Arduino" from Arduino to a Windows/Linux PC through serial port using Python.

The Python script running on the PC will receive data send by the Arduino using the readline() function of the pyserial library and display the text data on the command line.

PySerial provides  two functions to read data from the serialport

1. readline()
2. read()

readline() reads till it encounters a newline character '\n' and returns the bytes it has read.

If \n character is not encountered it will wait forever or until the read timeout expires.

ReceivedString = SerialObj.readline()
print(ReceivedString)
SerialObj.close() 

Setting up pySerial read timeouts 

When we are reading something from the serial port using Python and Pyserial library , the sender (Arduino) may fail to respond which will result in the Python script waiting forever. 

To mitigate this issue we can set timeouts for the pySerial read() and readline() methods which forces these methods to return after a set time period, irrespective of whether data is received or not.

The code below shows how to set timeouts during a read call. 

import serial
import time
SerialObj = serial.Serial('COM3') # COMxx   format on Windows
                                   # ttyUSBx format on Linux
                                   
SerialObj.baudrate = 9600  # set Baud rate to 9600
SerialObj.bytesize = 8     # Number of data bits = 8
SerialObj.parity   ='N'    # No parity
SerialObj.stopbits = 1     # Number of Stop bits = 1

SerialObj.timeout  = None  # Setting timeouts here No timeouts,waits forever

time.sleep(3)  #needed only for arduino

ReceivedString = SerialObj.readline()
print(ReceivedString)
SerialObj.close() 

there are three values for the timeout parameter

SerialObj.timeout  = None ,No timeouts,waits forever

1. timeout = None  means that the code will wait forever 
2. timeout = 0 non-blocking mode, return immediately in any case
3. timeout = seconds  Return immediately if data is available else wait for specified seconds till the data arrives

SerialObj.timeout  = 3 ,timeout set for 3 seconds,will return after 3seconds

Arduino Side Code

On the  Arduino  side ,the text string is stored in a char array as shown below and transmitted to the PC in a loop of about 1 second.

void setup() part not shown below, use the full code from GitHub repo.

void loop()
{
 char TextToSend[] = " Hello From Arduino Uno";
 Serial.println(TextToSend); // sends a \n with text
 delay(1000); //1 second delay 
}

Make sure that you use the 

Serial.println(TextToSend); // sends a \n with text

 as println() sends the \n character which helps the python readline() function to return.

Once the string is received the data is displayed on command line as shown below.

Connecting a Bare Microcontroller to your PC 's Serial port

In the above tutorial we learned how to connect an Arduino board with a PC and communicate with it (Receive/Transmit data ) using a standard USB cable.

What if instead of an Arduino we just want to connect a bare microcontroller like ATmega328P,ATmega16,MSP430 or PIC18F4550 to your PC.

In the case of Arduino all the details of how ATmega328P connects with the USB section is abstracted away from the user, when you are building embedded systems  you have to know which signals are connected to which.

When you are using a microcontroller which do not have any built in USB controller like ATmega16 or MSP430G2553 ,you have to use a USB to Serial Converter chip like FT232RL or buy a standard USB to serial converter board like  USB2SERIAL to convert serial signals to the USB ones.

The USB2SERIAL board shown can work as a USB to serial Converter ,USB to RS232 Converter or USB to RS485 converter

The below block diagram shows how to interface any microcontroller to a PC with a standard USB to serial converter. 

Here the TXD of the serial port is connected to the RXD of the microcontroller UART and vice versa. So when microcontroller transmits a byte it goes to the receive buffer of the serial port on the PC side and vice versa.

Ground lines are made common to both PC and microcontroller.

Interfacing MSP430 Microcontroller with PC using Python

Above image shows how to hook up a launchpad board with PC using USB2SERIAL converter The Controller (MSP430G2553)  is connected to the FT232's Serial port using a null modem cable as shown in the above figure.

Please note that MSP430's are 3.3V microcontrollers ,so please select the IO voltage levels of USB2SERIAL board as 3.3V.

In case you want to know more about MSP430's,

• check this tutorial on How to configure MSP430G2553 UART for serial communication.

Interfacing bare ATmega328P microcontroller with PC using Python.

Yes, Arduino uno is ATmega328P

but here the code is written in AVR embedded C and compiled using AVR studio or Microchip Studio.

• Full tutorial on AVR ATmega to PC communication can be found here

Controlling RTS and DTR Serial Port pins in Python using PySerial

RTS and DTR pins are two extra lines available on most serial ports which are used for signaling purposes.They do not transmit serial data.

Using Pyserial, you can control the logic states of RTS and DTR pins ie  make them HIGH or LOW to control a transistor switch or logic circuit.        

Earlier, PySerial API used SerialObj.setRTS() and SerialObj.setDTR() which are now deprecated.       

The new simplified API is just

• rts
• and dtr

which can be set or cleared by assigning a 1 or 0.

import serial

SerialObj = serial.Serial('COM6',9600)

SerialObj.rts = 1 #RTS HIGH
SerialObj.rts = 0 #RTS LOW
SerialObj.dtr = 1 #DTR HIGH
SerialObj.dtr = 0 #DTR LOW

SerialObj.close()

Please note that you need to add delay between HIGH and LOW to visualize the transition.

In some USB to Serial Converter chips like FT232RL the signals are Active LOW, so setting the pin=1 would make the signal LOW.       

The USB2SERIAL converter shown above have LED's that indicate the logic levels of the DTR and RTS Pins.The Pins are even brought out to screw terminal head's as shown above.

Python Serial Port programming on Linux

• Linux specific parts of the Python Serial Port programming can be found here.