À l'aide de PySerial est-il possble d'attendre que les données?

J'ai un programme en python qui est de la lecture des données à partir d'un port série via le PySerial module. Les deux conditions que j'ai besoin de garder à l'esprit: je ne sais pas la quantité de données à arive, et je ne sais pas quand s'attendre à des données.

Basé sur ce que j'ai est venu avec le code ci-dessous snipets:

#Code from main loop, spawning thread and waiting for data
s = serial.Serial(5, timeout=5)  # Open COM5, 5 second timeout
s.baudrate = 19200

#Code from thread reading serial data
while 1:
  tdata = s.read(500)    # Read 500 characters or 5 seconds

  if(tdata.__len__() > 0):        #If we got data
    if(self.flag_got_data is 0):  #If it's the first data we recieved, store it
      self.data = tdata        
    else:                         #if it's not the first, append the data
      self.data += tdata
      self.flag_got_data = 1

Donc ce code en boucle pour toujours obtenir les données sur le port série. Nous allons obtenir jusqu'à 500 caractères stocker les données, puis d'alerte de la boucle principale par un indicateur. Si aucune donnée n'est présente, nous allons juste aller de nouveau au sommeil et d'attendre.

Le code fonctionne, mais je n'aime pas le 5s délai d'attente. J'en ai besoin car je ne sais pas quelle quantité de données à attendre, mais je n'aime pas qu'il se réveille toutes les 5 secondes, même lorsque aucune donnée n'est présente.

Est-il de toute façon à vérifier si les données deviennent disponibles avant de faire la read? Je suis en train de penser à quelque chose comme le select de commande sous Linux.

EDIT:
Juste pensé que je remarque que j'ai trouvé le inWaiting() méthode, mais vraiment que semble qu'il suffit de changer mon "sommeil" à un sondage, donc ce n'est pas ce que je veux ici. J'ai juste envie de dormir, jusqu'à ce que des données, puis d'aller la chercher.

OriginalL'auteur Mike | 2012-10-22

16

Ok, j'ai effectivement eu quelque chose ensemble, que je l'aime pour cela. En utilisant une combinaison de read() sans délai d'attente et la inWaiting() méthode:
```
#Modified code from main loop: 
s = serial.Serial(5)

#Modified code from thread reading the serial port
while 1:
  tdata = s.read()           # Wait forever for anything
  time.sleep(1)              # Sleep (or inWaiting() doesn't give the correct value)
  data_left = s.inWaiting()  # Get the number of characters ready to be read
  tdata += s.read(data_left) # Do the read and combine it with the first character

  ... #Rest of the code
```
Cela semble donner les résultats que je voulais, je suppose que ce type de fonctionnalité n'existe pas une méthode unique en Python

time.sleep(1) semble être une très laid hack qui ajoute un tas de délai pour l'obtention de vos données.
Aucun argument là, il semble qu'il fonctionne sans sommeil, mais le data_left devient très peu fiable (une chaîne de 19 caractères boucles de 3, puis 10, puis 6 "banques"). Donc, je ne suis toujours pas heureux avec elle, mais il est plus proche de ce que je pensais. Le sommeil jusqu'à ce que les données, puis lire les données, puis aller de nouveau au sommeil.
Je ne vois pas en quoi c'est "peu fiables". C'est exactement la façon dont les octets sont arrivés comme vous êtes la lecture. Vous pouvez utiliser interCharTimeout, qui vous permet de détecter lorsque le récepteur a cessé de voir tout nouveau octets.

OriginalL'auteur Mike
11

Vous pouvez définir timeout = None, puis le read appel de bloc jusqu'à ce que le nombre d'octets sont là. Si vous voulez attendre jusqu'à ce que les données arrivent, il suffit de faire une read(1) avec délai d'attente None. Si vous voulez vérifier les données sans blocage, faire un read(1) avec temporisation à zéro, et de vérifier si il renvoie toutes les données.

(voir la documentation http://pyserial.sourceforge.net/pyserial_api.html)

Mais je pense aussi qu'il n'y a absolument rien de mal avec l'aide d'un 5s délai d'attente et de réveil et de retourner immédiatement à lire. C'est très simple et ne seront pas mesurables frais généraux.
Merci pour l'info, je l'ai fait voir à la lecture de la documentation ne pouvaient tout simplement pas comprendre comment le faire faire ce que je voulais. Je suis d'accord d'avoir une boucle avec un délai d'attente n'est pas très cher sur une machine de bureau, mais (en provenance d'un intégré à l'arrière-plan), il se sent si mal à m'sondage
Une meilleure solution, à mon avis (au moins pour mes besoins). Merci pour le partage.

OriginalL'auteur TJD

def cmd(cmd,serial):
    out='';prev='101001011'
    serial.flushInput();serial.flushOutput()
    serial.write(cmd+'\r');
    while True:
        out+= str(serial.read(1))
        if prev == out: return out
        prev=out
    return out

l'appeler comme ceci:

cmd('ATZ',serial.Serial('/dev/ttyUSB0', timeout=1, baudrate=115000))

OriginalL'auteur user5509884

Vous devez vous connecter pour publier un commentaire.