Python Twisted receive command from TCP write to Serial device return response
Question: I've managed to connect to usb modem and a client can connect via tcp to my
reactor.listenTCP,the data received from modem will be send back to client.
I'm want to take dataReceived from client and send this to modem..I'm
struggling to get this to work.Any help will be highly appreciated! the code:

    
    
    from twisted.internet import win32eventreactor
    win32eventreactor.install()
    from twisted.internet import reactor
    from twisted.internet.serialport import SerialPort
    from twisted.internet.protocol import Protocol, Factory
    from twisted.python import log
    import sys
    
    log.startLogging(sys.stdout)
    client_list = []#TCP clients connecting to me
    
    class USBClient(Protocol):
    
        def connectionFailed(self):
            print "Connection Failed:", self
            reactor.stop()
    
        def connectionMade(self):
            print 'Connected to USB modem'
            USBClient.sendLine(self, 'AT\r\n')
    
        def dataReceived(self, data):
            print "Data received", repr(data)
            print "Data received! with %d bytes!" % len(data)
            #check & perhaps modify response and return to client
            for cli in client_list:
                cli.notifyClient(data)
            pass
    
        def lineReceived(self, line):
            print "Line received", repr(line)
    
        def sendLine(self, cmd):
            print cmd
            self.transport.write(cmd + "\r\n")
    
        def outReceived(self, data):
            print "outReceived! with %d bytes!" % len(data)
            self.data = self.data + data
    
    class CommandRx(Protocol):
    
        def connectionMade(self):
            print 'Connection received from tcp..'
            client_list.append(self)
    
        def dataReceived(self, data):
            print 'Command receive', repr(data)
            #Build command, if ok, send to serial port
            #????
        def connectionLost(self, reason):
            print 'Connection lost', reason
            if self in client_list:
                print "Removing " + str(self)
                client_list.remove(self)
    
        def notifyClient(self, data):
            self.transport.write(data)
    
    class CommandRxFactory(Factory):
        protocol = CommandRx
        def __init__(self):
            client_list = []
    
    if __name__ == '__main__':
        reactor.listenTCP(8000, CommandRxFactory())
        SerialPort(USBClient(), 'COM8', reactor, baudrate='19200')
        reactor.run()
    


Answer: Your problem is not about twisted, but about python. Read this FAQ entry:

> [_How do I make input on one connection result in output on
> another?_](http://twistedmatrix.com/trac/wiki/FrequentlyAskedQuestions#HowdoImakeinputononeconnectionresultinoutputonanother)

Thing is, if you want to send stuff to a TCP-connected client in your serial-
connected protocol, just pass to the protocol a reference to the factory, so
you can use that reference to make the bridge.

Here's some example code that roughly does this:

    
    
    class USBClient(Protocol):
        def __init__(self, network):
            self.network = network
        def dataReceived(self, data):
            print "Data received", repr(data)
            #check & perhaps modify response and return to client
            self.network.notifyAll(data)
        #...    
    
    class CommandRx(Protocol):
        def connectionMade(self):
            self.factory.client_list.append(self)
        def connectionLost(self, reason):
            if self in self.factory.client_list:
                self.factory.client_list.remove(self)
    
    class CommandRxFactory(Factory):
        protocol = CommandRx
        def __init__(self):
            self.client_list = []
    
        def notifyAll(self, data):
            for cli in self.client_list:
                cli.transport.write(data)
    

When initializing, pass the reference:

    
    
    tcpfactory = CommandRxFactory()
    reactor.listenTCP(8000, tcpfactory)
    SerialPort(USBClient(tcpfactory), 'COM8', reactor, baudrate='19200')
    reactor.run()
    

