How to communicate an Arduino with Python on PC?

General concepts

Numeric values ​​must be represented as a string to be passed and converted to a numeric for use on both platforms. It is possible to send binary data, if you wish, but it is uselessly complicating your life.

All Arduino-PC communication must be in "UTF-8", which requires encoding/decoding the data on the PC side for sending/receiving.

Finally, you always have to send a '\n' at the end of the string, to mark its end. This is required both ways.

python

We will use pyserialto communicate from PC with the Arduino.

First we must open the serial port that communicates with Arduino. This requires identifying the serial and its speed, which must be compatible with the counterpart:

 ser = serial.Serial('/dev/ttyUSB0', 9600)

In this case, the serial port is /dev/ttyUSB0, which is platform dependent, and the speed is 9,600 bauds.

To send a string, you must first encode it to "UTF-8" using encode():

texto = "iniciar\n".encode("UTF-8") # Recuerda el \n al final.
ser.write(texto)

To receive a response, use readline(). This method reads from the serial until it detects a \n. If it doesn't find it, it blocks. The response comes in UTF-8, and must be encoded to transform it into a Python string:

 linea = ser.readline()
 respuesta = linea.decode()
 valor = int(respuesta)

If the answer expresses a numerical value, it must be converted appropriately, using intor float.

Arduino

Arduino requires that the function loopexecute in each pass in the minimum possible time, which implies that the signal must be read character by character.

Although Arduino has a method readString()that returns a data type Stringfrom the serial, it is not recommended to use it. This method blocks until a timeout\n is detected , which introduces all sorts of random errors. Also, it complicates encoding.

The general pattern is:

String buffer = "";

void loop() {

  if (Serial.available()) {
    /*
     * Hay uno o más caracteres a leer en la serial.
     */
    int car = Serial.read();
    /*
     * Procesamos caracter a caracter por simplicidad.
     */
    if (car == '\n') {
      /*
       * El retorno de carro marca el fin de la entrada.
       */

      ... hacer alguna cosa con lo leido ...
 
      buffer = ""  // Limpiar el buffer una vez procesado.
      }
    } else {
      /*
       * Acumular los caracteres leídos.
       */
      buffer += (char) car;
    }

First, we declare bufferas Stringoutside loopso that it retains its value during execution. In this variable we accumulate the read characters until we detect the \none that marks the end.

If there are characters to read in the serial, we will read and accumulate them one by one, for speed and simplicity.

Upon detecting the \n, we process the buffer and clear it, to receive the next text.

Everything received by Arduino is text; if we want to consider it as a value, the class Stringoffers several functions like toInt(), toFloat(), etc.

When sending responses from the Arduino to the PC we don't need to encode anything (it works in ASCII, UTF-8 compatible) and the final carriage return is automatically added by the println().

show

Arduino

This Arduino code reads from the serial. The texts are returned transformed to uppercase; the values ​​are accumulated and for each one received, it returns the accumulated sum.

[Of course, it doesn't include error handling.]

/*
 * Recibe textos y valores por la serial.
 * Responde convirtiendo textos a mayúsculas
 * y con la suma acumulada de los valores.
 */
void setup() {
  Serial.begin(9600);
}

String buffer = "";

void loop() {
  static float suma = 0.0;

  if (Serial.available()) {
    /*
     * Hay uno o más caracteres a leer en la serial.
     */
    int car = Serial.read();
    /*
     * Procesamos caracter a caracter por simplicidad.
     */
    if (car == '\n') {
      /*
       * El retorno de carro marca el fin de la entrada.
       */
      if (isDigit(buffer.charAt(0))) {
        suma += buffer.toFloat();
        Serial.println(suma);
      } else {       
        buffer.toUpperCase();
        Serial.println(buffer);
      }
      /*
       * Limpiar el buffer para recibir la siguiente entrada.
       */
      buffer = "";
    } else {
      /*
       * Acumular los caracteres leidos.
       */
      buffer += (char) car;
    }
  }
}

python

This code sends text and values ​​to the Arduino, receives the responses and displays them on the console.

[Of course, it doesn't include error handling.]

import serial

def encode_send(ser, texto):
     print(f"enviar: {texto}")
     enc = f"{texto}\n".encode("UTF-8")
     ser.write(enc)

def decode_response(ser):
     linea = ser.readline()
     respuesta = linea.decode()
     return respuesta

def conversar():
     ser = serial.Serial('/dev/ttyUSB0', 9600)
     valor1 = 125
     valor2 = 3.1415
     encode_send(ser, "Texto áéíóú")
     respuesta = decode_response(ser)
     print(f"recibido: {respuesta}")

     encode_send(ser, "valor1")
     decode_response(ser)
     encode_send(ser, f"{valor1}")
     respuesta = decode_response(ser)
     print(f"recibido: {respuesta}")

     encode_send(ser, "valor2")
     decode_response(ser)
     encode_send(ser, f"{valor2}")
     respuesta = decode_response(ser)
     print(f"recibido: {respuesta}")

     ser.close()

Result

enviar: Texto áéíóú
recibido: TEXTO áéíóú

enviar: valor1
enviar: 125
recibido: 125.00

enviar: valor2
enviar: 3.1415
recibido: 128.14


Process finished with exit code 0