class NetworkClient:
"""A class for sending readings to a server"""
def __init__(self):
# Create an INET, STREAMing socket
self.cli_sock = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
# Connect to a remote socket at host and port
self.cli_sock.connect(('pi2' , 1234))
self.serial_conn = SerialConnection('/dev/ttyUSB0', 30)
self.serial_conn.open()
self.serial_conn.flush_input()
def send(self):
try:
while True:
data = self.serial_conn.read()
self.cli_sock.send(data)
except KeyboardInterrupt:
self.serial_conn.close()
self.cli_sock.close()
class Main: """A class for establishing connections""" def start_db_hdlr(self, db): self.db_hdlr = DatabaseHandler(db) self.db_hdlr.flush_rss_readings() self.db_hdlr.check_pos_tbl() self.db_hdlr.check_rsl_tbl() def start_net_srv(self): self.net_srv = NetworkServer() self.net_srv.start() def start_serial_conn(self, port, timeout): self.serial_conn = SerialConnection(port, timeout) self.serial_conn.open() self.serial_conn.flush_input() def start_trilat(self): self.trilat = Trilateration() self.trilat.start() def run(self): try: while True: data = self.serial_conn.read().strip() tag_id = data[:4] rss = data[4:] self.db_hdlr.ins_reading(2, tag_id, rss) except KeyboardInterrupt: self.db_hdlr.close_db() self.net_srv.stop() self.net_srv.join(60) self.trilat.stop() self.trilat.join(20) self.serial_conn.close()
command = 6 * [0]
command_lock = threading.Lock()
# global variables
mission_running = True
mission_mode = True
blocking = True
thread1 = None
thread2 = None
obj_detection = ObjectDetection()
# initializing serial connection with AUV_simulator
simulator_com = SerialConnection(port='com1', baud=115200)
simulator_com.start()
# wait for the first not empty message from AUV_simulator
while nav_status == None:
receive_nav_status()
# threads running
start_threads()
# wait for threads termination
wait_for_threads_termination()
# close serial connection with AUV_simulator
simulator_com.close()
class Recipe(object):
recipes = {}
recipe_types = {}
by_feed = {}
def __init__(self, type_, name, ingredients, mixit, icon):
global type_icons
if type_ not in type_icons:
raise UnknownRecipeTypeError()
if type_ not in Recipe.recipe_types:
Recipe.recipe_types[type_] = []
Recipe.recipe_types[type_].append(self)
self.type_ = type_
self.name = name
self.icon = icon
self.mixit = mixit
self.ingredients = []
self.dispensing = []
self.timeslice_secs = 1.0
self.min_dispense_secs = 0.1
self.last_timeslice = time.time()
self.last_update_time = time.time()
self.stepsforml = 136 # number of steps for 1 ml
Recipe.recipes[name] = self
for ingr_data in ingredients:
ingr = Ingredient.fromArray(ingr_data)
if ingr.feed not in Recipe.by_feed:
Recipe.by_feed[ingr.feed] = []
Recipe.by_feed[ingr.feed].append(self)
self.ingredients.append(ingr)
@classmethod
def fromDict(cls, d):
"""Create new Recipe instances from a dictionary description."""
global type_icons
if 'type_icons' in type_icons:
type_icons = d['type_icons']
# Delete old Recipes
for name, recipe in cls.recipes.items():
recipe.delete_recipe()
# Add Recipes from dict
for name, data in d.get('recipes', {}).items():
cls(
data['type'],
name,
data['ingredients'],
data['mixit'],
icon=data.get('icon'),
)
@classmethod
def toDictAll(cls, d, metric=True):
"""Create a dictionary description of all Recipe instances."""
global type_icons
d['recipes'] = {
name: recipe.toDict(metric=metric)
for name, recipe in cls.recipes.items()
}
d['type_icons'] = type_icons
return d
def toDict(self, metric=True):
data = {
'type': self.type_,
'ingredients':
[x.toArray(metric=metric) for x in self.ingredients],
'mixit': self.mixit,
}
if self.icon:
data['icon'] = self.icon
return data
@classmethod
def getTypeNames(cls):
return sorted(cls.recipe_types.keys())
@staticmethod
def getPossibleTypeNames():
global type_icons
return sorted(type_icons.keys())
@classmethod
def getTypeIcon(cls, name):
global type_icons
return type_icons[name]
@classmethod
def getRecipesByType(cls, name):
recipe_list = cls.recipe_types[name]
return sorted(recipe_list, key=operator.attrgetter('name'))
@classmethod
def getRecipesKeysByType(cls, name):
recipe_list = cls.recipe_types[name]
for key in sorted(cls.recipes.keys()):
if cls.getByName(name=key) in recipe_list:
yield cls.recipes[key]
@classmethod
def getRecipesByFeed(cls, feed):
if feed not in cls.by_feed:
return []
recipe_list = cls.by_feed[feed]
return sorted(recipe_list, key=operator.attrgetter('name'))
@classmethod
def getNames(cls):
return sorted(cls.recipes.keys())
@classmethod
def getAll(cls):
for key in sorted(cls.recipes.keys()):
yield cls.recipes[key]
@classmethod
def getByName(cls, name):
return cls.recipes[name]
def getName(self):
return self.name
def getType(self):
return self.type_
def getMixit(self):
return self.mixit
def getIcon(self):
return self.icon
def delete_recipe(self):
del Recipe.recipes[self.name]
Recipe.recipe_types[self.type_].remove(self)
if not Recipe.recipe_types[self.type_]:
del Recipe.recipe_types[self.type_]
for ingr in self.ingredients:
Recipe.by_feed[ingr.feed].remove(self)
if not Recipe.by_feed[ingr.feed]:
del Recipe.by_feed[ingr.feed]
def rename(self, newname):
del Recipe.recipes[self.name]
self.name = newname
Recipe.recipes[newname] = self
def retype(self, newtype):
global type_icons
if newtype not in type_icons:
raise UnknownRecipeTypeError()
if newtype not in Recipe.recipe_types:
Recipe.recipe_types[newtype] = []
Recipe.recipe_types[self.type_].remove(self)
if not Recipe.recipe_types[self.type_]:
del Recipe.recipe_types[self.type_]
self.type_ = newtype
Recipe.recipe_types[newtype].append(self)
def add_ingredient(self, feedname, ml):
feed = SupplyFeed.getByName(feedname)
if feed not in Recipe.by_feed:
Recipe.by_feed[feed] = []
Recipe.by_feed[feed].append(self)
self.ingredients.append(Ingredient(feed, ml))
return self
def canMake(self):
for ingr in self.ingredients:
if not ingr.feed.avail or ingr.feed.remaining <= 0:
return False
return True
def getAlcoholPercentByVolume(self):
vol = 0.0
alc_vol = 0.0
for ingr in self.ingredients:
ml = ingr.milliliters
vol += ml
alc_vol += ml * (ingr.feed.proof / 100.0)
return 100.0 * alc_vol / vol
def totalVolume(self):
vol = 0.0
for ingr in self.ingredients:
vol += ingr.milliliters
return vol
def startDispensing(self, volume):
stepsforml = self.stepsforml
tot_vol = self.totalVolume()
vol_mult = volume / tot_vol
self.dispensing = []
sercommand = ''
self.dispenselist = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0
]
logging.info("Dispensing: %s, %d ml" % (self.getName(), volume))
for ingr in self.ingredients:
ingr.milliliters = math.ceil(ingr.milliliters * vol_mult)
self.dispensing.append(DispensingIngredient(ingr, vol_mult))
for ingr in self.dispensing:
thisfeed = SupplyFeed.getByName(ingr.feed.name)
newremaining = thisfeed.feeds[
ingr.feed.name].remaining - ingr.milliliters
thisfeed.feeds[ingr.feed.name].remaining = newremaining
logging.debug("remaining neu fuer " + ingr.feed.name + ": " +
str(thisfeed.feeds[ingr.feed.name].remaining))
logging.info("Zutat " + ingr.feed.name + ": " +
str(ingr.milliliters) + " ml")
for pumpnumber in list(range(24)):
if ingr.feed.motor_num == pumpnumber:
self.dispenselist[pumpnumber] = int(
math.ceil(ingr.milliliters * self.stepsforml))
sercommand = (','.join(map(str, self.dispenselist))) + '\n'
try:
self.ser.readData()
except:
logging.debug("keine bestehende verbindung")
try:
self.ser = SerialConnection()
self.ser.readData()
logging.debug("habe verbindung")
except:
logging.debug("verbindung nicht moeglich")
hwa = HardwareAction(self.mixit)
hwa.do_dispensing(self.mixit)
self.ser.sendData(sercommand)
self.ser.close()
del self.ser
self.updateDispensing(self.mixit)
def updateDispensing(self, mixing=True):
ml_left = []
dispenselist = self.dispenselist
self.ser = SerialConnection()
ml_left = self.ser.readLine().split(",")
logging.debug(str(ml_left[0]))
if not "ok" in ml_left[0]:
for ingr in self.dispensing:
logging.debug(ingr.feed.name)
for pumpnumber in list(range(24)):
if ingr.feed.motor_num == pumpnumber:
if "Ready" in ml_left[0]:
ingr.dispensed = 0
else:
logging.debug("pumpnumber ", str(pumpnumber))
if int(ml_left[pumpnumber]) < 0:
ml_left[pumpnumber] = 0
ingr.dispensed = math.ceil(
(dispenselist[pumpnumber] -
int(ml_left[pumpnumber])) / self.stepsforml)
else:
self.ser.close()
del self.ser
hwa = HardwareAction(self.mixit)
hwa.end_dispensing(self.mixit)
self.dispensing[:] = [x for x in self.dispensing if not x.done()]
def cancelDispensing(self):
self.ser = SerialConnection()
self.ser.sendData('@')
self.ser.readLine()
self.ser.close()
del self.ser
logging.debug("Ausschenken abgebrochen")
for ingr in self.dispensing:
ingr.stopFeed()
self.dispensing[:] = [x for x in self.dispensing if not x.done()]
def doneDispensing(self):
return not self.dispensing
nav_status = build_nav_status(eta, ni, mission_mode)
mission_com.send1c(nav_status)
# executing this block of code if mission mode is active
if mission_mode:
button2.inactiveColour = GREEN
# receiving message from mission_manager
command = mission_com.getPacket()
if command != None:
command[0:3] = geo2ned(command[0:3])
eta_des = matrix(command[0:6]).T
else:
button2.inactiveColour = RED
# drawing all graphic elements
draw_elements(screen, image_1, image_2, image_3, eta, ni, tau)
textbox.draw()
button1.draw()
button2.draw()
# updating GUI screen
pg.display.update()
sleep(TS)
# closing UDP connection with Unity
unity_com.close()
# closing serial connection with mission manager
mission_com.close()
# closing pygame
pg.quit()
