LOGGER.Debug("Initializing sensor serial handler...")
sensorSerialHandler = SerialHandler(CONSTANTS.SENSOR_BOARD_PORT)
sensorSerialHandler.initSerial()
val = ""
val = sensorHandler.getSensorValues()
LOGGER.Debug(val)
if CONSTANTS.USING_MOTOR_BOARD:
LOGGER.Debug("Initializing motor serial handler...")
motorSerialHandler = SerialHandler(CONSTANTS.MOTOR_BOARD_PORT)
motorSerialHandler.initSerial()
if CONSTANTS.USING_NETWORK_COMM:
networkClient = NetworkClient(CONSTANTS.CONTROL_STATION_IP,
CONSTANTS.CONTROL_STATION_PORT)
inboundMessageQueue = MessageQueue()
networkClient.setInboundMessageQueue(inboundMessageQueue)
outboundMessageQueue = MessageQueue()
lastReceivedMessageNumber = -1
currentReceivedMessageNumber = -1
stateStartTime = -1
# initialize motors
LOGGER.Debug("Initializing motor objects...")
leftMotor = Motor("LeftMotor", 1, MOTOR_MODES.K_PERCENT_VBUS)
rightMotor = Motor("RightMotor", 2, MOTOR_MODES.K_PERCENT_VBUS)
#initialize sensors
LOGGER.Debug("Initializing sensorobjects...")
#initialize servos
def __init__(self, name=None):
super(Actor, self).__init__(name)
self._messageQueue = MessageQueue()
self._connections = {}
self._connectionsLock = threading.RLock()
from MessageQueue import MessageQueue
from OdooConnector import OdooConnector
from time import sleep
from requests.exceptions import ConnectionError
import logging
if __name__ == '__main__':
logging.basicConfig(
filename='../auth.log',
level=logging.DEBUG,
format="[%(filename)s:%(lineno)s - %(funcName)s ] %(message)s")
while True:
try:
queue = MessageQueue()
auth_details, id = queue.get_message()
if auth_details is not None and id is not None:
username = auth_details['username']
password = auth_details['password']
auth = OdooConnector()
is_authenticated = auth.authenticate(username, password)
logging.debug("Authentication result for %s: %s" %
(username, is_authenticated))
if is_authenticated is False:
success = 'false'
role = 'None'
else:
success = 'true'
role = auth.get_user_role(is_authenticated)
response = {
class Actor(ServiceThread):
def __init__(self, name=None):
super(Actor, self).__init__(name)
self._messageQueue = MessageQueue()
self._connections = {}
self._connectionsLock = threading.RLock()
@classmethod
def start(cls, *args, **kwargs):
actor = cls(*args, **kwargs)
actor._start()
return actor
def _start(self):
super(Actor, self).start()
def _reset(self):
self._messageQueue.drain()
self.onReset()
def _ready(self):
self.onReady()
def _connectTo(self, actor):
with self._connectionsLock:
if actor not in self._connections:
# print '{} connected to {}'.format(type(self), type(actor))
self._connections[actor] = actor.createConnection()
def _disconnectedFrom(self, actor):
with self._connectionsLock:
if actor in self._connections:
del self._connections[actor]
def createConnection(self):
return Connection(self._messageQueue)
def proxy(self):
return ActorProxy(self, Connection(self._messageQueue))
def sendMessage(self, actor, message, priority=MessagePriority.Normal):
with self._connectionsLock:
if actor in self._connections:
connection = self._connections[actor]
connection.sendMessage(message, priority)
def broadcast(self, message, priority=MessagePriority.Normal, target=None):
with self._connectionsLock:
for actor, connection in list(self._connections.items()):
if target is None or target == actor.__class__:
connection.sendMessage(message, priority)
def loop(self):
# handle pending messages
if not self._messageQueue.empty():
message = self._messageQueue.dequeue()
self._handleMessage(message)
# allow subclasses to implement their own actions
self.act()
def _handleMessage(self, message):
# check whether it's actor message
event = message.getEvent()
if issubclass(event, ActorEvent):
result = self._handleActorEvent(event, message.getData())
else:
result = self.handleMessage(message)
message.setResult(result)
def _handleActorEvent(self, event, data):
if event == ActorReset:
self._reset()
elif event == ActorReady:
self._ready()
def handleMessage(self, message):
pass
def act(self):
pass
def onReset(self):
pass
def onReady(self):
pass