Disable Firmata reporting for an analog pin.

        :param command: {"method": "disable_analog_reporting", "params": [PIN]}
        :returns: No return message..
164554
async def disable_analog_reporting(self, command):
        
        pin = int(command[0])
        await self.core.disable_analog_reporting(pin)
142726
def disable(name, **kwargs):
    '''
    
    '''
    levels = []
    if 'runlevels' in kwargs:
        requested_levels = set(kwargs['runlevels'] if isinstance(kwargs['runlevels'],
                                                                 list) else [kwargs['runlevels']])
        levels = _disable_delta(name, requested_levels)
        if not levels:
            return True
    cmd = _enable_disable_cmd(name, 'delete', levels)
    return not _ret_code(cmd)
1247756
async def stop(self):
        """"""
        await self._command_task.future_command(['_set_mode', 0, 0])  # Disable advertising
        await self._cleanup_old_connections()

        self._command_task.stop()
        self._stream.stop()
        self._serial_port.close()

        await super(BLED112Server, self).stop()
1221011
def off(device):
    '''
    
    '''
    cmd = 'quotaoff {0}'.format(device)
    __salt__['cmd.run'](cmd, python_shell=False)
    return True
630100
async def enable_analog_reporting(self, command):
        
        pin = int(command[0])
        await self.core.enable_analog_reporting(pin)
197196
def _send_command(self, command, raw_text=False):
        
        return self.device.show(command, raw_text=raw_text)
388024
def enqueue_command(self, command, data):
        
        if command == CommandType.TrialEnd or (command == CommandType.ReportMetricData and data['type'] == 'PERIODICAL'):
            self.assessor_command_queue.put((command, data))
        else:
            self.default_command_queue.put((command, data))

        qsize = self.default_command_queue.qsize()
        if qsize >= QUEUE_LEN_WARNING_MARK:
            _logger.warning('default queue length: %d', qsize)

        qsize = self.assessor_command_queue.qsize()
        if qsize >= QUEUE_LEN_WARNING_MARK:
            _logger.warning('assessor queue length: %d', qsize)
367722
public void ENsetreport( String command ) throws EpanetException {
        int err = epanet.ENsetreport(command);
        checkError(err);
    }
697486
def delete_command(endpoint_id, rule_id):
    
    client = get_client()

    res = client.delete_endpoint_acl_rule(endpoint_id, rule_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
87519
def _format_capability_report(self, data):
        

        if self.log_output:
            return

        else:
            pin_modes = {0: 'Digital_Input', 1: 'Digital_Output',
                         2: 'Analog', 3: 'PWM', 4: 'Servo',
                         5: 'Shift', 6: 'I2C', 7: 'One Wire',
                         8: 'Stepper', 9: 'Encoder'}
            x = 0
            pin = 0

            print('\nCapability Report')
            print('-----------------\n')
            while x < len(data):
                # get index of next end marker
                print('{} {}{}'.format('Pin', str(pin), ':'))
                while data[x] != 127:
                    mode_str = ""
                    pin_mode = pin_modes.get(data[x])
                    mode_str += str(pin_mode)
                    x += 1
                    bits = data[x]
                    print('{:>5}{}{} {}'.format('  ', mode_str, ':', bits))
                    x += 1
                x += 1
                pin += 1
1101408
def __apf_cmd(cmd):
    '''
    
    '''
    apf_cmd = '{0} {1}'.format(salt.utils.path.which('apf'), cmd)
    out = __salt__['cmd.run_all'](apf_cmd)

    if out['retcode'] != 0:
        if not out['stderr']:
            msg = out['stdout']
        else:
            msg = out['stderr']
        raise CommandExecutionError(
            'apf failed: {0}'.format(msg)
        )
    return out['stdout']
996479
void noZeroOrOneOrAddress(String command) {
    if (isZeroCommand || isOneCommand) {
      throwException(CMD + command + " (zero|one) should not be specified");
    }
    if (isAddressCommand) {
      throwException(CMD + command + " address should not be specified");
    }
  }
573639
def command(self, cmd, *args):
        
        self._serial_interface.command(cmd)
        if len(args) > 0:
            self._serial_interface.data(list(args))
124953
def disable_all(self, disable):
        """"""
        commands = ['ENBH 0', #disable high freq. rear output
                    'ENBL 0', #disable low freq. front bnc
                    'MODL 0'   #disable modulation
                    ]
        command_string = '\n'.join(commands)
        print_string = '\n\t' + command_string.replace('\n', '\n\t')
        logging.info(print_string)
        if disable:
            self.instr.write(command_string)
43259
def change_mpl_backend(self, command):
        
        if command.startswith('%matplotlib') and \
          len(command.splitlines()) == 1:
            if not 'inline' in command:
                self.silent_execute(command)
616884
def direct_command(self, device_id, command, command2, extended_payload=None):
        """"""
        extended_payload = extended_payload or ''
        if not extended_payload:
            msg_type = '0'
            msg_type_desc = 'Standard'
        else:
            msg_type = '1'
            msg_type_desc = 'Extended'

            extended_payload = extended_payload.ljust(26, '0')

            ### Determine checksum to add onto the payload for I2CS support
            checksum_payload_hex = [int("0x" + extended_payload[i:i+2],16) for i in range(0,len(extended_payload)-1,2)]
            checksum_payload_hex.insert(0, int("0x" + command2, 16))
            checksum_payload_hex.insert(0, int("0x" + command, 16))

            # Get sum of all hex bytes
            bytessum = 0
            for ch in checksum_payload_hex:
                bytessum += ch
            bytessumStr = hex(bytessum)

            # Get last byte of the bytessum
            lastByte = bytessumStr[-2:]
            lastByte = '0x' + lastByte.zfill(2)
            # Determine compliment of last byte
            lastByteHex = int(lastByte, 16)
            lastCompliment = lastByteHex ^ 0xFF
            # Add one to create checksum
            checksum = hex(lastCompliment + 0x01)
            # Remove 0x prefix
            checksum_final = (format(int(checksum, 16), 'x'))
            checksum_final = checksum_final.upper()
            #print("final checksum")
            #pprint.pprint(checksum_final)
            extended_payload = extended_payload + checksum_final

        self.logger.info("direct_command: Device: %s Command: %s Command 2: %s Extended: %s MsgType: %s", device_id, command, command2, extended_payload, msg_type_desc)
        device_id = device_id.upper()
        command_url = (self.hub_url + '/3?' + "0262"
                       + device_id + msg_type + "F"
                       + command + command2 + extended_payload + "=I=3")
        return self.post_direct_command(command_url)
763219
def disable_key(self):
        """"""
        print("This command will disable a enabled key.")
        apiKeyID = input("API Key ID: ")
        try:
            key = self._curl_bitmex("/apiKey/disable",
                                    postdict={"apiKeyID": apiKeyID})
            print("Key with ID %s disabled." % key["id"])
        except:
            print("Unable to disable key, please try again.")
            self.disable_key()