Quel est l'équivalent de la Série.() dans pyserial?

Quand je suis en train de lire plusieurs lignes de données en série sur un Arduino, j'utilise la marche suivante:

String message = "";
while (Serial.available()){
    message = message + serial.read()
}

Dans Arduino C, Serial.available() renvoie le nombre d'octets disponibles pour être lu à partir de la mémoire tampon de série (Voir Docs). Ce qui est l'équivalent de Serial.available() en python?

Par exemple, si j'ai besoin de lire plusieurs lignes de données série je m'attends à ues le code suivant:

import serial
ser = serial.Serial('/dev/ttyACM0', 9600, timeout=0.050)
...
while ser.available():
    print ser.readline()
Veuillez décrire ce que Serial.available() est ou fournir un lien vers la documentation.

OriginalL'auteur Michael Molter | 2016-07-28

  1. 9

    La propriété numéro de Série.in_waiting renvoie la "le nombre d'octets dans le buffer de réception".

    Ce qui semble être l'équivalent de numéro de Série.disponible()'description: "le nombre d'octets ... c'est déjà arrivé et stockées dans la série du tampon de réception."

    Essayer:

    import serial
ser = serial.Serial('/dev/ttyACM0', 9600, timeout=0.050)
...
while ser.in_waiting:  # Or: while ser.inWaiting():
    print ser.readline()

    Pour les versions antérieures à pyserial 3.0, utilisez .inWaiting(). Pour déterminer votre pyserial version, faites ceci:

    import serial
print(serial.__version__)
    Dans tous les tutoriels d'introduction pour pyserial, je n'ai jamais vu la commande ser.in_waiting. Est-il une raison pour laquelle il est évitée? Serial.available() est omniprésent dans Arduino C de communications série. Ne développeurs python généralement utiliser un autre langage pour accomplir la même tâche?
    AttributeError: 'Serial' objet n'a pas d'attribut "in_waiting' root@raspberrypi:/home/wf# python3 --version de Python 3.4.2
    si votre version de pyserial est âgé de plus de 3.0, essayez .inWaiting().
    3.4.2 est votre python numéro de version. Le changement de inWaiting() à in_waiting s'est produite dans pyserial la version 3.0. Le pyserial numéro de version n'est pas nécessairement lié à la version de python nombre. Essayez import serial ; print (serial.__version__).
    Merci pour le commentaire. Je suis passé à Java.

    OriginalL'auteur Robᵩ

  2. 1

    J'ai résolu le même problème comme si. Le seul inconvénient de ce code est que lors de la première fois que je suis à l'envoi de la lettre 'a', ser.inWaiting() renvoie 0. Pour supprimer cet effet, j'ai ajouté délai de 1 seconde avant elle. Qui semble résoudre le problème.

    Dans mon cas, ATmega16 renvoie une chaîne de caractères, soit 8 ou 12bits. Donc, je vais obtenir le nombre de bits d'arriver à RPi avec ser.inWaiting() et puis je vais vous lire une quantité de données avec ser.read(), en les combinant dans des ser.lire(ser.inWaiting())

    import RPi.GPIO as GPIO
from time import sleep
import serial # version is 3.2.1
ser = serial.Serial('/dev/rfcomm0', 9600)
ser.parity = serial.PARITY_ODD
ser.parity = serial.PARITY_NONE
GPIO.setmode(GPIO.BOARD)
led1 = 16
led2 = 18
button = 7
GPIO.setup(led1, GPIO.OUT)
GPIO.setup(led2, GPIO.OUT)
GPIO.setup(button, GPIO.IN, pull_up_down = GPIO.PUD_UP)
try:
while True:
choice = raw_input("Enter 'a' if you want to turn LED ON or 'b' "
+ "to turn the LED OFF: ")
if (choice == "a"):
print "Sending command to turn LED ON"
GPIO.output(led1, GPIO.HIGH)
sleep(1)
GPIO.output(led1, GPIO.LOW)
#Send the actual data
ser.write('a');
#Receive what ATmega it send back
sleep(1)
received_data = ser.read(ser.inWaiting())
print "Received data: " + received_data
elif (choice == "b"):
print "Sending command to turn LED OFF"
GPIO.output(led2, GPIO.HIGH)
sleep(1)
GPIO.output(led2, GPIO.LOW)
#Send the actual data
ser.write('b');
#Receive what ATmega it sends back
sleep(1)
received_data = ser.read(ser.inWaiting())
print "Received data: " + received_data
else:
print "Invalid command"
GPIO.output(led1, GPIO.HIGH)
GPIO.output(led2, GPIO.HIGH)
sleep(.3)
GPIO.output(led1, GPIO.LOW)
GPIO.output(led2, GPIO.LOW)
sleep(.3)
GPIO.output(led1, GPIO.HIGH)
GPIO.output(led2, GPIO.HIGH)
sleep(.3)
GPIO.output(led1, GPIO.LOW)
GPIO.output(led2, GPIO.LOW)
#send invalid command
ser.write(choice);
#receive what ATmega sends back
sleep(1)
received_data = ser.read(ser.inWaiting())
print "Received data: " + received_data
finally:
GPIO.cleanup()

    OriginalL'auteur Evaldas22

  3. 1

    Une réponse correcte dépend de la version de Python - ce qui a déclenché moi pendant un certain temps aujourd'hui. Je soupçonne certains commentaires qui ont été en cours d'exécution sur Raspberry Pi qui est actuellement en Python 2.7.9 et, de même, moins-que-courant pySerial.

    Donc sur un Pi vous pouvez utiliser ser.inWaiting() qui est similaire à Serial.available() dans Arduino C - les deux renvoient le nombre d'octets dans le buffer de réception; pour pySerial >= 3.0 vous utilisez ser.in_waiting (noter que ceci est un attribut pas de fonction http://pyserial.readthedocs.io/en/latest/pyserial_api.html#serial.Serial.in_waiting)

    D'ailleurs, sur un Pi (et sans doute plus âgés Pythons/pySerials) import serial ; print (serial.__version__) résultats dans un attribut d'erreur, mais fonctionne sur les versions plus récentes.

    OriginalL'auteur jaydublu2002

  4. 0

    J'ai écrit mon code comme ci-dessous. J'espère que vous pourrez l'utiliser modifier votre code

    import serial
import csv
import os
import time
import sys
import string
from threading import Timer
def main():
pass
if __name__ == '__main__':
main()
COUNT=0
f=open("test.csv","w+");
result = csv.writer(f,delimiter=',')
result_statement=("Dir","ACTUATOR_ON_OFF","MODE","DATE","TIME"," TRACKER DESIRED ANGLE"," TRACKER ACTUAL ANGLE")
result.writerow(result_statement)
f.close()
while COUNT<=100:
#while():
time.sleep(60)
ser=serial.Serial()
ser.port=12
ser.baudrate=9600
ser.open()
str=ser.read(150)
# print "string are:\n",str
print type(str)
val=str.split(":")
# print "value is:\n",val
lines=str.split("\r\n")
# print  "line statement are :\n",lines
COUNT=COUNT+1
print COUNT
f=open("test.csv","a+");
result = csv.writer(f,delimiter=',')
wst=[]
for line in lines[:-1]:
parts=line.split(":")
for p in parts[1:]:
wst.append(p)
#result = csv.writer(f,delimiter=',')
#wst.append(parts[1:])
print "wst:\n",wst
result.writerow(wst)
f.close()
f.close()
ser.close()
    Merci pour les commentaires Ajit, mais ton code ne marche malheureusement pas l'adresse de mon problème. Il vous suffit de s'attendre à 150 octets de données en série à être disponible avec ser.read(150) plutôt que de vérifier pour voir comment beaucoup (le cas échéant) est disponible. Quelques conseils supplémentaires, beaucoup de ce code peut être amélioré par plus de python (plus court, plus propre, plus rapide, plus facile à lire). Essayez d'utiliser le with mot-clé dans le jeu de f = open(), f.close(), et ser.close(). En outre, votre while COUNT<=100: doit être remplacé par un for i in xrange(100) ou for i in xrange(1, 101) si le zéro de l'indexation est un problème.

    OriginalL'auteur Ajit Nayak