def connect_serial(port, baudrate=115200, timeout=1, writeTimeout=1):
    """
    Return Serial object after making sure that the port is accessible and that the port is expressed as a string.

    :param port: str or int (ie "COM4" or 4 for Windows).
    :param baudrate: baudrate.
    :param timeout: read timeout in seconds, default 1 sec.
    :param writeTimeout: write timeout in seconds, default 1 sec.
    :return: serial port object.
    :rtype: serial.Serial
    """

    if isinstance(port, int):
        port = "COM{0}".format(port)
    names_list = list()
    for i in list_ports.comports():
        names_list.append(i[0])
    if port not in names_list:
        print ("Serial not found on {0}.".format(port))
        print ("Listing current serial ports with devices:")
        for ser in list_ports.comports():
            ser_str = "\t{0}: {1}".format(ser[0], ser[1])
            print ser_str
        time.sleep(0.01)  # just to let the above lines print before the exemption is raised. cleans console output.
        raise serial.SerialException("Requested COM port: {0} is not listed as connected.".format(port))
    else:
        return serial.Serial(port, baudrate=baudrate, timeout=timeout, writeTimeout=writeTimeout)

def locateport():
    """
    Function Name:  locateport()
    Input Args:     None
    Output:         port        The port at which the arduino is connected
    Description:    This function checks th OS it is running on and
    also identifies the com port the ARDUINO BOARD is connected to.
    And also returns the COM port the ARDUINO BOARD is connected.
    """
    port = ''
    if sys.platform.startswith('win'):      # For WINDOWS
        # port = ''
        ports = list(comports())
        for i in ports:
            for j in i:
                if 'Arduino' in j:
                    port = i[0]

    elif sys.platform.startswith('linux'):  # For LINUX
        b = []
        # port = ''
        ports = list(comports())
        for i in range(len(ports)):
            for x in range(7):
                portname = "/dev/ttyACM"+str(x)
                if ports[i][0] == portname:
                    b.append(ports[i][0])
        port = b[0]
    return port

	def comportRefresh(self, dbg=False):
		#Detect devices
		hwgrep = []
		for i in comports():
			if dbg:
				#Print list to console if requested
				comport = ''
				for j in i: comport+=j+"\t"
				print(comport)
			for hw in i[2].split(' '):
				hwgrep += ["hwgrep://"+hw+"\t"+i[1]]

		#Populate combobox
		devices = sorted([x[0]+"\t"+x[1] for x in comports()])
		devices += ['']
		devices += sorted(set(hwgrep))
		devices += ['']
		devices += sorted(["spy://"+x[0]+"?raw"+"\t(Debug) "+x[1] for x in comports()])
		devices += ['', 'socket://localhost:23', 'rfc2217://localhost:2217']

		#Clean neighbour duplicates
		devices_clean = []
		devprev = '';
		for i in devices:
			if i.split("\t")[0] != devprev: devices_clean += [i]
			devprev = i.split("\t")[0]

		self.portCombo.fill(devices_clean)

    def find_serial_port():
        """
        tries to connect to all available serial ports, returns of first successful connection.
        exit if none works

        :return: serial interface object
        """
        if settings.debug_port_detection:
            for port in list_ports.comports():
                print('trying {}'.format(port[0]))

            return serial.Serial(settings.forced_port, settings.baud_rate, timeout=1)

        else:
            for port in (list_ports.comports()):
                print('trying {}'.format(port[0]))
                try:
                    serial_interface = serial.Serial(port[0], settings.baud_rate, timeout=2)
                    sleep(2)  # wait for the device to be ready
                    # send hello command
                    serial_interface.write(settings.handshake_challenge)

                    # check if this device knows what to reply
                    reply = serial_interface.read(len(settings.handshake_response))
                    print(reply)
                    if reply == settings.handshake_response:
                        return serial_interface

                except serial.SerialException:
                    # print("opening serial failed")
                    pass

        raise ConnectionError("Couldn't connect to any serial ports, exiting...")

    def get_port(self):
        """Detect Buspirate and return first detected port
        
        Returns
        -------
        str
            First valid port name
        """
        try:
            import serial.tools.list_ports as list_ports
        except ImportError:
            raise ImportError('Pyserial version with serial.tools.list_port required')

        import serial

        # the API in version 2 and 3 is different
        if serial.VERSION[0] == '2':
            ports = list_ports.comports()
            for port in ports:
                if len(port) == 3 and '0403:6001' in port[2]:
                    return port[0]
                if len(port) == 3 and 'VID_0403+PID_6001' in port[2]:
                    return port[0]
        else:
            ports = list_ports.comports()
            for port in ports:
                if hasattr(port, 'pid') and hasattr(port, 'vid'):
                    if port.vid == 1027 and port.pid == 24577:
                        return port.device

def list_com_ports():
    port_list = list_ports.comports()    
    if port_list is not None and len(port_list) is not 0:
        print "Available Serial ports - "
        for port in list_ports.comports():
            print "\t"+port[0]
    else:
        print "No serial ports found by pySerial - you might be using cygwin where you can use /dev/ttySXX where XX = (nn-1) with nn being the COM port number (so COM11 is /dev/ttyS10)"

 def refresh(self):
     self.portComboBox.setStyleSheet('QComboBox {color: black;}')
     ports = list_ports.comports()
     if ports != self.ports:
         self.ports = ports
         self.portComboBox.clear()
         for port in list_ports.comports():
             name = port[0]
             if name.startswith('/dev/ttyACM') or name.startswith('/dev/ttyUSB') or name.startswith('COM'):
                 self.portComboBox.addItem(name)

 def refresh(self):
     self.portComboBox.setPalette(self.originalPalette)
     ports = list_ports.comports()
     if ports != self.ports:
         self.ports = ports
         self.portComboBox.clear()
         for port in list_ports.comports():
             name = port[0]
             if name.startswith('/dev/ttyACM') or name.startswith('/dev/ttyUSB') or name.startswith('COM'):
                 self.portComboBox.addItem(name)

def get_serial_ports():
    '''
    Returns a list object for all available serial ports
    '''
    if os.name == 'nt':
        # windows
        _comports = [port for port in list_ports.comports()]
        if _comports.__len__()>0:
            _serial_ports = ['\\\\.\\'+port[0] for port in list_ports.comports()]
        else:
            _serial_ports = []
    else:
        # unix
        _serial_ports = [port[0] for port in list_ports.comports()]
    return _serial_ports

def serial_ports():
    '''
    Returns a generator for all available serial ports
    '''
    if os.name == 'nt':
        # windows
        _comports = [port for port in list_ports.comports()]
        if _comports.__len__()>0:
            _serial_ports = [p for p in _comports[0]]
        else:
            _serial_ports = []
    else:
        # unix
        _serial_ports = [port[0] for port in list_ports.comports()]
    return _serial_ports

    def find_tty(self):
        for port in comports():
            print port
            if re.search(r'PID=2458:0*1', port[2]):
                return port[0]

        return None

    def scan_for_device(self):
        ports = [x[0] for x in list_ports.comports()]
        retport = None
        self._log("Searching for an active bootloader")

        for p in ports:
            try:
                rsp = self._send_ping(p)
                if not rsp == None:
                    ver = self._get_version(p)
                    if not ver:
                        version = '<=0.1.2'
                    else:
                        version = '.'.join(
                            [str(x) for x in
                             (ver.major, ver.minor, ver.bugfix)])
                    self._log("Found bootloader ver: {} on: {}".format(version, p))
                    retport = p
                    break
                else:
                    raise IOError()
            except IOError:
                pass

        return retport

def ask_for_port():
    """\
    Show a list of ports and ask the user for a choice. To make selection
    easier on systems with long device names, also allow the input of an
    index.
    """

    try:
        raw_input
    except NameError:
        raw_input = input   # in python3 it's "raw"
        unichr = chr

    sys.stderr.write('\n--- Available ports:\n')
    ports = []
    for n, (port, desc, hwid) in enumerate(sorted(comports()), 1):
        #~ sys.stderr.write('--- %-20s %s [%s]\n' % (port, desc, hwid))
        sys.stderr.write('--- {:2}: {:20} {}\n'.format(n, port, desc))
        ports.append(port)
    while True:
        port = raw_input('--- Enter port index or full name [1]: ') or 1
        try:
            index = int(port) - 1
            if not 0 <= index < len(ports):
                sys.stderr.write('--- Invalid index!\n')
                continue
        except ValueError:
            pass
        else:
            port = ports[index]
        return port

 def _port_search(self):
     print 'Automatically detecting COM ports.'
     ports = list(comports())
     print 'Detected %i ports.' % len(ports)
     port = ports[0][0]
     print 'Trying port ' + port + '.'
     return port

 def find_port(self):
     a = list(list_ports.comports())
     for portStruct in a:
         m = re.search('(/dev/cu\.usbmodem.*)', portStruct[0])
         if m:
             print "found port: ", m.group(0)
             return m.group(0)

 def scanComPort(self):
     port_list=list(list_ports.comports())
     num=len(port_list)
     #print 'num=', num
     for i in xrange(num):
         str=port_list[i][2].split('=')
         #print str
         if(str[0]=='USB VID:PID'):
             str=str[1].split(' ')[0] #Extract VID and PID from string.
             str=str.split(':')
             print str
             if(str[0] in usb_id):
                 if(str[1].lower() in usb_id[str[0]]):
                     port=port_list[i][0]
                     try:
                         __port = serial.Serial(port, baudrate=38400, bytesize=8, parity ='N', stopbits=1, xonxoff=False, dsrdtr=False, timeout=5)
                     except serial.SerialException, e:
                         print e.message
                         continue
                     time.sleep(0.5)
                     while(True):
                         num=__port.inWaiting()
                         if(num==0):
                             break
                         else:
                             print '-',
                         __port.flushInput()  #Clear input buffer.
                         time.sleep(0.1)
                     __port.close()
                     return port

 def __init__(self):
     wx.Dialog.__init__(
         self, None, title="DAQControl",
         style=(wx.STAY_ON_TOP | wx.CAPTION))
     self.horizontal_sizer = wx.BoxSizer(wx.HORIZONTAL)
     self.vertical_sizer = wx.BoxSizer(wx.VERTICAL)
     self.gauge = wx.Gauge(self, range=100, size=(100, 15))
     self.horizontal_sizer.Add(self.gauge, wx.EXPAND)
     avaiable_ports = list(comports())
     self.sample_list = []
     if len(avaiable_ports) != 0:
         for nombre in avaiable_ports:
             self.sample_list.append(nombre[0])
     self.label_hear = wx.StaticText(self, label="Select Serial Port")
     self.edit_hear = wx.ComboBox(
         self, size=(95, -1), choices=self.sample_list,
         style=wx.CB_READONLY)
     self.edit_hear.SetSelection(0)
     self.horizontal_sizer.Add(self.label_hear, wx.EXPAND)
     self.horizontal_sizer.Add(self.edit_hear, wx.EXPAND)
     self.button_ok = wx.Button(self, label="OK")
     self.Bind(wx.EVT_BUTTON, self.ok_event, self.button_ok)
     self.button_cancel = wx.Button(self, label="Cancel", pos=(115, 22))
     self.Bind(wx.EVT_BUTTON, self.cancel_event, self.button_cancel)
     self.vertical_sizer.Add(self.horizontal_sizer, wx.EXPAND)
     self.vertical_sizer.Add(self.button_ok, wx.EXPAND)
     self.gauge.Show(False)
     self.SetSizer(self.vertical_sizer)
     self.SetAutoLayout(1)
     self.vertical_sizer.Fit(self)

    def ListAllPorts():
        portsList = []
        allSerial = list_ports.comports()
        for ser in allSerial:
            portsList.append(ser[0])

        return portsList

def serial_ports():
    """
    Returns a generator for all available serial ports
    based on: http://stackoverflow.com/questions/12090503/listing-available-com-ports-with-python
    WARNING: works with pyserial>=2.7
    """

    ports = []
    if os.name == 'nt':
        # windows
        for i in range(256):
            try:
                s = serial.Serial(i)
                s.close()
                ports.append('COM' + str(i + 1))
            except serial.SerialException:
                pass
    else:
        # unix
        for port in list_ports.comports():
            if 'USB' in port[0] or 'ACM' in port[0]:
                # yield port[0]
                ports.append(port[0])

    return ports

 def list_serial_ports(self):
     try:
         ports = list(comports())
     except Exception, e:
         if comports != win32_comports_bruteforce:
             LOG.error("Failed to detect win32 serial ports: %s" % e)
             ports = win32_comports_bruteforce()