docs: def send_scp(self, buffer_size, x, y, p, cmd, arg1=0, arg2=0, arg3=0,
                   data=b'', expected_args=3, timeout=0.0):
          """Transmit a packet to the SpiNNaker machine and block until an
          acknowledgement is received.
  
          Parameters
          ----------
          buffer_size : int
              Number of bytes held in an SCP buffer by SARK, determines how many
              bytes will be expected in a socket.
          x : int
          y : int
          p : int
          cmd : int
          arg1 : int
          arg2 : int
          arg3 : int
          data : bytestring
          expected_args : int
              The number of arguments (0-3) that are expected in the returned
              packet.
          timeout : float
              Additional timeout in seconds to wait for a reply on top of the
              default specified upon instantiation.
  
          Returns
          -------
          :py:class:`~rig.machine_control.packets.SCPPacket`
              The packet that was received in acknowledgement of the transmitted
              packet.
          """
          # This is implemented as a single burst packet sent using the bursty
          # interface.  This significantly reduces code duplication.
          # Construct a callable to retain the returned packet for us
          class Callback(object):
              def __init__(self):
                  self.packet = None
  
              def __call__(self, packet):
                  self.packet = SCPPacket.from_bytestring(
                      packet, n_args=expected_args
                  )
  
          # Create the packet to send
          callback = Callback()
          packets = [
              scpcall(x, y, p, cmd, arg1, arg2, arg3, data, callback, timeout)
          ]
  
          # Send the burst
          self.send_scp_burst(buffer_size, 1, packets)
  
          # Return the received packet
          assert callback.packet is not None
          return callback.packet