def __init__(self, x, y, app_id, base_address=None): """ :param int x: The x-coordinate of the chip to allocate on, between 0 and 255 :param int y: The y-coordinate of the chip to allocate on, between 0 and 255 :param int app_id: The ID of the application, between 0 and 255 :param base_address: The start address in SDRAM to which the block needs to be deallocated, or none if deallocating via app_id :type base_address: int or None """ if base_address is not None: super().__init__( SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_ALLOC), argument_1=(AllocFree.FREE_SDRAM_BY_POINTER.value ), # @UndefinedVariable argument_2=base_address) self._read_n_blocks_freed = False else: super().__init__( SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_ALLOC), argument_1=(app_id << 8 | AllocFree.FREE_SDRAM_BY_APP_ID.value )) # @UndefinedVariable self._read_n_blocks_freed = True
def __init__(self, power_command, boards, delay=0.0, board_to_send_to=0): """ .. note:: There is currently a bug in the BMP that means some boards don't\ respond to power commands not sent to BMP 0. Thus changing the\ board_to_send_to parameter is not recommended! :param PowerCommand power_command: The power command being sent :param boards: The boards on the same backplane to power on or off :type boards: int or list(int) :param float delay: Number of seconds delay between power state changes of the different boards. :param int board_to_send_to: The optional board to send the command to if this is to be sent to a frame of boards. .. note:: Leave this at the default because of hardware bugs. """ if board_to_send_to != 0: logger.warning( "There is currently a bug in the BMP that means some boards" " don't respond to power commands not sent to BMP 0. Thus " "changing the board_to_send_to is not recommended!") arg1 = (int(delay * 1000) << 16) | power_command.value arg2 = self.get_board_mask(boards) super().__init__(board_to_send_to, SCPRequestHeader(command=SCPCommand.CMD_BMP_POWER), argument_1=arg1, argument_2=arg2)
def __init__(self, x, y, p, timeout_mantissa, timeout_exponent): """ :param x: The x-coordinate of a chip, between 0 and 255 :type x: int :param y: The y-coordinate of a chip, between 0 and 255 :type y: int :param p: \ The processor running the extra monitor vertex, between 0 and 17 :type p: int :param timeout_mantissa: \ The mantissa of the timeout value, between 0 and 15 :type timeout_mantissa: int :param timeout_exponent: \ The exponent of the timeout value, between 0 and 15 :type timeout_exponent: int """ # pylint: disable=too-many-arguments super(SetRouterEmergencyTimeoutMessage, self).__init__( SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=( SDP_PORTS.EXTRA_MONITOR_CORE_REINJECTION.value), destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader( command=ReinjectorSCPCommands.SET_ROUTER_EMERGENCY_TIMEOUT), argument_1=(timeout_mantissa & 0xF) | ((timeout_exponent & 0xF) << 4))
def __init__(self, x, y, p, current_time, run_time, infinite_run, destination_port, expect_response=True): # pylint: disable=too-many-arguments sdp_flags = SDPFlag.REPLY_NOT_EXPECTED if expect_response: sdp_flags = SDPFlag.REPLY_EXPECTED super(SCPUpdateRuntimeRequest, self).__init__( SDPHeader(flags=sdp_flags, destination_port=destination_port, destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader( command=SDP_RUNNING_MESSAGE_CODES.SDP_NEW_RUNTIME_ID_CODE), argument_1=run_time, argument_2=infinite_run, argument_3=current_time, data=struct.pack("<B", int(bool(expect_response))))
def __init__(self, nearest_neighbour_id, n_blocks, x=None, y=None): """ :param int nearest_neighbour_id: The ID of the packet, between 0 and 127 :param int n_blocks: The number of blocks of data that will be sent, between 0 and 255 :param int x: The x-coordinate of the chip to load the data on to. If not specified, the data will be loaded on to all chips :param int y: The y-coordinate of the chip to load the data on to. If not specified, the data will be loaded on to all chips """ key = ((_NNP_FLOOD_FILL_START << 24) | (nearest_neighbour_id << 16) | (n_blocks << 8)) data = 0xFFFF if x is not None and y is not None: m = ((y & 3) * 4) + (x & 3) data = (((x & 0xfc) << 24) + ((y & 0xfc) << 16) + (3 << 16) + (1 << m)) super().__init__(SDPHeader( flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=self.DEFAULT_DEST_X_COORD, destination_chip_y=self.DEFAULT_DEST_Y_COORD), SCPRequestHeader(command=SCPCommand.CMD_NNP), argument_1=key, argument_2=data, argument_3=_NNP_FORWARD_RETRY)
def __init__(self, x, y, base_address, size, cpu=0): """ :param int x: The x-coordinate of the chip to read from, between 0 and 255 :param int y: The y-coordinate of the chip to read from, between 0 and 255 :param int base_address: The positive base address to start the read from :param int size: The number of bytes to read, between 1 and 256 :raise SpinnmanInvalidParameterException: * If the chip coordinates are out of range * If the base address is not a positive number * If the size is out of range """ # pylint: disable=too-many-arguments super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=cpu, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_READ), argument_1=base_address, argument_2=size, argument_3=address_length_dtype[(base_address % 4, size % 4)].value)
def __init__(self, x, y, link, base_address, data, cpu=0): """ :param int x: The x-coordinate of the chip whose neighbour will be written to, between 0 and 255 :param int y: The y-coordinate of the chip whose neighbour will be written to, between 0 and 255 :param int cpu: The CPU core to use, normally 0 (or if a BMP, the board slot number) :param int link: The link number to write to between 0 and 5 (or if a BMP, the FPGA between 0 and 2) :param int base_address: The base_address to start writing to :param bytes data: Up to 256 bytes of data to write """ # pylint: disable=too-many-arguments super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=cpu, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_LINK_WRITE), argument_1=base_address, argument_2=len(data), argument_3=link, data=None) self._data_to_write = data
def __init__(self, x, y, p, multicast, point_to_point, fixed_route, nearest_neighbour): """ :param x: The x-coordinate of a chip, between 0 and 255 :type x: int :param y: The y-coordinate of a chip, between 0 and 255 :type y: int :param p: \ The processor running the extra monitor vertex, between 0 and 17 :type p: int :param point_to_point: If point to point should be set :type point_to_point: bool :param multicast: If multicast should be set :type multicast: bool :param nearest_neighbour: If nearest neighbour should be set :type nearest_neighbour: bool :param fixed_route: If fixed route should be set :type fixed_route: bool """ # pylint: disable=too-many-arguments super(SetReinjectionPacketTypesMessage, self).__init__( SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=( SDP_PORTS.EXTRA_MONITOR_CORE_REINJECTION.value), destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=ReinjectorSCPCommands.SET_PACKET_TYPES), argument_1=int(bool(multicast)), argument_2=int(bool(point_to_point)), argument_3=int(bool(fixed_route)), data=bytearray(struct.pack("<B", nearest_neighbour)))
def __init__(self, x, y, base_address, data, cpu=0): """ :param int x: The x-coordinate of the chip, between 0 and 255; this is not checked due to speed restrictions :param int y: The y-coordinate of the chip, between 0 and 255; this is not checked due to speed restrictions :param int base_address: The base_address to start writing to the base address is not checked to see if its not valid :param data: between 1 and 256 bytes of data to write; this is not checked due to speed restrictions :type data: bytearray or bytes """ # pylint: disable=too-many-arguments size = len(data) super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=cpu, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_WRITE), argument_1=base_address, argument_2=size, argument_3=address_length_dtype[(base_address % 4), (size % 4)].value, data=None) self._data_to_write = data
def __init__(self, x, y, p, run_time, infinite_run, destination_port, expect_response=True): sdp_flags = SDPFlag.REPLY_NOT_EXPECTED arg3 = 0 if expect_response: sdp_flags = SDPFlag.REPLY_EXPECTED arg3 = 1 AbstractSCPRequest.__init__( self, SDPHeader(flags=sdp_flags, destination_port=destination_port, destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader( command=SDP_RUNNING_MESSAGE_CODES.SDP_NEW_RUNTIME_ID_CODE), argument_1=run_time, argument_2=infinite_run, argument_3=arg3)
def __init__(self, x, y, host, port, tag, strip, use_sender=False): """ :param int x: The x-coordinate of a chip, between 0 and 255 :param int y: The y-coordinate of a chip, between 0 and 255 :param bytearray or list[int] host: The host address, \ as an array of 4 bytes :param int port: The port, between 0 and 65535 :param int tag: The tag, between 0 and 7 :param bool strip: if the SDP header should be striped from the packet :param bool use_sender: if the sender IP address and port should be used """ # pylint: disable=too-many-arguments strip_value = int(bool(strip)) sender_value = int(bool(use_sender)) super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_IPTAG), argument_1=(strip_value << 28) | (sender_value << 30) | (_IPTAG_SET << 16) | tag, argument_2=port, argument_3=((host[3] << 24) | (host[2] << 16) | (host[1] << 8) | host[0]))
def __init__(self, x, y, destination_x, destination_y, destination_p, port, tag, sdp_port): """ :param int x: The x-coordinate of a chip, between 0 and 255 :param int y: The y-coordinate of a chip, between 0 and 255 :param int destination_x: The x-coordinate of the destination chip, between 0 and 255 :param int destination_y: The y-coordinate of the destination chip, between 0 and 255 :param int destination_p: The ID of the destination processor, between 0 and 17 :param int port: The port, between 0 and 65535 :param int tag: The tag, between 0 and 7 """ # pylint: disable=too-many-arguments strip_value = 1 reverse_value = 1 arg1 = ((reverse_value << 29) | (strip_value << 28) | (_IPTAG_SET << 16) | (sdp_port << 13) | (destination_p << 8) | tag) arg2 = ((destination_x << 24) | (destination_y << 16) | port) super().__init__( SDPHeader( flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_IPTAG), argument_1=arg1, argument_2=arg2, argument_3=0)
def __init__(self, led, action, boards): """ :param led: Number of the LED or an iterable of LEDs to set the state of (0-7) :type led: int or list(int) :param LEDAction action: State to set the LED to, either on, off or toggle :param boards: Specifies the board to control the LEDs of. This may also be an iterable of multiple boards (in the same frame). :type boards: int or list(int) """ # set up the led entry for arg1 if isinstance(led, int): leds = [led] else: leds = led # LED setting actions arg1 = sum(action.value << (led * 2) for led in leds) # Bitmask of boards to control arg2 = self.get_board_mask(boards) # initialise the request now super().__init__(boards, SCPRequestHeader(command=SCPCommand.CMD_LED), argument_1=arg1, argument_2=arg2)
def __init__(self, app_id, x, y, processors, wait=False): """ :param int app_id: The ID of the application to run, between 16 and 255 :param int x: The x-coordinate of the chip to run on, between 0 and 255 :param int y: The y-coordinate of the chip to run on, between 0 and 255 :param list(int) processors: The processors on the chip where the executable should be started, between 1 and 17 :param bool wait: True if the processors should enter a "wait" state on starting """ # pylint: disable=too-many-arguments processor_mask = 0 if processors is not None: for processor in processors: processor_mask |= (1 << processor) processor_mask |= (app_id << 24) if wait: processor_mask |= _WAIT_FLAG super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_AR), argument_1=processor_mask)
def __init__(self, board): """ :param int board: which board to request the ADC register from """ super().__init__( board, SCPRequestHeader(command=SCPCommand.CMD_BMP_INFO), argument_1=BMPInfo.ADC)
def __init__(self, board): """ :param int board: The board to get the version from :raise SpinnmanInvalidParameterException: * If the chip coordinates are out of range * If the processor is out of range """ super().__init__(board, SCPRequestHeader(command=SCPCommand.CMD_VER))
def __init__(self, x, y): scp_header = SCPRequestHeader(command=SCPResult.RC_OK) sdp_header = SDPHeader(flags=SDPFlag.REPLY_NOT_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y) utils.update_sdp_header_for_udp_send(sdp_header, 0, 0) SDPMessage.__init__(self, sdp_header, data=scp_header.bytestring)
def __init__(self, x, y, sequence=0): # pragma: no cover scp_header = SCPRequestHeader(command=SCPResult.RC_OK, sequence=sequence) sdp_header = SDPHeader(flags=SDPFlag.REPLY_NOT_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y) utils.update_sdp_header_for_udp_send(sdp_header, 0, 0) super().__init__(sdp_header, data=scp_header.bytestring)
def __init__(self, x, y, version): self._scp_header = SCPRequestHeader(command=SCPResult.RC_OK) self._version_descriptor = b"BC&MP/Test\0" + version + b"\0" self._y = y self._x = x sdp_header = SDPHeader(flags=SDPFlag.REPLY_NOT_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y) utils.update_sdp_header_for_udp_send(sdp_header, 0, 0) super(SCPVerMessage, self).__init__(sdp_header)
def __init__(self, x, y): """ :param int x: The x-coordinate of a chip, between 0 and 255 :param int y: The y-coordinate of a chip, between 0 and 255 """ super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_IPTAG), argument_1=(_IPTAG_INFO << 16), argument_2=_IPTAG_MAX)
def __init__(self, x, y, p): # pylint: disable=too-many-arguments super(_ClearIOBUFRequest, self).__init__( SDPHeader( flags=SDPFlag.REPLY_EXPECTED, destination_cpu=p, destination_chip_x=x, destination_chip_y=y, destination_port=SDP_PORTS.RUNNING_COMMAND_SDP_PORT.value), SCPRequestHeader( command=SDP_RUNNING_MESSAGE_CODES.SDP_CLEAR_IOBUF_CODE), argument_3=int(True))
def __init__(self, fpga_num, addr, value, board): """ :param int fpga_num: FPGA number (0, 1 or 2) to communicate with. :param int addr: Register address to read or write to (will be rounded down to the nearest 32-bit word boundary). :param int value: A 32-bit int value to write to the register """ super().__init__(board, SCPRequestHeader(command=SCPCommand.CMD_LINK_WRITE), argument_1=addr & (~0x3), argument_2=4, argument_3=fpga_num, data=_ONE_WORD.pack(value))
def __init__(self, app_id): """ :param int app_id: The ID of the application, between 0 and 255 """ super().__init__(SDPHeader( flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=self.DEFAULT_DEST_X_COORD, destination_chip_y=self.DEFAULT_DEST_Y_COORD), SCPRequestHeader(command=SCPCommand.CMD_NNP), argument_1=(0x3f << 16), argument_2=(5 << 28) | _get_data(app_id, Signal.STOP), argument_3=(1 << 31) + (0x3f << 8))
def __init__(self, x, y, tag_timeout): """ :param int x: The x-coordinate of the chip to run on, between 0 and 255 :param int y: The y-coordinate of the chip to run on, between 0 and 255 :param IPTAG_TIME_OUT_WAIT_TIMES tag_timeout: The timeout value """ super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_IPTAG), argument_1=_IPTAG_TTO, argument_2=tag_timeout.value)
def __init__(self, x, y, p, destination_port, expect_response=True): # pylint: disable=too-many-arguments sdp_flags = SDPFlag.REPLY_NOT_EXPECTED if expect_response: sdp_flags = SDPFlag.REPLY_EXPECTED super(SCPClearIOBUFRequest, self).__init__( SDPHeader(flags=sdp_flags, destination_port=destination_port, destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader( command=SDP_RUNNING_MESSAGE_CODES.SDP_CLEAR_IOBUF_CODE), argument_3=int(bool(expect_response)))
def __init__(self, x, y, tag): """ :param int x: The x-coordinate of a chip, between 0 and 255 :param int y: The y-coordinate of a chip, between 0 and 255 :param int tag: The tag to get details of, between 0 and 7 :param int tag: The tag, between 0 and 7 """ super().__init__(SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_IPTAG), argument_1=(_IPTAG_GET << 16) | tag, argument_2=1)
def __init__(self, x, y): """ :param int x: The x-coordinate of the chip, between 0 and 255 :param int y: The y-coordinate of the chip, between 0 and 255 :raise SpinnmanInvalidParameterException: * If x is out of range * If y is out of range """ super().__init__( SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=SCPCommand.CMD_RTR))
def __init__(self, x, y, p): """ :param int x: The x-coordinate of a chip, between 0 and 255 :param int y: The y-coordinate of a chip, between 0 and 255 :param int p: The processor running the extra monitor vertex, between 0 and 17 """ super(GetReinjectionStatusMessage, self).__init__( SDPHeader(flags=SDPFlag.REPLY_EXPECTED, destination_port=( SDP_PORTS.EXTRA_MONITOR_CORE_REINJECTION.value), destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=ReinjectorSCPCommands.GET_STATUS))
def __init__(self, app_id, state): """ :param int app_id: The ID of the application, between 0 and 255 :param CPUState state: The state to count """ super().__init__( SDPHeader( flags=SDPFlag.REPLY_EXPECTED, destination_port=0, destination_cpu=0, destination_chip_x=self.DEFAULT_DEST_X_COORD, destination_chip_y=self.DEFAULT_DEST_Y_COORD), SCPRequestHeader(command=SCPCommand.CMD_SIG), argument_1=_COUNT_SIGNAL_TYPE, argument_2=_get_data(app_id, state), argument_3=_ALL_CORE_MASK)
def __init__(self, x, y, p): """ :param int x: The x-coordinate of a chip, between 0 and 255 :param int y: The y-coordinate of a chip, between 0 and 255 :param int p: The processor running the extra monitor vertex, between 0 and 17 """ # pylint: disable=too-many-arguments super(ClearReinjectionQueueMessage, self).__init__( SDPHeader( flags=SDPFlag.REPLY_EXPECTED, destination_port=( SDP_PORTS.EXTRA_MONITOR_CORE_REINJECTION.value), destination_cpu=p, destination_chip_x=x, destination_chip_y=y), SCPRequestHeader(command=ReinjectorSCPCommands.CLEAR))