Plusieurs écritures dans le fichier

Question

J'ai le code python suivant qui attend des données provenant du port série, et l'écrit dans un fichier.

import time 
import serial 

def write_log (text): 
    f = open('logger.log', 'a') 
    f.write(text) 
    f.close() 

ser = serial.Serial() 
ser.port = "/dev/ttyS0" 
ser.baudrate = 4800 
ser.open() 
if ser.isOpen(): 
    while 1: 
     while ser.inWaiting() <= 0: 
      time.sleep(1) 
      response = ser.read(ser.inWaiting()) 
      if len (response): 
       write_log(response) 
       print response 

Il fonctionne dans une certaine mesure, comme après un certain temps, il commence à se bloquer, ce qui porte le CPU tout le chemin, et ne pas écrire quoi que ce soit (ou d'écrire parfois que des morceaux de texte) au fichier .log.

Le processus ici est assez intensif, car mon port série écrira une chaîne de 8 octets chaque seconde, et ce script python est censé le recevoir et écrire son contenu dans le fichier journal.

Je pense que le problème ici est le fait que j'ouvre et ferme trop le fichier, ce qui rend l'ensemble du processus lent. Je ne suis pas un python wizz, donc toute aide ou conseil sur l'amélioration de ce code serait grandement apprécié.

Merci à l'avance,

Answer 1

Je pense que le problème ici est que vous recherchez des mises à jour.

La fonction serial.read() de Python bloque en fait le thread courant jusqu'à ce que quelque chose devienne lisible sur le thread, jusqu'au timeout. Ce que vous devriez faire, par conséquent, est de sortir un autre thread pour gérer les E/S série. Avoir une boucle indéfiniment, vérifiant une condition (le thread principal veut que vous restiez à l'écoute et le port série est toujours disponible). Ce fil fera quelque chose comme:

while ser.isOpen() && thisthread_should_keep_doing_this: 
    response = ser.read(ser.inWaiting()) 
    if len(response): 
     write_log(response) 
     print response 

Ensuite, quand vous le voulez pour sortir, votre fil maître définit thisthread_should_keep_doing_this=False et quand votre thread esclave a terminé la lecture, il se tue.

Deux choses:

• ont le délai d'attente de lecture relativement fréquemment.
• Ne pas "tuer à distance" le fil. Passez-lui un message et faites-le se tuer. Tuer des fils à distance crée un désordre terrible.

Voir http://pyserial.sourceforge.net/examples.html#miniterm

Answer 2

Vous avez une boucle infinie dans votre code, et vous ne cassent pas de quand il y a un problème - ou le périphérique série n'est plus ouvert.

probablement utiliser:

while ser.isOpen(): 
    while ser.inWaiting() <= 0: 
     time.sleep(1) 
     response = ser.read(ser.inWaiting()) 
     if len(response): 
      write_log(response) 
      print response 

ou même:

while ser.isOpen() && ser.inWaiting() <= 0: 
    time.sleep(1) 
    response = ser.read(ser.inWaiting()) 
    if len(response): 
     write_log(response) 
     print response 

Je ne suis pas sûr du sommeil, que ce soit; vous feriez mieux d'attendre la lecture pour que les données deviennent disponibles. En y réfléchissant, ne sachant pas les méthodes disponibles dans la classe sérielle, plus je pense que la boucle principale devrait essayer de lire depuis le périphérique série, pendante heureusement s'il n'y a rien actuellement disponible, et ne s'arrêtant que lorsque la méthode d'entrée indique qu'il n'y a plus d'entrée à venir - l'appareil a été fermé sur vous, ou a échoué d'une manière ou d'une autre.