def render_GET(self, request):
if('v' in request.args and 'r' in request.args):
r=int(request.args['r'][0])
v=int(request.args['v'][0])
if(r>0 and r<9 and (v==0 or v==1)):
msk=1<<(r-1)
if (v==1):cmd=0x11
if (v==0):cmd=0x12
data=packet(cmd,msk,0x00,0x00)
SerialPort.write(port,data)
print ">"+pk2str(data)
else:
print "r or v out of range"
else:
print "r or v missing"
request.setHeader("content-type", "application/json")
return ">"+pk2str(data)
def render_GET(self, request):
if ('v' in request.args and 'r' in request.args):
r = int(request.args['r'][0])
v = int(request.args['v'][0])
if (r > 0 and r < 9 and (v == 0 or v == 1)):
msk = 1 << (r - 1)
if (v == 1): cmd = 0x11
if (v == 0): cmd = 0x12
data = packet(cmd, msk, 0x00, 0x00)
SerialPort.write(port, data)
print ">" + pk2str(data)
else:
print "r or v out of range"
else:
print "r or v missing"
request.setHeader("content-type", "application/json")
return json.dumps([Relay, Sensor])
def writeMessage(self, message):
print "Writing message: " + message
writeData = HexToByte(message)
global ser
try:
ser.write(writeData)
except:
try:
ser = SerialPort(serproto, "/dev/ttyUSB0", reactor, 19200)
ser.write(writeData)
except:
raise
self.bytesWritten += len(writeData)
self.messageWritten = message
self.timer = threading.Timer(4.0, self.timeout)
self.timer.start()
self.d = defer.Deferred()
return self.d
class Radio(object):
def connect(self, port):
self.serial = SerialPort(RadioReceiverProtocol(self), port, reactor, baudrate=57600)
self.serial.flushInput()
def __init__(self):
self.listeners = []
self.serial = None
def send(self, packet):
data = array.array('B', packet.encode()).tostring()
print 'tx:', packet
if self.serial is not None:
self.serial.write(data)
def gotPacket(self, packet):
print 'rx:', packet
for l in self.listeners:
l(packet)
class SerialConnection(Connection):
#: Connection settings
port = Unicode('/dev/ttyUSB0').tag(config=True)
ports = List()
baudrate = Int(115200).tag(config=True)
#: Actual connection
serial_port = Instance(SerialPort)
def is_available(self):
self.ports = comports()
self.name = self._default_name()
return bool(self.ports)
def _default_name(self):
for port in self.ports:
if port.device == self.port:
return str(port)
return self.port
@observe('port')
def _refresh_name(self, change):
self.name = self._default_name()
def connect(self, protocol):
d = Deferred()
def do_connect():
try:
self.serial_port = SerialPort(protocol,
self.port,
reactor,
baudrate=self.baudrate)
d.callback(True)
log.debug("{} connected!".format(self.port))
except Exception as e:
d.callback(e)
deferred_call(do_connect)
return d
def write(self, message):
if self.serial_port is None:
return 0
return self.serial_port.write(message)
def disconnect(self):
""" """
s = self.serial_port
if s:
log.debug("{} disconnected!".format(self.port))
s.loseConnection()
self.serial_port = None
def serial_init(port='/dev/ttyUSB0', baudrate=115200):
logging.debug('About to open port {0}'.format(port))
s = SerialPort(EchoProtocol(port, 1000), port, reactor, baudrate=baudrate)
s.write('\r\nHello ...\r\n'.encode('utf8'))
class Sparki(object):
##
#
#
def __init__(self, port):
self._sensor_observers = {
'range': [None],
'accelerometer': [None],
'error': [self._message_error],
'overflow': [self._overflow_error]
}
self._sensor_codes = {
'r': 'range',
'a': 'accelerometer',
'e': 'error',
'o': 'overflow'
}
self._port = port
self._protocol = SparkiProtocol()
self._protocol.setLineCallback(self._handleMessage)
self._ser = SerialPort(self._protocol,
self._port,
reactor,
baudrate=9600)
self._reactor_thread = Thread(target=reactor.run, args=(False, ))
self._reactor_thread.daemon = True
self._reactor_thread.start()
##
#
#
def shutdown(self):
reactor.stop()
##
#
#
def send(self, message):
try:
self._ser.write(message)
except:
raise
##
#
#
def sendMotorVO(self, lin_vel, ang_vel):
message = "U V " + str(lin_vel) + " " + str(ang_vel) + "\n"
self.send(message)
##
#
#
def addSensorCallback(self, sensor, callback):
self._sensor_observers[sensor].append(callback)
##
#
#
def _handleMessage(self, data):
output = data.split()
for observer in self._sensor_observers[self._sensor_codes[output[0]]]:
if observer is not None:
observer(output[1:])
##
#
#
def _message_error(self):
print "Submitted bad serial message to Sparki"
##
#
#
def _overflow_error(self):
print "Sparki receive buffer overflow"
def render_GET(self, request):
data=packet(0x18,0x00,0x00,0x00)
SerialPort.write(port,data)
request.setHeader("content-type", "application/json")
request.setHeader("Cache-Control", "no-cache")
return json.dumps([Relay,Sensor])
class SerialNodesController(object):
def __init__(self, oNodeControl):
self._NodeControl = oNodeControl
# TODO generic alert state dictionary
self._PIR1Alerting = False
self._PIR2Alerting = False
self._ResetState = 10
self._LDRLightStateValue = 400
if self._NodeControl.nodeProps.has_option('ldr-reporting',
'state-value'):
self._LDRLightStateValue = self._NodeControl.nodeProps.getint(
'ldr-reporting', 'state-value')
# list all serial ports: python -m serial.tools.list_ports
self._connectSerialPort()
def _connectSerialPort(self):
self.Close()
myProtocol = SerialNodesProtocol(self._NodeControl,
OnReceive=self.OnMsgReceive)
self._serialPort = SerialPort(myProtocol,
self._NodeControl.nodeProps.get(
'serialnodes', 'serialport'),
reactor,
baudrate=9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE)
sleep(1)
def OnMsgReceive(self, RecMsg):
myNodeID = self._NodeControl.nodeProps.get('system', 'nodeId')
if str(RecMsg.ToAdress) == myNodeID:
# for this node
if int(RecMsg.Function) == 1:
# PIR alert garage
if not self._PIR1Alerting:
self._PIR1Alerting = True
self._NodeControl.MQTTPublish(sTopic="garage/pirevent",
sValue="ON",
iQOS=0,
bRetain=False)
reactor.callLater(self._ResetState,
self.ResetPIR1State,
topic="garage/pirevent")
elif int(RecMsg.Function) == 2:
# PIR alert Werkkamer
if not self._PIR2Alerting:
self._PIR2Alerting = True
self._NodeControl.MQTTPublish(sTopic="werkkamer/pirevent",
sValue="ON",
iQOS=0,
bRetain=False)
reactor.callLater(self._ResetState,
self.ResetPIR2State,
topic="werkkamer/pirevent")
elif int(RecMsg.Function) == 3:
# LDR garage
if int(RecMsg.MsgValue) > self._LDRLightStateValue:
self._NodeControl.MQTTPublish(sTopic="garage/ldrevent",
sValue="ON",
iQOS=0,
bRetain=False)
elif int(RecMsg.MsgValue) < self._LDRLightStateValue:
self._NodeControl.MQTTPublish(sTopic="garage/ldrevent",
sValue="OFF",
iQOS=0,
bRetain=False)
elif int(RecMsg.Function) == 4:
# LDR Garage zolder
if int(RecMsg.MsgValue) > self._LDRLightStateValue:
self._NodeControl.MQTTPublish(
sTopic="garagezolder/ldrevent",
sValue="ON",
iQOS=0,
bRetain=False)
elif int(RecMsg.MsgValue) < self._LDRLightStateValue:
self._NodeControl.MQTTPublish(
sTopic="garagezolder/ldrevent",
sValue="OFF",
iQOS=0,
bRetain=False)
def ResetPIR1State(self, topic):
self._PIR1Alerting = False
self._NodeControl.MQTTPublish(sTopic="garage/pirevent",
sValue="OFF",
iQOS=0,
bRetain=False)
def ResetPIR2State(self, topic):
self._PIR2Alerting = False
self._NodeControl.MQTTPublish(sTopic="werkkamer/pirevent",
sValue="OFF",
iQOS=0,
bRetain=False)
def SendMessage(self, sSerialMessage):
try:
self._serialPort.write(sSerialMessage)
sleep(0.1)
return True
except Exception, exp:
print traceback.format_exc()
self._NodeControl.log.error("SendMessage error: %s." %
traceback.format_exc())
return False
class SerialNodesController(object):
def __init__(self, oNodeControl):
self._NodeControl = oNodeControl
self._AfterPIREvent = None
self._ResetState = 10
# list all serial ports: python -m serial.tools.list_ports
self._connectSerialPort()
l = task.LoopingCall(self.eCheckLights)
l.start(300)
def _connectSerialPort(self):
self.Close()
myProtocol = SerialNodesProtocol(self._NodeControl,
OnReceive=self.OnMsgReceive)
self._serialPort = SerialPort(myProtocol,
self._NodeControl.nodeProps.get(
'serialnodes', 'serialport'),
reactor,
baudrate=9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE)
sleep(1)
def eCheckLights(self):
if self._AfterPIREvent is None:
self.setNormalState()
def OnMsgReceive(self, RecMsg):
myNodeID = '112' # self._NodeControl.nodeProps.get('system', 'nodeId')
if str(RecMsg.ToAdress) == myNodeID:
# for this node
if int(RecMsg.Function) == 1:
# PIR alert
if self._AfterPIREvent is None:
self._NodeControl.MQTTPublish(sTopic="overloop/pirevent",
sValue="ON",
iQOS=0,
bRetain=False)
reactor.callLater(self._ResetState,
self.ResetState,
topic="overloop/pirevent")
if ARMED:
RGBColors.sendEffectScheme(self, self._NodeControl,
752, RGBColors.EFFECT_ALERT)
elif astro_functions.isDusk(self._NodeControl):
RGBColors.sendEffectScheme(
self, self._NodeControl, 752,
RGBColors.EFFECT_SILENT_NIGHT_WAVE)
else:
RGBColors.sendRGBValue(self, self._NodeControl, 752,
RGBColors.FRIENDLYHELLO)
self._AfterPIREvent = reactor.callLater(
10, self.afterPIREvent)
def afterPIREvent(self):
reactor.callFromThread(self.switchToNoneAlertState)
def ResetState(self, topic):
self._NodeControl.MQTTPublish(sTopic=topic,
sValue="OFF",
iQOS=0,
bRetain=False)
def switchToNoneAlertState(self):
self._AfterPIREvent = None
self._connectSerialPort()
self.setNormalState()
def setNormalState(self):
if astro_functions.isDusk(self._NodeControl):
self._NodeControl.log.debug('Dusk: setting quit nights lights')
RGBColors.sendColorScheme(self, self._NodeControl, 752,
RGBColors.COLORSCHEME_QUITNIGHT_01)
else:
self._NodeControl.log.debug('Daytime: switch lights off')
RGBColors.sendRGBValue(self, self._NodeControl, 752,
RGBColors.ALLOFF)
def SendMessage(self, sSerialMessage):
try:
self._serialPort.write(sSerialMessage)
sleep(0.1)
return True
except Exception, exp:
print traceback.format_exc()
self._NodeControl.log.error("SendMessage error: %s." %
traceback.format_exc())
return False
class SerialNodesController(object):
def __init__(self, oNodeControl):
self._NodeControl = oNodeControl
# list all serial ports: python -m serial.tools.list_ports
self._ResetState = 10
self._connectSerialPort()
def _connectSerialPort(self):
self.Close()
myProtocol = SerialNodesProtocol(self._NodeControl,
OnReceive=self.OnMsgReceive)
self._serialPort = SerialPort(myProtocol,
self._NodeControl.nodeProps.get(
'serialnodes', 'serialport'),
reactor,
baudrate=9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE)
self._NodeControl.log.debug(
'Serial port: %s open.' %
self._NodeControl.nodeProps.get('serialnodes', 'serialport'))
sleep(1)
def OnMsgReceive(self, RecMsg):
myNodeID = '999' # self._NodeControl.nodeProps.get('system', 'nodeId')
if str(RecMsg.ToAdress) == myNodeID:
# for this node
if ((int(RecMsg.Function) == 1) and (int(RecMsg.MsgValue) == 1)):
self._NodeControl.log.debug("Deuropen signal (keypad)")
self.doOpenDoor()
self._NodeControl.MQTTPublish(sTopic="deur/keyopen",
sValue="ON",
iQOS=0,
bRetain=False)
reactor.callLater(self._ResetState,
self.ResetState,
topic="deur/keyopen")
elif ((int(RecMsg.Function) == 2) and (int(RecMsg.MsgValue) == 1)):
self._NodeControl.log.debug("Deuropen signal (RFID)")
self.doOpenDoor()
self._NodeControl.MQTTPublish(sTopic="deur/rfidopen",
sValue="ON",
iQOS=0,
bRetain=False)
reactor.callLater(self._ResetState,
self.ResetState,
topic="deur/rfidopen")
elif ((int(RecMsg.Function) == 3) and (int(RecMsg.MsgValue) == 1)):
self._NodeControl.log.debug("Deurbel signal.")
self._NodeControl.MQTTPublish(sTopic="deur/ring",
sValue="ON",
iQOS=0,
bRetain=False)
reactor.callLater(self._ResetState,
self.ResetState,
topic="deur/ring")
elif ((int(RecMsg.Function) == 4) and (int(RecMsg.MsgValue) == 1)):
self._NodeControl.log.debug("Tampering Keypad")
self._NodeControl.MQTTPublish(sTopic="tampering/keypad",
sValue="ON",
iQOS=0,
bRetain=False)
elif ((int(RecMsg.Function) == 4) and (int(RecMsg.MsgValue) == 0)):
reactor.callLater(self._ResetState,
self.ResetState,
topic="tampering/keypad")
def ResetState(self, topic):
self._NodeControl.MQTTPublish(sTopic=topic,
sValue="OFF",
iQOS=0,
bRetain=False)
def SendMessage(self, sSerialMessage):
try:
self._serialPort.write(sSerialMessage)
sleep(0.1)
return True
except Exception as exp:
print(traceback.format_exc())
self._NodeControl.log.error("SendMessage error: %s." %
traceback.format_exc())
return False
def Close(self):
try:
self._serialPort.loseConnection()
self._serialPort = None
except:
pass
def doOpenDoor(self):
if self._NodeControl.nodeProps.has_option('dooropener', 'active') and\
self._NodeControl.nodeProps.getboolean('dooropener', 'active'):
idoorUnlockTime = 5
if self._NodeControl.nodeProps.has_option('dooropener',
'unlockTime'):
idoorUnlockTime = float(
self._NodeControl.nodeProps.get('dooropener',
'unlockTime'))
self._NodeControl.log.debug("Door opening")
wiringpi.digitalWrite(17, 1)
self._NodeControl.log.debug("Door opening done")
reactor.callLater(idoorUnlockTime, self.releaseDoorLockEvent)
def releaseDoorLockEvent(self):
self._NodeControl.log.debug("releaseDoorLockEvent")
wiringpi.digitalWrite(17, 0)
self._NodeControl.log.debug("Deur GPIO 17 off")
class WAMP_Component(ApplicationSession):
"""
RPi WAMP application component.
"""
# The Queue-Object is an threadsafe FIFO Buffer.
# Operations like put and get are atomic
# this queue holds all incomming complete Frames
frameInBuffer = Queue(50)
# this queue holds the ordered config requests
antwortQueue = Queue(50)
# what ist deque? = double-ended queue. it's a thread-safe ringbuffer
# this deque holds the errors as string
logQueue = deque([], 200)
# hier werden die messungen gespeichert
messCSVDictList = []
messCSVDictList_lock = threading.Lock()
# to ensure that we have a thead-safe write function, we need that look
serialWrite_lock = threading.Lock()
isSerialConnected = False
# GSV-6CPU RX bufferoverflow prevention
actTime = None
lastTime = datetime.now()
# ready falg
sys_ready = False
# cleanup here
def onLeave(self, details):
try:
self.serialPort.stopReading()
except Exception:
pass
try:
self.serialPort.reactor.stop()
except Exception:
pass
if self.router.isAlive():
self.router.stop()
# wait max 1 Sec.
self.router.join(1.0)
@inlineCallbacks
def onJoin(self, details):
port = self.config.extra['port']
baudrate = self.config.extra['baudrate']
# install signal handler
signal.signal(signal.SIGINT, self.signal_handler)
signal.signal(signal.SIGTERM, self.signal_handler)
self.toWAMP_logger = Log_WAMP_Handler(self, self.logQueue)
self.toWAMP_logger.addFilter(NoHTTP_GetFilter())
logging.getLogger('serial2ws').addHandler(self.toWAMP_logger)
# first of all, register the getErrors Function
yield self.register(self.getLog, u"de.me_systeme.gsv.getLog")
yield self.register(self.getIsSerialConnected, u"de.me_systeme.gsv.getIsSerialConnected")
# create an router object/thread
self.router = FrameRouter(self, self.frameInBuffer, self.antwortQueue)
# create GSV6 Serial-Protocol-Object
serialProtocol = GSV_6Protocol(self, self.frameInBuffer, self.antwortQueue)
logging.getLogger('serial2ws.WAMP_Component').debug(
'About to open serial port {0} [{1} baud] ..'.format(port, baudrate))
# try to init Serial-Connection
try:
self.serialPort = SerialPort(serialProtocol, port, reactor, baudrate=baudrate)
self.isSerialConnected = True
except Exception as e:
logging.getLogger('serial2ws.WAMP_Component').critical('Could not open serial port: {0}. exit!'.format(e))
os.kill(os.getpid(), signal.SIGTERM)
else:
# when erial-init okay -> start FrameRouter
self.router.start()
def __exit__(self):
logging.getLogger('serial2ws.WAMP_Component').trace('Exit.')
def __del__(self):
logging.getLogger('serial2ws.WAMP_Component').trace('del.')
def getLog(self):
return list(self.logQueue)
sendCounter = 0
def writeAntwort(self, data, functionName, args=None):
# okay this function have to be atomic
# we protect it with a lock!
self.serialWrite_lock.acquire()
self.actTime = datetime.now()
diffTime = self.actTime - self.lastTime
if diffTime.days <= 0 and diffTime.seconds <= 2:
if (diffTime.seconds == 0 and diffTime.microseconds < 4000):
self.sendCounter += 1
if self.sendCounter >= 8:
self.sendCounter = 0
logging.getLogger('serial2ws.WAMP_Component').debug(
"serialWait, prevent GSV-6CPU RX Buffer overflow")
sleep(0.2) # Time in seconds
else:
self.sendCounter = 0
try:
self.antwortQueue.put_nowait({functionName: args})
self.serialPort.write(str(data))
logging.getLogger('serial2ws.WAMP_Component').debug(
'[serialWrite] Data: ' + ' '.join(format(z, '02x') for z in data))
except NameError:
logging.getLogger('serial2ws.WAMP_Component').debug('[WAMP_Component] serialport not openend')
finally:
self.lastTime = datetime.now()
self.serialWrite_lock.release()
def write(self, data):
# okay this function have to be atomic
# we protect it with a lock!
self.serialWrite_lock.acquire()
try:
self.serialPort.write(str(data))
logging.getLogger('serial2ws.WAMP_Component').debug(
'[serialWrite] Data: ' + ' '.join(format(z, '02x') for z in data))
except NameError:
logging.getLogger('serial2ws.WAMP_Component').debug('serialport not openend')
finally:
self.serialWrite_lock.release()
def getIsSerialConnected(self):
return self.isSerialConnected
def lostSerialConnection(self, errorMessage):
logging.getLogger('serial2ws.WAMP_Component').critical("Lost SerialConnection: " + errorMessage)
self.isSerialConnected = False
# not implemented at web-frontend
self.publish(u"de.me_systeme.gsv.onSystemGoingDown")
# shut down app
os.kill(os.getpid(), signal.SIGTERM)
def signal_handler(self, signal, frame):
if signal == 15:
self.stopMeasurement()
logger = logging.getLogger('serial2ws')
logger.removeHandler(self.toWAMP_logger)
logger.info('received SIGNAL, going down.')
self.disconnect()
def stopMeasurement(self):
data = self.router.gsv6.buildStopTransmission()
logging.getLogger('serial2ws.WAMP_Component').warning('Sending stop Message to GSV-Modul')
self.write(data)
self.router.writeCSVdata()
class IridiumSimulator(Thread):
def __init__(self, comPort, moIP, moPort, mtPort, delay):
Thread.__init__(self)
self.udpMavlink = mavlink.MAVLink(0)
self.serialMavlink = mavlink.MAVLink(0)
self.udpRx = []
self.serialRx = None
self.ipLock = Lock()
self.serialLock = Lock()
self.ipTransport = None
self.status = SatcomStatus.idle
self.serialTime = 0
self.delay = delay
self.terminate = False
# serial interface to PX4
self.serialInterface = SerialPort(PX4UartInterface(self.receivedPX4), comPort, reactor, baudrate = 115200)
self.serialInterface.flushInput()
self.serialInterface.flushOutput()
# enpoint for sending MO messages from PX to the relay
self.relayMoEndpoint = TCP4ClientEndpoint(reactor, moIP, moPort)
# enpoint receiving MT messages coming from the relay
self.relayMtEndpoint = TCP4ServerEndpoint(reactor, mtPort)
self.relayMtEndpoint.listen(relay.IridiumMtReceiverFactory(self.receivedRelay))
def run(self):
while not self.terminate:
self.serialLock.acquire()
if self.serialTime + self.delay <= time():
if self.status == SatcomStatus.sending:
self.sendMsgToPX4(0x01, chr(0x00))
self.ipLock.acquire()
# prepare and send an iridium message
try:
m = self.udpMavlink.decode(self.serialRx[8:])
if m is not None:
msgId = m.get_msgId()
print '<-- PX4 {0} ({1})'.format(mavlink.mavlink_map[msgId].name, msgId)
except Exception as e:
print '<-- PX4 ' + str(e)
moMsgData = self.prepareMoMessage(self.serialRx)
prot = relay.IridiumMoSender(moMsgData)
connectProtocol(self.relayMoEndpoint, prot)
self.ipLock.release()
#print 'SEND RQ: complete'
self.status = SatcomStatus.idle
elif self.status == SatcomStatus.receiving:
if len(self.udpRx) != 0:
self.ipLock.acquire()
msg = self.udpRx.pop(0)
try:
m = self.udpMavlink.decode(msg)
except Exception as e:
print e
m = None
if m is not None:
msgId = m.get_msgId()
print 'QGC --> {0} ({1})'.format(mavlink.mavlink_map[msgId].name, msgId)
self.sendMsgToPX4(0x02, chr(0x00) + msg)
else:
self.sendMsgToPX4(0x02, chr(0x2F)) # no msg
self.ipLock.release()
#print 'RCV RQ: complete'
else:
self.sendMsgToPX4(0x02, chr(0x2F)) # no msg
#print 'RCV RQ: no msg'
self.status = SatcomStatus.idle
self.serialLock.release()
sleep(0.1)
def receivedPX4(self, msg):
# send msg
if msg.id == 0x01:
self.satcomSendRequest(msg.data)
# retrieve msg
if msg.id == 0x02:
self.satcomReceiveRequest()
# check network status
if msg.id == 0x05:
self.satcomGetNetworkStatus()
# check signal strength
if msg.id == 0x06:
self.satcomGetSignalStrength()
def receivedRelay(self, msg):
# print 'MT MSG CALLBACK'
for ie in msg.ieList:
# print 'IE: {0}: {1}'.format(ie.id, ie.name)
if ie.name == 'MT Payload IE':
# print ie.payload
try:
#m = self.udpMavlink.decode(ie.payload)
#if m is not None:
# print 'MT mavlink msg ID {0}'.format(m.get_msgId())
self.ipLock.acquire()
self.udpRx.append(ie.payload)
self.ipLock.release()
except:
pass
def prepareMoMessage(self, mavlinkMsg):
msg = iridium.IridiumMessage()
header = iridium.MoHeaderIe()
header.autoId = 123
header.imei = bytearray([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE])
header.sessionStatus = iridium.MoHeaderIe.SessionStatus.SUCCESSFUL
header.momsn = 1
header.mtmsn = 2
header.timeOfSession = 100000
header.prepareRaw()
msg.ieList.append(header)
payload = iridium.MoPayloadIe()
payload.payload = mavlinkMsg
payload.prepareRaw()
msg.ieList.append(payload)
msg.prepareRaw()
return msg.rawData
def satcomSendRequest(self, msgData):
self.serialLock.acquire()
if self.status == SatcomStatus.idle:
#print 'SEND RQ: pending'
self.status = SatcomStatus.sending
self.serialTime = time()
scsHeader = bytearray()
packetLen = len(msgData) + 8
scsHeader.append(packetLen / 256)
scsHeader.append(packetLen % 256)
scsHeader.append(2) # PX4 packet
scsHeader += bytearray(5) # 5 empty bytes - only used when sending images
self.serialRx = scsHeader + msgData
else:
print 'SEND RQ: busy <<<<<<<<<<<<<<<<<<<<<<<' # THIS SHOULD NOT HAPPEN - PX4 SATCOM DRIVER SHOULD WAIT FOR PREVIOUS COMMAND REPLY
self.sendMsgToPX4(0x01, chr(0x01))
self.serialLock.release()
def satcomReceiveRequest(self):
self.serialLock.acquire()
if self.status == SatcomStatus.idle:
#print 'RCV RQ: pending'
self.status = SatcomStatus.receiving
self.serialTime = time()
else:
print 'RCV RQ: busy <<<<<<<<<<<<<<<<<<<<<<<' # THIS SHOULD NOT HAPPEN - PX4 SATCOM DRIVER SHOULD WAIT FOR PREVIOUS COMMAND REPLY
self.sendMsgToPX4(0x02, chr(0x01))
self.serialLock.release()
def satcomGetNetworkStatus(self):
self.serialLock.acquire()
self.sendMsgToPX4(0x05, chr(0x00) + chr(0x01))
self.serialLock.release()
def satcomGetSignalStrength(self):
self.serialLock.acquire()
self.sendMsgToPX4(0x06, chr(0x00) + chr(0x05))
self.serialLock.release()
def sendMsgToPX4(self, id, data):
msg = [0x5B, 0, 0, 0]
msg[1] = (id)
msg[2] = (len(data)/256)
msg[3] = (len(data)%256)
msg += data
data = bytes(bytearray(msg))
self.serialInterface.write(data)
class WAMP_Component(ApplicationSession):
"""
RPi WAMP application component.
"""
# The Queue-Object is an threadsafe FIFO Buffer.
# Operations like put and get are atomic
# this queue holds all incomming complete Frames
frameInBuffer = Queue(50)
# this queue holds the ordered config requests
antwortQueue = Queue(50)
# what ist deque? = double-ended queue. it's a thread-safe ringbuffer
# this deque holds the errors as string
logQueue = deque([], 200)
# hier werden die messungen gespeichert
messCSVDictList = []
messCSVDictList_lock = threading.Lock()
# to ensure that we have a thead-safe write function, we need that look
serialWrite_lock = threading.Lock()
isSerialConnected = False
# GSV-6CPU RX bufferoverflow prevention
actTime = None
lastTime = datetime.now()
# ready falg
sys_ready = False
# cleanup here
def onLeave(self, details):
try:
self.serialPort.stopReading()
except Exception:
pass
try:
self.serialPort.reactor.stop()
except Exception:
pass
if self.router.isAlive():
self.router.stop()
# wait max 1 Sec.
self.router.join(1.0)
@inlineCallbacks
def onJoin(self, details):
port = self.config.extra['port']
baudrate = self.config.extra['baudrate']
# install signal handler
signal.signal(signal.SIGINT, self.signal_handler)
signal.signal(signal.SIGTERM, self.signal_handler)
self.toWAMP_logger = Log_WAMP_Handler(self, self.logQueue)
self.toWAMP_logger.addFilter(NoHTTP_GetFilter())
logging.getLogger('serial2ws').addHandler(self.toWAMP_logger)
# first of all, register the getErrors Function
yield self.register(self.getLog, u"de.me_systeme.gsv.getLog")
yield self.register(self.getIsSerialConnected,
u"de.me_systeme.gsv.getIsSerialConnected")
# create an router object/thread
self.router = FrameRouter(self, self.frameInBuffer, self.antwortQueue)
# create GSV6 Serial-Protocol-Object
serialProtocol = GSV_6Protocol(self, self.frameInBuffer,
self.antwortQueue)
logging.getLogger('serial2ws.WAMP_Component').debug(
'About to open serial port {0} [{1} baud] ..'.format(
port, baudrate))
# try to init Serial-Connection
try:
self.serialPort = SerialPort(serialProtocol,
port,
reactor,
baudrate=baudrate)
self.isSerialConnected = True
except Exception as e:
logging.getLogger('serial2ws.WAMP_Component').critical(
'Could not open serial port: {0}. exit!'.format(e))
os.kill(os.getpid(), signal.SIGTERM)
else:
# when erial-init okay -> start FrameRouter
self.router.start()
def __exit__(self):
logging.getLogger('serial2ws.WAMP_Component').trace('Exit.')
def __del__(self):
logging.getLogger('serial2ws.WAMP_Component').trace('del.')
def getLog(self):
return list(self.logQueue)
sendCounter = 0
def writeAntwort(self, data, functionName, args=None):
# okay this function have to be atomic
# we protect it with a lock!
self.serialWrite_lock.acquire()
self.actTime = datetime.now()
diffTime = self.actTime - self.lastTime
if diffTime.days <= 0 and diffTime.seconds <= 2:
if (diffTime.seconds == 0 and diffTime.microseconds < 4000):
self.sendCounter += 1
if self.sendCounter >= 8:
self.sendCounter = 0
logging.getLogger('serial2ws.WAMP_Component').debug(
"serialWait, prevent GSV-6CPU RX Buffer overflow")
sleep(0.2) # Time in seconds
else:
self.sendCounter = 0
try:
self.antwortQueue.put_nowait({functionName: args})
self.serialPort.write(str(data))
logging.getLogger('serial2ws.WAMP_Component').debug(
'[serialWrite] Data: ' +
' '.join(format(z, '02x') for z in data))
except NameError:
logging.getLogger('serial2ws.WAMP_Component').debug(
'[WAMP_Component] serialport not openend')
finally:
self.lastTime = datetime.now()
self.serialWrite_lock.release()
def write(self, data):
# okay this function have to be atomic
# we protect it with a lock!
self.serialWrite_lock.acquire()
try:
self.serialPort.write(str(data))
logging.getLogger('serial2ws.WAMP_Component').debug(
'[serialWrite] Data: ' +
' '.join(format(z, '02x') for z in data))
except NameError:
logging.getLogger('serial2ws.WAMP_Component').debug(
'serialport not openend')
finally:
self.serialWrite_lock.release()
def getIsSerialConnected(self):
return self.isSerialConnected
def lostSerialConnection(self, errorMessage):
logging.getLogger('serial2ws.WAMP_Component').critical(
"Lost SerialConnection: " + errorMessage)
self.isSerialConnected = False
# not implemented at web-frontend
self.publish(u"de.me_systeme.gsv.onSystemGoingDown")
# shut down app
os.kill(os.getpid(), signal.SIGTERM)
def signal_handler(self, signal, frame):
if signal == 15:
self.stopMeasurement()
logger = logging.getLogger('serial2ws')
logger.removeHandler(self.toWAMP_logger)
logger.info('received SIGNAL, going down.')
self.disconnect()
def stopMeasurement(self):
data = self.router.gsv6.buildStopTransmission()
logging.getLogger('serial2ws.WAMP_Component').warning(
'Sending stop Message to GSV-Modul')
self.write(data)
self.router.writeCSVdata()
def render_GET(self, request):
data = packet(0x18, 0x00, 0x00, 0x00)
SerialPort.write(port, data)
request.setHeader("content-type", "application/json")
request.setHeader("Cache-Control", "no-cache")
return json.dumps([Relay, Sensor])