Send a Reset command to set the operation mode to 0.
425882
def reset_mode(self):
        """"""
        self.command(0x18, b"\x01", timeout=0.1)
        self.transport.write(Chipset.ACK)
        time.sleep(0.010)
1191445
def reset(self):
        '''
        '''
        for index in range(self.counts_len):
            self.counts[index] = 0
        self.total_count = 0
        self.min_value = sys.maxsize
        self.max_value = 0
        self.start_time_stamp_msec = sys.maxsize
        self.end_time_stamp_msec = 0
655141
def reset(self):
        
        self._monitor.notify_received()
        self._pinger.stop()
        self._mark_fresh()
1087884
def reset_bunch_counter(self):
        '''
        '''
        logging.info('')
        commands = []
        commands.extend(self.register.get_commands("RunMode"))
        commands.extend(self.register.get_commands("BCR"))
        self.send_commands(commands)
        time.sleep(0.1)
        commands = []
        commands.extend(self.register.get_commands("ConfMode"))
        self.send_commands(commands)
778107
async def _reset_vector(self):
        """"""

        # Send ourselves all of our config variable assignments
        config_rpcs = self.config_database.stream_matching(8, self.name)
        for rpc in config_rpcs:
            await self._device.emulator.await_rpc(*rpc)

        config_assignments = self.latch_config_variables()
        self._logger.info("Latched config variables at reset for controller: %s", config_assignments)

        for system in self._post_config_subsystems:
            try:
                system.clear_to_reset(config_assignments)
                await asyncio.wait_for(system.initialize(), timeout=2.0)
            except:
                self._logger.exception("Error initializing %s", system)
                raise

        self._logger.info("Finished clearing controller to reset condition")

        # Now reset all of the tiles
        for address, _ in self._device.iter_tiles(include_controller=False):
            self._logger.info("Sending reset signal to tile at address %d", address)

            try:
                await self._device.emulator.await_rpc(address, rpcs.RESET)
            except TileNotFoundError:
                pass
            except:
                self._logger.exception("Error sending reset signal to tile at address %d", address)
                raise

        self.initialized.set()
584926
def reset():
    
    if hasattr(ray.worker.global_worker, "signal_counters"):
        ray.worker.global_worker.signal_counters = defaultdict(lambda: b"0")
953130
def set_operation_mode(self, mode):
        
        if mode == "off":
            desired_state = {"powered": False}
        else:
            desired_state = {"powered": True, "mode": mode}

        response = self.api_interface.set_device_state(self, {
            "desired_state": desired_state
        })

        self._update_state_from_response(response)
655069
async def async_set_operation_mode(
            self, operation_mode: OperationMode, password: str = '') -> None:
        

        await self._protocol.async_execute(
            SetOpModeCommand(operation_mode),
            password=password)
816978
def do_mode(self, args):
        ''''''
        if args.mode:
            mode = { 'idle': self.task_master.IDLE,
                     'run': self.task_master.RUN,
                     'terminate': self.task_master.TERMINATE }[args.mode]
            self.task_master.set_mode(mode)
            self.stdout.write('set mode to {0!r}\n'.format(args.mode))
        else:
            mode = self.task_master.get_mode()
            self.stdout.write('{0!s}\n'.format(mode))
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()
1092414
def _reset(self):
        
        self.commands = []
        self.watching = False
        self._watched_keys = {}
        self.explicit_transaction = False
883716
def set_default_command(self, command):
        """"""
        cmd_name = command.name
        self.add_command(command)
        self.default_cmd_name = cmd_name
98035
def set_off(self):
        """"""
        try:
            request = requests.post(
                '{}/{}/{}/'.format(self.resource, URI, self._mac),
                data={'action': 'off'}, timeout=self.timeout)
            if request.status_code == 200:
                pass
        except requests.exceptions.ConnectionError:
            raise exceptions.MyStromConnectionError()
771472
def _reset_state(self):
        
        self._builders = {}
        self._total_data_size = 0
        self._progress_offset = 0
        self._current_progress_fraction = 0
98632
def _reset_state_mode(self, state, mode):
        

        state.set_mode(mode)
        state.options |= self._state_add_options
        state.options = state.options.difference(self._state_remove_options)
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
960510
def _reset(self):
        
        # Analog pin 0
        self.hw.remote_at(
            dest_addr=self.remote_addr,
            command='D0',
            parameter='\x02')

        # Disengage remote LED, buzzer
        self.deactivate()
        self._set_send_samples(False)