Resets the serial device. Internally calls __send_break().

        :param method: Not used for DutSerial
        :return: Nothing
162867
def reset(self, method=None):
        
        self.logger.info('Reset serial device %s' % self.name)
        self.__send_break()
732031
def factory_reset(self, ids, except_ids=False, except_baudrate_and_ids=False):
        

        mode = (0x02 if except_baudrate_and_ids else
                0x01 if except_ids else 0xFF)

        for id in ids:
            try:
                self._send_packet(self._protocol.DxlResetPacket(id, mode))

            except (DxlTimeoutError, DxlCommunicationError):
                pass
798250
def _onMethodTimeout(self, serial, d):
        
        del self._pendingCalls[serial]
        d.errback(error.TimeOut('Method call timed out'))
984570
def remove(self, method: Method):
        
        self._table = [fld for fld in self._table if fld is not method]
152862
def _perform_reset(self, reset_type):
        """"""
        if reset_type is Target.ResetType.HW:
            self.session.probe.reset()
        elif reset_type is Target.ResetType.SW_EMULATED:
            self._perform_emulated_reset()
        else:
            if reset_type is Target.ResetType.SW_SYSRESETREQ:
                mask = CortexM.NVIC_AIRCR_SYSRESETREQ
            elif reset_type is Target.ResetType.SW_VECTRESET:
                mask = CortexM.NVIC_AIRCR_VECTRESET
            else:
                raise RuntimeError("internal error, unhandled reset type")
        
            try:
                self.write_memory(CortexM.NVIC_AIRCR, CortexM.NVIC_AIRCR_VECTKEY | mask)
                # Without a flush a transfer error can occur
                self.flush()
            except exceptions.TransferError:
                self.flush()
736056
def reset(self, mode=InputMode.INSERT):
        
        # Go back to insert mode.
        self.input_mode = mode

        self.waiting_for_digraph = False
        self.operator_func = None
        self.operator_arg = None
548244
def reset():
    
    global _handlers, python_signal
    for sig, (previous, _) in _handlers.iteritems():
        if not previous:
            previous = SIG_DFL
        python_signal.signal(sig, previous)
    _handlers = dict()
274635
def setBreak(self,breakFlag = True):
        
        if breakFlag:
            _parseMethod = self._parse
            def breaker(instring, loc, doActions=True, callPreParse=True):
                import pdb
                pdb.set_trace()
                _parseMethod( instring, loc, doActions, callPreParse )
            breaker._originalParseMethod = _parseMethod
            self._parse = breaker
        else:
            if hasattr(self._parse,"_originalParseMethod"):
                self._parse = self._parse._originalParseMethod
        return self
1227841
def send_reset(self):
        
        task = asyncio.ensure_future(self.core.send_reset())
        self.loop.run_until_complete(task)
1024851
def send(self, method, args={}, to=None, nowait=False, **kwargs):
        

        if to is None:
            to = self.routing_key
        r = self.call_or_cast(method, args, routing_key=to,
                              nowait=nowait, **kwargs)
        if not nowait:
            return r.get()
607853
def reset(self):
        
        super(SinonSpy, self).unwrap()
        super(SinonSpy, self).wrap2spy()
143642
def _serial_close(self, port):
        '''
        
        '''
        if port in self.open_devices:
            try:
                self.open_devices[port].close()
            except Exception as exception:
                logger.error('Error closing device `%s`: %s', port, exception)
                return
        else:
            logger.debug('Device not connected to `%s`', port)
            self._publish_status(port)
            return
1275452
def Reset(self):
        '  '
        spi.SPI_write(self.CS, [0xC0, 0x60])      # reset
#        spi.SPI_write(self.CS, [0x14, 0x14])      # Stall Treshold setup
#        spi.SPI_write(self.CS, [0xFF, 0xFF])  
#        spi.SPI_write(self.CS, [0x13, 0x13])      # Over Current Treshold setup 
#        spi.SPI_write(self.CS, [0xFF, 0xFF])  
        spi.SPI_write(self.CS, [0x15, 0xFF])      # Full Step speed 
        spi.SPI_write(self.CS, [0xFF, 0xFF])
        spi.SPI_write(self.CS, [0xFF, 0xFF]) 
        spi.SPI_write(self.CS, [0x05, 0x05])      # ACC 
        spi.SPI_write(self.CS, [0x01, 0x01])
        spi.SPI_write(self.CS, [0xF5, 0xF5]) 
        spi.SPI_write(self.CS, [0x06, 0x06])      # DEC 
        spi.SPI_write(self.CS, [0x01, 0x01])
        spi.SPI_write(self.CS, [0xF5, 0xF5]) 
        spi.SPI_write(self.CS, [0x0A, 0x0A])      # KVAL_RUN
        spi.SPI_write(self.CS, [0x10, 0x10])
        spi.SPI_write(self.CS, [0x0B, 0x0B])      # KVAL_ACC
        spi.SPI_write(self.CS, [0x20, 0x20])
        spi.SPI_write(self.CS, [0x0C, 0x0C])      # KVAL_DEC
        spi.SPI_write(self.CS, [0x20, 0x20])
        spi.SPI_write(self.CS, [0x18, 0x18])      # CONFIG
        spi.SPI_write(self.CS, [0b00111000, 0b00111000])
        spi.SPI_write(self.CS, [0b00000000, 0b00000000])
37463
def reset_object(self, driver_wrapper=None):
        
        if driver_wrapper:
            self.driver_wrapper = driver_wrapper
        self.app_strings = self.driver_wrapper.app_strings  #: mobile application strings
        for element in self._get_page_elements():
            element.reset_object(driver_wrapper)
83889
def ipmi_method(self, command):       
        
        ipmi = ipmitool(self.console, self.password, self.username)
        
        if command == "reboot":
            self.ipmi_method(command="status")
            if self.output == "Chassis Power is off":
                command = "on"
        
        ipmi.execute(self.ipmi_map[command])
        
        if ipmi.status:
            self.error = ipmi.error.strip()
        else:
            self.output = ipmi.output.strip()        
        self.status = ipmi.status
1200995
def reset(self):
        '''
        
        '''
        t = self
        while t._output is not None:
            t = t._output
        while t is not None:
            if t._pop and t._pop.returncode is None:
                t._pop.kill()
                t._pop.wait()
            del t._pop
            t._pop = None
            t = t._input
        return self
557084
def serial_disconnect(self):
		
		if self._serial_connected:
			try:
				self.serial_connection.close()
			except c1218.errors.C1218IOError as error:
				self.logger.error('caught C1218IOError: ' + str(error))
			except serial.serialutil.SerialException as error:
				self.logger.error('caught SerialException: ' + str(error))
			self._serial_connected = False
			self.logger.warning('the serial interface has been disconnected')
		return True