pyserial - Comment lire la dernière ligne envoyé à partir d'un périphérique série

Je suis peut-être un malentendu à votre question, mais comme c'est une ligne série, vous aurez à lire tout envoyé à partir de l'Arduino de façon séquentielle - il va être mis en mémoire tampon dans l'Arduino avant de l'avoir lu.

Si vous voulez avoir un affichage de l'état qui montre la dernière chose envoyés utiliser un thread qui intègre le code dans votre question (moins la veille), et de garder la dernière ligne complète de lire la dernière ligne de l'Arduino.

Mise à jour: mtasicà l'exemple de code est assez bonne, mais si l'Arduino a envoyé une commande partielle quand inWaiting() est appelé, vous obtiendrez un tronc de ligne. Au lieu de cela, ce que vous voulez faire est de mettre la dernière complète ligne en last_received, et de garder la partielle de la ligne dans buffer de sorte qu'il peut être ajouté à la prochaine ronde de la boucle. Quelque chose comme ceci:

def receiving(ser):
    global last_received

    buffer_string = ''
    while True:
        buffer_string = buffer_string + ser.read(ser.inWaiting())
        if '\n' in buffer_string:
            lines = buffer_string.split('\n') # Guaranteed to have at least 2 entries
            last_received = lines[-2]
            #If the Arduino sends lots of empty lines, you'll lose the
            #last filled line, so you could make the above statement conditional
            #like so: if lines[-2]: last_received = lines[-2]
            buffer_string = lines[-1]

Concernant l'utilisation de readline(): Voici ce que le Pyserial documentation a à dire (légèrement modifié pour plus de clarté et avec une mention à readlines()):

Être prudent lors de l'utilisation de "readline". Faire
spécifier un timeout lors de l'ouverture de la
port série, sinon il pourrait bloquer
jamais si aucun caractère de saut de ligne est
reçu. Notez également que "readlines()"
ne fonctionne qu'avec un délai d'attente. Il
dépend de l'existence d'un délai d'attente et
qui interprète comme EOF (fin de fichier).

qui semble tout à fait raisonnable pour moi!

Ces solutions de porc de la CPU lors de l'attente pour les personnages.

Vous devez faire au moins un appel de blocage à lire(1)

while True:
    if '\n' in buffer: 
        pass # skip if a line already in buffer
    else:
        buffer += ser.read(1)  # this will block until one more char or timeout
    buffer += ser.read(ser.inWaiting()) # get remaining buffered chars

...et de faire la split chose qu'avant.

Cette méthode permet de contrôler séparément le délai d'attente pour la collecte de toutes les données de chaque ligne, et d'un autre délai d'attente sur les lignes supplémentaires.

# get the last line from serial port
lines = serial_com()
lines[-1]              

def serial_com():
    '''Serial communications: get a response'''

    # open serial port
    try:
        serial_port = serial.Serial(com_port, baudrate=115200, timeout=1)
    except serial.SerialException as e:
        print("could not open serial port '{}': {}".format(com_port, e))

    # read response from serial port
    lines = []
    while True:
        line = serial_port.readline()
        lines.append(line.decode('utf-8').rstrip())

        # wait for new data after each line
        timeout = time.time() + 0.1
        while not serial_port.inWaiting() and timeout > time.time():
            pass
        if not serial_port.inWaiting():
            break 

    #close the serial port
    serial_port.close()   
    return lines

Légère modification à mtasic & Vinay Sajip code:

Alors que j'ai trouvé ce code très utile pour moi pour une application similaire, j'avais besoin d' tous les lignes de la série de l'appareil qui permettrait d'envoyer des informations périodiquement.

J'ai opté pour de la pop, le premier élément à partir du haut, de l'enregistrer, puis de rejoindre le reste des éléments comme le nouveau tampon et continuer à partir de là.

Je me rends compte que c'est pas ce que Greg l'a cherché, mais je pensais que c'était le partage de la valeur comme une note de côté.

def receiving(ser):
    global last_received

    buffer = ''
    while True:
        buffer = buffer + ser.read(ser.inWaiting())
        if '\n' in buffer:
            lines = buffer.split('\n')
            last_received = lines.pop(0)

            buffer = '\n'.join(lines)

Trop de complications

Quelle est la raison pour diviser les octets de l'objet par un saut de ligne ou par d'autres de la matrice de manipulations?
J'écris la méthode la plus simple, qui permettra de résoudre votre problème:

import serial
s = serial.Serial(31)
s.write(bytes("ATI\r\n", "utf-8"));
while True:
    last = ''
    for byte in s.read(s.inWaiting()): last += chr(byte)
    if len(last) > 0:
        # Do whatever you want with last
        print (bytes(last, "utf-8"))
        last = ''