ThreadSerialOutput.py

# -*- coding: utf-8 -*-
##########################################################################
##                          PYTHON SOURCES                              ##
##########################################################################

#   ___|  _)  | _)       _)                         ___|
# \___ \   |  |  |   __|  |  |   |  __ `__ \       |       _ \    __|  __ \
#       |  |  |  |  (     |  |   |  |   |   |      |      (   |  |     |   |
# _____/  _| _| _| \___| _| \__,_| _|  _|  _|     \____| \___/  _|     .__/
#                                                                     _|
#Code source libre de droit. Si vous utilisez mon code, merci à vous d'en préciser la source.

#@Date : 03/11/2011
#@Auteur : Silicium Corp

import serial
import time
from threading import Thread
import Queue

class ThreadSerialOutput(Thread):                                       #Class de gestion d'un thread de reception de données sur le port série
    isActif = False                                                     #permet de savoir si le thread est actif
    protocoleSerie = 0                                                  #initialise la variable qui va contenir le protocole serie
    shareStack = 0
#===============================================================
    def __init__(self, stackToShare, serialProtocol) :                  #Constructeur du thread : attend un objet de type Queue() et un autre de type serial.Seial()
        try :
            self.shareStack = stackToShare                              #Récupération de l'instance de la stack (Output Serial Stack)
            self.protocoleSerie = serialProtocol                        #Récupération de l'instance de la session Serial
            Thread.__init__(self)                                       #Appel du construsteur propre à l'objet Thread
        except BaseException as err :
            print("Erreur lors de la creation du thread :\n!!! %s !!!"%err)
#===============================================================
    def run (self):                                                     #méthode principale de l'objet Thread() Contenu executer lors de l'appel à thread.start()
        self.isActif = True                                             #On définie le boolean isActif à true
        actualByte = 0
        while self.isActif :                                            #Tans que le boolean isActif est à true
            actualByte = self.protocoleSerie.read()                     #Si vous oubliez de definir le timeOut de lecture du protocole série, cette fonction sera blocante
            try :
                if actualByte != "" :
                    self.shareStack.put(actualByte,True,5)              #On enregistre l'octet reçu si celui ci différent de "rien"...
                                                                        #...si une donnée est reçue mais que le thread ne parvient pas a en faire la saisi pendant + de 5 secondes, la stack est considérée pleine
                    self.shareStack.task_done()                         #Chaque fin de timeOut précédent on indique au systeme que la tache de saisi dans la stack et pour l'instant terminée
                time.sleep(0.001)                                       #Si vous définissez le timeOut du protocole série à 0, permet au thread de ne pas prendre 100% d'un cpu
            except :
                print("Stack pleine")
                pass
#===============================================================
    def kill (self):                                                    #Permet d'eteindre le thread
        self.isActif = False                                            #Grace au timeout de la fonction self.shareStack.get(True, 5) on s'assure une vérification de l'etat self.isActif toutes les 5 secondes
#===============================================================
    def getIsActif (self):
        return (self.isActif)                                           #Renvoie l'etat de l'activité du thread
#===============================================================
    def __del__(self) :
        print ("- Thread Killed -")                                     #Indique juste que le thread est en fin de vie et que son destructeur a bien été appelé
#===================================================================
#====================    MAIN PRINCIPAL ============================
#===================================================================
if __name__ == "__main__":
    print ("== Main ThreadSerialOutput==\n")                            #Début du programme (permet de savoir qui à lancé le programme) joue le role de Main par defaut.
    protocoleSerie = serial.Serial()                                    #Initialisation du protocole Série
    protocoleSerie.baudrate = 9600                                      #Initialisation de la vitesse du protocole 9600 BPS (Bauds per seconds)
    protocoleSerie.port = 2                                             #Initialisation du port usb/serie utilisé (2 = COM3)
    protocoleSerie.timeout = 0                                          #Permet de rendre non bloquante la lecture du port série.
    stack = Queue.LifoQueue(32)                                         #Initialisation de la pile de reception, (Output Serial Stack) en mode LIFO (Last In, First Out) pour garder les elements dans l'ordre

    thrd = ThreadSerialOutput(stack, protocoleSerie)                    #On envoie la stack et le protocole série à la déclaration du thread

    try :
        protocoleSerie.open()                                           #Ouverture du dialogue série
        thrd.start()                                                    #On active le thread
        for i in range(15) :                                            #Micro test : On attend à 15 reprises pendant 10 secondes la lecture de donnée dans notre stack (Output Serial Stack)
            try :
                print("Data =>%s<="%stack.get(True,10))                 #Si un delai de 10 secondes s'ecoule sans recevoir de data, on le signal
            except :
                print("no data")
                pass
        thrd.kill()                                                     #Pour mettre fin au thread
        stack.join()                                                    #On s'assure que la stack n'a pas encore quelques actions à finir

    except BaseException as err:
        print("*** Erreur lors de la connexion serie :\n!!! %s !!!"%err)