示例#1
0
 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()]
示例#2
0
    def __init__(self, master, amount, turns, pumpcount=1):
        super(CleanScreen, self).__init__(master)
        self.master = master
        self.last_disp = 0.0
        self.pumpnumber = 0
        self.turn = 0
        self.amount = amount
        self.turns = turns
        self.pumpcount = pumpcount
        self.stopCleaning = False
        self.desc = Text(self, relief=FLAT, wrap=NONE, state=DISABLED)
        backbtn = RectButton(self,
                             text="Abbruch",
                             command=self.handle_button_back)
        self.bgcolor = master.bgcolor
        self.configure(bg=self.bgcolor)

        self.desc.grid(column=0, row=0, sticky=N + E + W + S)
        backbtn.grid(column=0, row=1, padx=10, pady=10, sticky=E + W + S)

        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(0, weight=1)
        try:
            self.ser.readData()
        except:
            try:
                self.ser = SerialConnection()
                self.ser.readData()
            except:
                logging.debug("Verbindung nicht moeglich")
        self.next_Pump()
示例#3
0
 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()]
示例#4
0
 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 __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()
示例#6
0
    def __init__(self, master, recipe, amount):
        super(DispensingScreen, self).__init__(master)
        self.master = master
        self.ser = SerialConnection()
        self.recipe = recipe
        self.last_disp = 0.0
        self.desc = Text(self, relief=FLAT, wrap=NONE, state=DISABLED)
        backbtn = RectButton(self, text="Abbruch", command=self.handle_button_back)
        self.bgcolor = master.bgcolor
        self.configure(bg=self.bgcolor)

        self.desc.grid(column=0, row=0, sticky=N+E+W+S)
        backbtn.grid(column=0, row=1, padx=10, pady=10, sticky=E+W+S)

        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(0, weight=1)
        recipe.startDispensing(amount)
        self.pid = self.after(UPDATE_MS, self.update_screen)
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()
示例#8
0
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()
示例#9
0
nav_status_lock = threading.Lock()

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()
示例#10
0
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
示例#11
0
control_mode = False
mission_mode = False

#--------------------------------------------------------------------------------#
# inizializing UDP connection with Unity
HOST_IP = 'localhost'
HOST_PORT_UDP = 29000
UDP_IP = 'localhost'
UDP_PORT = 25000

unity_com = CustomUDP(HOST_IP, HOST_PORT_UDP, UDP_IP, UDP_PORT)
unity_com.start()

# inizializing connection with mission_manager
mission_com = SerialConnection(port='com2', baud=115200)
mission_com.start()

# inizializing pygame
pg.init()

# creation GUI screen
pg.display.set_caption('Zeno GUI')
screen = pg.display.set_mode(SCREEN_DIM)

# creation of stylised images of the AUV (top, side and back view)
# note: images are square and image width is equal to dial diameter
image_width = 2 * DIAL_R

image_1 = create_view('images/zeno_top.bmp', image_width)  # top view
image_2 = create_view('images/zeno_side.bmp', image_width)  # side view
示例#12
0
from serial_connection import SerialConnection
import signal


def new_packet(incoming_queue):
    packet = incoming_queue.get()
    print(packet)
    incoming_queue.task_done()


def exit_handler(signal, frame):
    print("Exit called")
    con.stop()


con = SerialConnection('/dev/pts/2', 19200, new_packet, "ACK\n")
items = ["esimene", "teine", "kolmas", "neljas"]

con.start()

for i in items:
    con.write(i)

print("items added to write queue")

# register exit handler
signal.signal(signal.SIGINT, exit_handler)
示例#13
0
	def start_serial_conn(self, port, timeout): 
		self.serial_conn = SerialConnection(port, timeout)
		self.serial_conn.open()
		self.serial_conn.flush_input()
示例#14
0
class CleanScreen(Frame):
    def __init__(self, master, amount, turns, pumpcount=1):
        super(CleanScreen, self).__init__(master)
        self.master = master
        self.last_disp = 0.0
        self.pumpnumber = 0
        self.turn = 0
        self.amount = amount
        self.turns = turns
        self.pumpcount = pumpcount
        self.stopCleaning = False
        self.desc = Text(self, relief=FLAT, wrap=NONE, state=DISABLED)
        backbtn = RectButton(self,
                             text="Abbruch",
                             command=self.handle_button_back)
        self.bgcolor = master.bgcolor
        self.configure(bg=self.bgcolor)

        self.desc.grid(column=0, row=0, sticky=N + E + W + S)
        backbtn.grid(column=0, row=1, padx=10, pady=10, sticky=E + W + S)

        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(0, weight=1)
        try:
            self.ser.readData()
        except:
            try:
                self.ser = SerialConnection()
                self.ser.readData()
            except:
                logging.debug("Verbindung nicht moeglich")
        self.next_Pump()

    def next_Pump(self):
        sercommand = ''
        self.pid = None
        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
        ]
        for currentpump in range(self.pumpnumber,
                                 (self.pumpnumber + self.pumpcount)):
            if currentpump < 24:
                self.dispenselist[currentpump] = 136 * self.amount
        sercommand = (','.join(map(str, self.dispenselist))) + '\n'
        print(sercommand)
        self.pumpnumber += self.pumpcount - 1
        self.ser.sendData(sercommand)
        if self.pumpnumber >= 23:
            self.pumpnumber = 0
            self.turn += 1
        else:
            self.pumpnumber += +1
        if self.turn >= self.turns:
            self.stopCleaning = True
            self.master.screen_pop_to_top()
        self.pid = self.after(UPDATE_MS, self.update_screen)

    def update_screen(self):
        self.pid = None
        if not self.stopCleaning:
            serout = ''
            serout = str(self.ser.readLine())
            if bool(re.search(r'ok', serout)):
                logging.debug("ok gefunden")
                self.next_Pump()
            else:
                try:
                    bool(re.search(r'\d+,\d+', serout))
                    ml_left = serout.split(",")
                    logging.debug("pumpnumber " + str(self.pumpnumber))
                    self.desc.config(state=NORMAL)
                    self.desc.delete(0.0, END)
                    self.desc.tag_config("header",
                                         background="#077",
                                         foreground="white")
                    self.desc.tag_config("pumpnumber",
                                         lmargin1=10,
                                         lmargin2=20)
                    self.desc.tag_config("left", foreground="#c44")
                    self.desc.insert(END, "Cleaning Pump: ", "header")
                    self.desc.insert(
                        END,
                        str(
                            list(
                                range((self.pumpnumber - self.pumpcount),
                                      self.pumpnumber))), "pumpnumber")
                    self.desc.insert(
                        END, " left %.0f ml\n" % math.ceil(
                            int(ml_left[self.pumpnumber - self.pumpcount]) /
                            136), 'left')
                    self.desc.config(state=DISABLED)
                except ValueError:
                    print("That's not an int!")
                self.master.update()
                self.pid = self.after(UPDATE_MS, self.update_screen)

    def handle_button_back(self):
        if self.pid != None:
            self.after_cancel(self.pid)
        self.turn = 5
        self.stopCleaning = True
        self.master.screen_pop()

    def hasNumbers(inputString):
        return any(char.isdigit() for char in inputString)