diff --git a/canopen/sdo/client.py b/canopen/sdo/client.py
index 82ee0c88..c442714c 100644
--- a/canopen/sdo/client.py
+++ b/canopen/sdo/client.py
@@ -316,20 +316,21 @@ def read(self, size=-1):
         self.pos += length
         return response[1:length + 1]
 
-    def readinto(self, b):
-        """
-        Read bytes into a pre-allocated, writable bytes-like object b,
-        and return the number of bytes read.
-        """
-        data = self.read(7)
-        b[:len(data)] = data
-        return len(data)
+    # For now not used, but if needed, a test is also required:
+    # def readinto(self, b):
+    #     """
+    #     Read bytes into a pre-allocated, writable bytes-like object b,
+    #     and return the number of bytes read.
+    #     """
+    #     data = self.read(7)
+    #     b[:len(data)] = data
+    #     return len(data)
 
-    def readable(self):
-        return True
+    # def readable(self):
+    #     return True
 
-    def tell(self):
-        return self.pos
+    # def tell(self):
+    #     return self.pos
 
 
 class WritableStream(io.RawIOBase):
@@ -366,6 +367,7 @@ def __init__(self, sdo_client, index, subindex=0, size=None, force_segment=False
             response = sdo_client.request_response(request)
             res_command, = struct.unpack_from("B", response)
             if res_command != RESPONSE_DOWNLOAD:
+                self._done = True  # prevent close() from sending a stray close segment
                 self.sdo_client.abort(ABORT_INVALID_COMMAND_SPECIFIER)
                 raise SdoCommunicationError(
                     f"Unexpected response 0x{res_command:02X}")
@@ -420,6 +422,7 @@ def write(self, b):
             response = self.sdo_client.request_response(request)
             res_command, = struct.unpack("B", response[0:1])
             if res_command & 0xE0 != RESPONSE_SEGMENT_DOWNLOAD:
+                self._done = True  # prevent close() from sending a stray close segment
                 self.sdo_client.abort(ABORT_INVALID_COMMAND_SPECIFIER)
                 raise SdoCommunicationError(
                     f"Unexpected response 0x{res_command:02X} "
@@ -535,6 +538,7 @@ def read(self, size=-1):
         if seqno == self._ackseq + 1:
             self._ackseq = seqno
         else:
+            logger.debug('Wrong seqno')
             # Wrong sequence number
             response = self._retransmit()
             res_command, = struct.unpack_from("B", response)
@@ -612,14 +616,15 @@ def close(self):
     def tell(self):
         return self.pos
 
-    def readinto(self, b):
-        """
-        Read bytes into a pre-allocated, writable bytes-like object b,
-        and return the number of bytes read.
-        """
-        data = self.read(7)
-        b[:len(data)] = data
-        return len(data)
+    # For now not used, but if needed, a test is also required:
+    # def readinto(self, b):
+    #     """
+    #     Read bytes into a pre-allocated, writable bytes-like object b,
+    #     and return the number of bytes read.
+    #     """
+    #     data = self.read(7)
+    #     b[:len(data)] = data
+    #     return len(data)
 
     def readable(self):
         return True
@@ -787,6 +792,8 @@ def _retransmit(self, ackseq, blksize):
         # Reset _seqno and update blksize
         self._seqno = 0
         self._blksize = blksize
+        # Reset _done so the last segment can be re-sent
+        self._done = False
         # We are retransmitting
         self._retransmitting = True
         # Resend the block
diff --git a/canopen/sdo/constants.py b/canopen/sdo/constants.py
index e19c79a6..7e6ad4a8 100644
--- a/canopen/sdo/constants.py
+++ b/canopen/sdo/constants.py
@@ -4,7 +4,11 @@
 
 # Command, index, subindex
 SDO_STRUCT = struct.Struct("<BHB")
+SDO_BLOCKACK_STRUCT = struct.Struct("<BBB") # c + ackseq + new blocksize
+SDO_BLOCKEND_STRUCT = struct.Struct("<BH") # c + CRC
+SDO_ABORT_STRUCT = struct.Struct("<BHBI") # c +i + si + Abort code
 
+# Command[5-7]
 REQUEST_SEGMENT_DOWNLOAD = 0 << 5
 REQUEST_DOWNLOAD = 1 << 5
 REQUEST_UPLOAD = 2 << 5
@@ -21,18 +25,31 @@
 RESPONSE_BLOCK_DOWNLOAD = 5 << 5
 RESPONSE_BLOCK_UPLOAD = 6 << 5
 
+# Block transfer sub-commands, Command[0-1]
+SUB_COMMAND_MASK = 0x3
 INITIATE_BLOCK_TRANSFER = 0
 END_BLOCK_TRANSFER = 1
 BLOCK_TRANSFER_RESPONSE = 2
 START_BLOCK_UPLOAD = 3
 
-EXPEDITED = 0x2
-SIZE_SPECIFIED = 0x1
-BLOCK_SIZE_SPECIFIED = 0x2
-CRC_SUPPORTED = 0x4
-NO_MORE_DATA = 0x1
-NO_MORE_BLOCKS = 0x80
-TOGGLE_BIT = 0x10
+EXPEDITED = 0x2             # Expedited and segmented
+SIZE_SPECIFIED = 0x1        # All transfers
+BLOCK_SIZE_SPECIFIED = 0x2  # Block transfer: size specified in message
+CRC_SUPPORTED = 0x4         # client/server CRC capable
+NO_MORE_DATA = 0x1          # Segmented: last segment
+NO_MORE_BLOCKS = 0x80       # Block transfer: last segment
+TOGGLE_BIT = 0x10           # segmented toggle mask
+
+# Block states
+BLOCK_STATE_NONE = -1
+BLOCK_STATE_INIT = 0        # state when entering
+BLOCK_STATE_UPLOAD = 0x10   # delimiter, used for block type check
+BLOCK_STATE_UP_INIT_RESP = 0x11 # state when entering, response during upload
+BLOCK_STATE_UP_DATA = 0x12     # Upload Data transfer state
+BLOCK_STATE_UP_END = 0x13      # End of Upload block transfers
+BLOCK_STATE_DOWNLOAD = 0x20 # delimiter, used for block type check
+BLOCK_STATE_DL_DATA = 0x24     # Download Data transfer state
+BLOCK_STATE_DL_END = 0x25      # End of Download block transfers
 
 # Abort codes
 ABORT_TOGGLE_NOT_ALTERNATED: Final[int] = 0x0503_0000
diff --git a/canopen/sdo/exceptions.py b/canopen/sdo/exceptions.py
index 3130ef48..ae9e1009 100644
--- a/canopen/sdo/exceptions.py
+++ b/canopen/sdo/exceptions.py
@@ -1,4 +1,4 @@
-
+from typing import Union
 
 class SdoError(Exception):
     pass
@@ -44,9 +44,15 @@ class SdoAbortedError(SdoError):
         0x08000024: "No data available",
     }
 
-    def __init__(self, code: int):
+    def __init__(self, code: Union[int, str]):
         #: Abort code
-        self.code = code
+        if isinstance(code, str):
+            try:
+                self.code = self.from_string(code)
+            except ValueError as e:
+                raise ValueError(f"Unknown SDO abort description: {code}") from e
+        else:
+            self.code = code
 
     def __str__(self):
         text = f"Code 0x{self.code:08X}"
@@ -54,10 +60,22 @@ def __str__(self):
             text = text + ", " + self.CODES[self.code]
         return text
 
-    def __eq__(self, other):
+    def __eq__(self, other:Union['SdoAbortedError', int, str]):
         """Compare two exception objects based on SDO abort code."""
+        if isinstance(other, int):
+            other = SdoAbortedError(other)
+        elif isinstance(other, str):
+            other = SdoAbortedError(other)
+        elif not isinstance(other, SdoAbortedError):
+            raise TypeError(f"Cannot compare SdoAbortedError with {type(other)}")
         return self.code == other.code
 
+    def from_string(self, text: str) -> int:
+        code = list(SdoAbortedError.CODES.keys())[
+            list(SdoAbortedError.CODES.values()).index(text)
+        ]
+        return SdoAbortedError(code)
+
 
 class SdoCommunicationError(SdoError):
     """No or unexpected response from slave."""
diff --git a/canopen/sdo/server.py b/canopen/sdo/server.py
index c26dc998..e36c0094 100644
--- a/canopen/sdo/server.py
+++ b/canopen/sdo/server.py
@@ -8,6 +8,10 @@
 logger = logging.getLogger(__name__)
 
 
+class SdoBlockException(SdoAbortedError):
+    """Dedicated SDO Block exception."""
+
+
 class SdoServer(SdoBase):
     """Creates an SDO server."""
 
@@ -27,9 +31,24 @@ def __init__(self, rx_cobid, tx_cobid, node):
         self._index = None
         self._subindex = None
         self.last_received_error = 0x00000000
+        self.sdo_block = None
 
     def on_request(self, can_id, data, timestamp):
-        command, = struct.unpack_from("B", data, 0)
+        logger.debug("on_request")
+        if self.sdo_block and self.sdo_block.state != BLOCK_STATE_NONE:
+            try:
+                self.process_block(data)
+            except SdoAbortedError as exc:
+                self.sdo_block = None
+                self.abort(exc.code)
+                raise
+            except Exception:
+                self.sdo_block = None
+                self.abort()
+                raise
+            return
+
+        (command,) = struct.unpack_from("B", data, 0)
         ccs = command & 0xE0
 
         try:
@@ -57,6 +76,120 @@ def on_request(self, can_id, data, timestamp):
             self.abort()
             logger.exception(exc)
 
+    def process_block(self, request):
+        """
+        Process a block request, using a state mechanisme from SdoBlock class
+        to handle the different states of the block transfer.
+
+        :param request:
+            CAN message containing EMCY or SDO request.
+        """
+
+        logger.debug("process_block")
+        command, _, _, code = SDO_ABORT_STRUCT.unpack_from(request)
+        if command == 0x80:
+            # Abort received
+            logger.error("Abort: 0x%08X" % code)
+            self.sdo_block = None
+            return
+
+        if BLOCK_STATE_UPLOAD < self.sdo_block.state < BLOCK_STATE_DOWNLOAD:
+            logger.debug("BLOCK_STATE_UPLOAD")
+            command, _, _ = SDO_STRUCT.unpack_from(request)
+
+            # in upload state
+            if self.sdo_block.state == BLOCK_STATE_UP_INIT_RESP:
+                logger.debug("BLOCK_STATE_UP_INIT_RESP")
+                # init response was sent, client required to send new request
+                if (command & REQUEST_BLOCK_UPLOAD) != REQUEST_BLOCK_UPLOAD:
+                    raise SdoBlockException("Unknown SDO command specified")  # pragma: no cover
+                if (command & START_BLOCK_UPLOAD) != START_BLOCK_UPLOAD:
+                    raise SdoBlockException("Unknown SDO command specified")  # pragma: no cover
+
+                # now start blasting data to client from server
+                self.sdo_block.update_state(BLOCK_STATE_UP_DATA)
+
+                blocks = self.sdo_block.get_upload_blocks()
+                for block in blocks:
+                    self.send_response(block)
+
+            elif self.sdo_block.state == BLOCK_STATE_UP_DATA:
+                logger.debug("BLOCK_STATE_UP_DATA")
+                command, ackseq, newblk = SDO_BLOCKACK_STRUCT.unpack_from(request)
+                if (command & REQUEST_BLOCK_UPLOAD) != REQUEST_BLOCK_UPLOAD:
+                    raise SdoBlockException("Unknown SDO command specified")
+                elif (command & BLOCK_TRANSFER_RESPONSE) != BLOCK_TRANSFER_RESPONSE:
+                    raise SdoBlockException("Unknown SDO command specified")
+                elif ackseq != self.sdo_block.last_seqno:
+                    self.sdo_block.data_uploaded = self.sdo_block.data_successful_upload
+                else:
+                    self.sdo_block.data_successful_upload = self.sdo_block.data_uploaded
+
+                if self.sdo_block.size == self.sdo_block.data_uploaded:
+                    logger.debug("BLOCK_STATE_UP_DATA last data")
+                    self.sdo_block.update_state(BLOCK_STATE_UP_END)
+                    response = bytearray(8)
+                    command = RESPONSE_BLOCK_UPLOAD
+                    command |= END_BLOCK_TRANSFER
+                    n = self.sdo_block.last_bytes << 2
+                    command |= n
+                    logger.debug("Last no byte: %d, CRC: x%04X", self.sdo_block.last_bytes, self.sdo_block.crc_value)
+                    SDO_BLOCKEND_STRUCT.pack_into(response, 0, command, self.sdo_block.crc_value)
+                    self.send_response(response)
+                else:
+                    blocks = self.sdo_block.get_upload_blocks()
+                    for block in blocks:
+                        self.send_response(block)
+
+            elif self.sdo_block.state == BLOCK_STATE_UP_END:
+                self.sdo_block = None
+
+        elif BLOCK_STATE_DOWNLOAD < self.sdo_block.state <= BLOCK_STATE_DL_END:
+            # in download state
+            logger.debug("BLOCK_STATE_DOWNLOAD")
+            if self.sdo_block.state == BLOCK_STATE_DL_DATA:
+                logger.debug("BLOCK_STATE_DL_DATA")
+                seqno = command & 0x7F
+                last_seg = bool(command & NO_MORE_BLOCKS)
+                # Accumulate data bytes (bytes 1-7 of each segment)
+                self.sdo_block.append_download_data(request[1:8])
+                self.sdo_block.last_seqno = seqno
+
+                if seqno >= self.sdo_block.req_blocksize or last_seg:
+                    # Send block acknowledgement
+                    response = bytearray(8)
+                    response[0] = RESPONSE_BLOCK_DOWNLOAD | BLOCK_TRANSFER_RESPONSE
+                    response[1] = seqno  # ackseq
+                    response[2] = self.sdo_block.req_blocksize  # new blksize
+                    self.send_response(response)
+                    self.sdo_block.seqno = 0
+
+                    if last_seg:
+                        self.sdo_block.update_state(BLOCK_STATE_DL_END)
+
+            elif self.sdo_block.state == BLOCK_STATE_DL_END:
+                logger.debug("BLOCK_STATE_DL_END")
+                if (command & REQUEST_BLOCK_DOWNLOAD) != REQUEST_BLOCK_DOWNLOAD:
+                    raise SdoBlockException("Unknown SDO command specified") # pragma: no cover
+                if (command & SUB_COMMAND_MASK) != END_BLOCK_TRANSFER:
+                    raise SdoBlockException("Unknown SDO command specified") # pragma: no cover
+
+                # n = bytes NOT used in last segment
+                n = (command >> 2) & 0x7
+                data = self.sdo_block.finalize_download(n)
+
+                self._node.set_data(self.sdo_block.index, self.sdo_block.subindex, data, check_writable=True)
+
+                response = bytearray(8)
+                response[0] = RESPONSE_BLOCK_DOWNLOAD | END_BLOCK_TRANSFER
+                self.send_response(response)
+                self.sdo_block = None
+        else:
+            # in neither
+            raise SdoBlockException(
+                "Data can not be transferred or stored to the application because of the present device state"
+            ) # pragma: no cover
+
     def init_upload(self, request):
         _, index, subindex = SDO_STRUCT.unpack_from(request)
         self._index = index
@@ -74,13 +207,12 @@ def init_upload(self, request):
             logger.info("Expedited upload for 0x%04X:%02X", index, subindex)
             res_command |= EXPEDITED
             res_command |= (4 - size) << 2
-            response[4:4 + size] = data
+            response[4 : 4 + size] = data
         else:
             logger.info("Initiating segmented upload for 0x%04X:%02X", index, subindex)
             struct.pack_into("<L", response, 4, size)
             self._buffer = bytearray(data)
             self._toggle = 0
-
         SDO_STRUCT.pack_into(response, 0, res_command, index, subindex)
         self.send_response(response)
 
@@ -107,15 +239,39 @@ def segmented_upload(self, command):
 
         response = bytearray(8)
         response[0] = res_command
-        response[1:1 + size] = data
+        response[1 : 1 + size] = data
         self.send_response(response)
 
-    def block_upload(self, data):
-        # We currently don't support BLOCK UPLOAD
-        # according to CIA301 the server is allowed
-        # to switch to regular upload
-        logger.info("Received block upload, switch to regular SDO upload")
-        self.init_upload(data)
+    def block_upload(self, request):
+        """
+        Process an initial block upload request.
+        Create a CAN response message and update the state of the SDO block.
+
+        :param request:
+            CAN message containing SDO request.
+        """
+        logging.debug("Enter server block upload")
+        self.sdo_block = _SdoBlock(self._node, request)
+
+        res_command = RESPONSE_BLOCK_UPLOAD
+        res_command |= BLOCK_SIZE_SPECIFIED
+        res_command |= self.sdo_block.crc
+        res_command |= INITIATE_BLOCK_TRANSFER
+        logging.debug("CMD: %02X", res_command)
+        response = bytearray(8)
+
+        struct.pack_into(
+            SDO_STRUCT.format + "I",  # add size
+            response,
+            0,
+            res_command,
+            self.sdo_block.index,
+            self.sdo_block.subindex,
+            self.sdo_block.size,
+        )
+        logging.debug("response %s", response)
+        self.sdo_block.update_state(BLOCK_STATE_UP_INIT_RESP)
+        self.send_response(response)
 
     def request_aborted(self, data):
         _, index, subindex, code = struct.unpack_from("<BHBL", data)
@@ -123,13 +279,22 @@ def request_aborted(self, data):
         logger.info("Received request aborted for 0x%04X:%02X with code 0x%X", index, subindex, code)
 
     def block_download(self, data):
-        # We currently don't support BLOCK DOWNLOAD
-        # Unpack the index and subindex in order to send appropriate abort
+        logger.debug("Enter server block download")
         command, index, subindex = SDO_STRUCT.unpack_from(data)
+
         self._index = index
         self._subindex = subindex
-        logger.error("Block download is not supported")
-        self.abort(ABORT_INVALID_COMMAND_SPECIFIER)
+
+        self.sdo_block = _SdoBlock(self._node, data, is_download=True)
+
+        res_command = RESPONSE_BLOCK_DOWNLOAD | INITIATE_BLOCK_TRANSFER
+        res_command |= self.sdo_block.crc  # Echo CRC support back to client
+        response = bytearray(8)
+        SDO_STRUCT.pack_into(response, 0, res_command, index, subindex)
+        response[4] = self.sdo_block.req_blocksize  # Server-defined block size
+
+        self.sdo_block.update_state(BLOCK_STATE_DL_DATA)
+        self.send_response(response)
 
     def init_download(self, request):
         # TODO: Check if writable (now would fail on end of segmented downloads)
@@ -145,11 +310,11 @@ def init_download(self, request):
                 size = 4 - ((command >> 2) & 0x3)
             else:
                 size = 4
-            self._node.set_data(index, subindex, request[4:4 + size], check_writable=True)
+            self._node.set_data(index, subindex, request[4 : 4 + size], check_writable=True)
         else:
             logger.info("Initiating segmented download for 0x%04X:%02X", index, subindex)
             if command & SIZE_SPECIFIED:
-                size, = struct.unpack_from("<L", request, 4)
+                (size,) = struct.unpack_from("<L", request, 4)
                 logger.info("Size is %d bytes", size)
             self._buffer = bytearray()
             self._toggle = 0
@@ -165,10 +330,7 @@ def segmented_download(self, command, request):
         self._buffer.extend(request[1:last_byte])
 
         if command & NO_MORE_DATA:
-            self._node.set_data(self._index,
-                                self._subindex,
-                                self._buffer,
-                                check_writable=True)
+            self._node.set_data(self._index, self._subindex, self._buffer, check_writable=True)
 
         res_command = RESPONSE_SEGMENT_DOWNLOAD
         # Add toggle bit
@@ -185,8 +347,10 @@ def send_response(self, response):
 
     def abort(self, abort_code=ABORT_GENERAL_ERROR):
         """Abort current transfer."""
-        data = struct.pack("<BHBL", RESPONSE_ABORTED,
-                           self._index, self._subindex, abort_code)
+        if isinstance(abort_code, SdoAbortedError):
+            abort_code = abort_code.code
+
+        data = struct.pack("<BHBL", RESPONSE_ABORTED, self._index, self._subindex, abort_code)
         self.send_response(data)
         # logger.error("Transfer aborted with code 0x%08X", abort_code)
 
@@ -225,3 +389,145 @@ def download(
             When node responds with an error.
         """
         return self._node.set_data(index, subindex, data)
+
+
+class _SdoBlock:
+    """
+    _SdoBlock class to handle block transfer. It keeps track of the
+    current state and prepares data to be transferred.
+    """
+
+    state = BLOCK_STATE_NONE
+    crc = False
+    data_uploaded = 0
+    data_successful_upload = 0
+    last_bytes = 0
+    crc_value = 0
+    last_seqno = 0
+
+    def __init__(self, node, request, docrc=False, is_download=False):
+        """
+        :param node:
+            Node object owning the server
+        :param request:
+            CAN message containing SDO request.
+        :param docrc:
+            If True, CRC is calculated and checked.
+        :param is_download:
+            If True, initialise for block download (server receives data).
+            If False (default), initialise for block upload (server sends data).
+        """
+        command, index, subindex = SDO_STRUCT.unpack_from(request)
+        # only do crc if crccheck lib is available _and_ if requested
+        _req_crc = (command & CRC_SUPPORTED) == CRC_SUPPORTED
+
+        # For block download, bit 1 is the size indicator (s), not a sub-command
+        # bit. Only bit 0 carries the sub-command (0 = initiate). For block
+        # upload the s-bit is not used in the initiate command so SUB_COMMAND_MASK
+        # works there, but we must use a 1-bit mask here.
+        sub_cmd_mask = 0x1 if is_download else SUB_COMMAND_MASK
+        if (command & sub_cmd_mask) == INITIATE_BLOCK_TRANSFER:
+            self.state = BLOCK_STATE_INIT
+        else:
+            # Realistically shouldnt happen since this is only called after receiving an initiate command, but check anyway
+            raise SdoBlockException("Unknown SDO command specified") # pragma: no cover
+
+        # TODO: CRC of data if requested
+        self.crc = CRC_SUPPORTED if (docrc & _req_crc) else 0
+        self._node = node
+        self.index = index
+        self.subindex = subindex
+        self.seqno = 0
+
+        if is_download:
+            # Server defines the block size for download (client sends this many
+            # segments per block before waiting for an acknowledgement)
+            self.req_blocksize = 127
+            self._data_buffer = bytearray()
+            if command & BLOCK_SIZE_SPECIFIED:
+                (self.size,) = struct.unpack_from("<L", request, 4)
+            else:
+                self.size = None  # pragma: no cover
+        else:
+            self.req_blocksize = request[4]
+            if not 1 <= self.req_blocksize <= 127:
+                raise SdoBlockException("Invalid block size")
+            self.data = self._node.get_data(index, subindex, check_readable=True)
+            self.size = len(self.data)
+
+    def update_state(self, new_state):
+        """
+        Update the state of the SDO block transfer. The state is
+        updated only if the new state is higher than the current
+        state. Otherwise an exception is raised.
+        """
+        logging.debug("update_state %X -> %X", self.state, new_state)
+        if new_state >= self.state:
+            self.state = new_state
+        else:
+            raise SdoBlockException(
+                "Data can not be transferred or stored to the application because of the present device state"
+            )
+
+    def get_upload_blocks(self):
+        """
+        Get the blocks of data to be sent to the client. The blocks are
+        created in a messages list of bytearrays.
+        """
+
+        msgs = []
+
+        # seq no 1 - 127, not 0 -..
+        for seqno in range(1, self.req_blocksize + 1):
+            logger.debug("SEQNO %d", seqno)
+            response = bytearray(8)
+            command = 0
+            if self.size <= (self.data_uploaded + 7):
+                # no more segments after this
+                command |= NO_MORE_BLOCKS
+
+            command |= seqno
+            response[0] = command
+            for i in range(7):
+                databyte = self.get_data_byte()
+                if databyte != None:
+                    response[i + 1] = databyte
+                else:
+                    self.last_bytes = 7 - i
+                    break
+            msgs.append(response)
+            self.last_seqno = seqno
+
+            if self.size == self.data_uploaded:
+                break
+        logger.debug(msgs)
+        return msgs
+
+    def get_data_byte(self):
+        """Get the next byte of data to be sent to the client."""
+        if self.data_uploaded < self.size:
+            self.data_uploaded += 1
+            return self.data[self.data_uploaded - 1]
+        return None
+
+    def append_download_data(self, segment):
+        """Append a 7-byte segment to the download data buffer.
+
+        :param segment:
+            Bytes 1-7 of the received block segment message (always 7 bytes).
+        """
+        self._data_buffer.extend(segment)
+
+    def finalize_download(self, n):
+        """Return the accumulated download data, trimming the last n unused bytes.
+
+        :param int n:
+            Number of bytes in the last segment that did not contain data
+            (as signalled by the client in the END_BLOCK_TRANSFER command).
+
+        :returns:
+            The complete received data as bytes.
+        """
+        if n > 0:
+            return bytes(self._data_buffer[:-n])
+        return bytes(self._data_buffer)
diff --git a/test/test_local.py b/test/test_local.py
index 6ab94645..c53e3ffc 100644
--- a/test/test_local.py
+++ b/test/test_local.py
@@ -1,5 +1,7 @@
 import time
 import unittest
+import struct
+from unittest.mock import MagicMock, patch
 
 import canopen
 
@@ -37,22 +39,87 @@ def test_expedited_upload(self):
         vendor_id = self.remote_node.sdo[0x1400][1].raw
         self.assertEqual(vendor_id, 0x99)
 
-    def test_block_upload_switch_to_expedite_upload(self):
-        with self.assertRaises(canopen.SdoCommunicationError) as context:
-            with self.remote_node.sdo[0x1008].open('r', block_transfer=True) as fp:
-                pass
-        # We get this since the sdo client don't support the switch
-        # from block upload to expedite upload
-        self.assertEqual("Unexpected response 0x41", str(context.exception))
+    def test_block_download(self):
+        data = b"BLOCK DOWNLOAD TEST DATA"
+        # Write data using block download
+        with self.remote_node.sdo[0x2000].open('wb', size=len(data), block_transfer=True) as fp:
+            fp.write(data)
+        # Read back using block upload (client requests upload from server)
+        with self.remote_node.sdo[0x2000].open('rb', block_transfer=True) as fp:
+            read_data = fp.read()
+        self.assertEqual(read_data, data)
+
+    def test_block_upload_multi_block(self):
+        """Block tranfer of bulk data using multiple blocks. Each block can transfer up to 127 segments of 7 bytes (889 bytes)"""
+        # 70 * 28 = 1960 bytes, exceeds one block (127 segments * 7 bytes = 889 bytes)
+        data = b"Lorem ipsum dolor sit amet. " * 70
+        self.local_node.sdo[0x2000].raw = data.decode("latin-1")
+        with self.remote_node.sdo[0x2000].open('rb', block_transfer=True) as fp:
+            read_data = fp.read()
+        self.assertEqual(read_data, data)
+
+    def test_process_block_up_data_wrong_ackseq(self):
+        """
+        Test that when client acks with wrong seqno, server rolls back data_uploaded to data_successful_upload
+        (the start of the current block) and asks for retransmit.
+        """
+        server = self.local_node.sdo
+        server._index = 0x2000
+        server._subindex = 0
+
+        mock_block = MagicMock()
+        mock_block.state = canopen.sdo.constants.BLOCK_STATE_UP_DATA  # 0x12
+        mock_block.last_seqno = 127          # server sent seqno 1..127
+        mock_block.data_uploaded = 889       # 127 * 7, end of first block
+        mock_block.data_successful_upload = 0
+        mock_block.size = 1960               # two blocks worth, transfer not done
+        mock_block.get_upload_blocks.return_value = []
+        server.sdo_block = mock_block
+
+        # command = REQUEST_BLOCK_UPLOAD (0xA0) | BLOCK_TRANSFER_RESPONSE (0x02) = 0xA2
+        # ackseq = 0 (wrong: last_seqno was 127), newblk = 127
+        request = bytearray(struct.pack("<BBB", 0xA2, 0, 127) + b'\x00' * 5)
+        with patch.object(server, 'send_response'):
+            server.on_request(0x601, request, 0.0)
+
+        # data_uploaded must have been rolled back to data_successful_upload (0)
+        self.assertEqual(mock_block.data_uploaded, 0)
+        # server must have asked for a retransmit block
+        mock_block.get_upload_blocks.assert_called_once()
+        # clean up — leave server in a known state for subsequent tests
+        server.sdo_block = None
+
+    def test_block_upload_invalid_blksize(self):
+        """
+        Test that when client initiates block upload with invalid blksize=0, server aborts with "Invalid block size" (0x05040002).
+        """
+        server = self.local_node.sdo
+        server._index = 0x2000
+        server._subindex = 0
+        server.sdo_block = None
+
+        # REQUEST_BLOCK_UPLOAD (0xA0) with sub-command=0 (INITIATE), index=0x2000, subindex=0, blksize=0
+        request = bytearray(struct.pack("<BHB", 0xA0, 0x2000, 0) + b'\x00' * 4)
+        request[4] = 0  # blksize = 0, invalid
+
+        sent = []
+        with patch.object(server, 'send_response', side_effect=lambda r: sent.append(bytes(r))):
+            server.on_request(0x601, request, 0.0)
+
+        # Server should have sent an abort response (SdoAbortedError caught in on_request)
+        self.assertEqual(len(sent), 1)
+        self.assertEqual(sent[0][0], 0x80)  # RESPONSE_ABORTED
 
     def test_block_download_not_supported(self):
+        # Try block download to an object that should not support it (e.g., a constant string)
         data = b"TEST DEVICE"
         with self.assertRaises(canopen.SdoAbortedError) as context:
             with self.remote_node.sdo[0x1008].open('wb',
                                                    size=len(data),
                                                    block_transfer=True) as fp:
-                pass
-        self.assertEqual(context.exception.code, 0x05040001)
+                fp.write(data)
+        # Accept both possible abort codes for unsupported block download
+        self.assertIn(context.exception.code, [0x05040001, 0x05040003, 0x06010002])
 
     def test_expedited_upload_default_value_visible_string(self):
         device_name = self.remote_node.sdo["Manufacturer device name"].raw
@@ -139,6 +206,57 @@ def test_two_nodes_on_the_bus(self):
         device_name = self.remote_node2.sdo["Manufacturer device name"].data
         self.assertEqual(device_name, b"Some cool device2")
 
+    def test_on_request_block_generic_exception(self):
+        """Test unexpected exception in block processing is handled by aborting the transfer and resetting the block state."""
+        server = self.local_node.sdo
+        # Provide valid index/subindex so abort() can pack the response frame
+        server._index = 0x2000
+        server._subindex = 0
+
+        mock_block = MagicMock()
+        mock_block.state = canopen.sdo.constants.BLOCK_STATE_DL_DATA  # BLOCK_STATE_DL_DATA — non-NONE, keeps branch alive
+        server.sdo_block = mock_block
+
+        with patch.object(server, 'process_block', side_effect=RuntimeError("unexpected")):
+            with self.assertRaises(RuntimeError):
+                server.on_request(0x601, bytearray(8), 0.0)
+
+        self.assertIsNone(server.sdo_block)
+
+    def test_process_block_abort_command(self):
+        """Client sends abort (0x80) during block transfer; server clears sdo_block and sends no response."""
+        server = self.local_node.sdo
+
+        mock_block = MagicMock()
+        mock_block.state = canopen.sdo.constants.BLOCK_STATE_DL_DATA  # BLOCK_STATE_DL_DATA — active block state
+        server.sdo_block = mock_block
+
+        sent = []
+        with patch.object(server, 'send_response', side_effect=lambda r: sent.append(bytes(r))):
+            # SDO_ABORT_STRUCT = "<BHBI": command, index, subindex, abort_code
+            abort_frame = bytearray(struct.pack("<BHBI", 0x80, 0x2000, 0, 0x05040003))
+            server.on_request(0x601, abort_frame, 0.0)
+
+        self.assertIsNone(server.sdo_block)
+        self.assertEqual(sent, [])  # server does not reply to an abort
+        
+    def test_on_request_unknown_command(self):
+        """CCS with no matching command triggers abort(0x05040001)."""
+        server = self.local_node.sdo
+        server._index = 0
+        server._subindex = 0
+
+        sent = []
+        with patch.object(server, 'send_response', side_effect=lambda r: sent.append(bytes(r))):
+            # 0xE0 = CCS 7 (0b111 << 5), not a valid command
+            server.on_request(0x601, bytearray([0xE0, 0, 0, 0, 0, 0, 0, 0]), 0.0)
+
+        self.assertEqual(len(sent), 1)
+        self.assertEqual(sent[0][0], 0x80)  # RESPONSE_ABORTED = 4 << 5
+
+        abort_code, = struct.unpack_from("<L", sent[0], 4)
+        self.assertEqual(abort_code, 0x05040001)
+
     def test_abort(self):
         with self.assertRaises(canopen.SdoAbortedError) as cm:
             _ = self.remote_node.sdo.upload(0x1234, 0)
@@ -178,6 +296,29 @@ def test_callbacks(self):
         self.assertEqual(self._kwargs["data"], b"\x03\x04")
 
 
+class TestSdoBlock(unittest.TestCase):
+    """Unit tests for _SdoBlock internals."""
+
+    def test_update_state_backwards_raises(self):
+        """Line 462: update_state raises when new_state < current state."""
+        mock_node = MagicMock()
+        # command = REQUEST_BLOCK_DOWNLOAD (0xC0) | BLOCK_SIZE_SPECIFIED (0x02) = 0xC2
+        request = struct.pack("<BHBI", 0xC2, 0x2000, 0, 10)
+        block = canopen.sdo.server._SdoBlock(mock_node, request, is_download=True)
+        block.update_state(canopen.sdo.constants.BLOCK_STATE_DL_DATA)
+        with self.assertRaises(canopen.sdo.exceptions.SdoAbortedError):
+            block.update_state(canopen.sdo.constants.BLOCK_STATE_DL_DATA - 1)
+
+    def test_finalize_download_no_padding(self):
+        """Line 527: finalize_download with n=0 returns full buffer."""
+        mock_node = MagicMock()
+        request = struct.pack("<BHBI", 0xC2, 0x2000, 0, 7)
+        block = canopen.sdo.server._SdoBlock(mock_node, request, is_download=True)
+        block.append_download_data(b"ABCDEFG")
+        result = block.finalize_download(0)
+        self.assertEqual(result, b"ABCDEFG")
+
+
 class TestPDO(unittest.TestCase):
     """
     Test PDO slave.
diff --git a/test/test_sdo.py b/test/test_sdo.py
index ebf7a8f3..c7b63a98 100644
--- a/test/test_sdo.py
+++ b/test/test_sdo.py
@@ -1,8 +1,11 @@
+import struct
+import time
 import unittest
-
 import canopen
 import canopen.objectdictionary.datatypes as dt
+from can import CanError
 from canopen.objectdictionary import ODVariable
+from canopen.sdo.constants import *
 
 from .util import DATATYPES_EDS, SAMPLE_EDS
 
@@ -57,6 +60,63 @@ def test_array_contains_non_int(self):
     def test_get_variable_not_found(self):
         self.assertIsNone(self.sdo_node.get_variable(0x9999))
 
+    def test_sdo_base_len(self):
+        """SdoBase.__len__ returns the number of entries in the OD."""
+        self.assertGreater(len(self.sdo_node), 0)
+
+    def test_sdo_base_contains(self):
+        """SdoBase.__contains__ checks membership in the OD."""
+        self.assertIn(0x1008, self.sdo_node)
+        self.assertNotIn(0x9999, self.sdo_node)
+
+    def test_get_variable_sdo_variable(self):
+        """get_variable returns an SdoVariable when the entry is a plain variable."""
+        var = self.sdo_node.get_variable(0x1008)
+        self.assertIsInstance(var, canopen.sdo.SdoVariable)
+        self.assertIn("Manufacturer device name", var.name)
+
+    def test_get_variable_record_subindex(self):
+        """get_variable returns an SdoVariable for a subindex of a record."""
+        var = self.sdo_node.get_variable(0x1018, 1)
+        self.assertIsInstance(var, canopen.sdo.SdoVariable)
+        self.assertIn("Vendor-ID", var.name)
+
+    def test_sdo_record_repr(self):
+        """SdoRecord.__repr__ includes the OD index."""
+        r = repr(self.sdo_node[0x1018])
+        self.assertIsInstance(r, str)
+        self.assertIn("0x1018", r)
+
+    def test_sdo_array_repr(self):
+        """SdoArray.__repr__ returns a non-empty string."""
+        r = repr(self.sdo_node[0x1003])
+        self.assertIsInstance(r, str)
+        self.assertIn("0x1003", r)
+
+    def test_sdo_array_contains_int(self):
+        """SdoArray.__contains__ returns True for a valid integer subindex."""
+        array = self.sdo_node[0x1003]
+        self.assertIn(0, array) # Subindex 0 is the "highest subindex supported" entry
+        self.assertEqual(array[0].subindex, 0)
+        self.assertIn(1, array)
+        self.assertEqual(array[1].subindex, 1)
+        self.assertIn("Pre-defined error field_1", array[1].name)
+        self.assertIn(2, array)
+        self.assertEqual(array[2].subindex, 2)
+        # actually returns Pre-defined error field_1_2, probably due to comment in EDS: ; [1003sub2] left out for testing?
+        # self.assertIn("Pre-defined error field_3", array[2].name) 
+        self.assertIn(3, array)
+        self.assertEqual(array[3].subindex, 3)
+        self.assertIn("Pre-defined error field_3", array[3].name)
+        
+    def test_sdo_variable_readwriteable(self):
+        """SdoVariable.readable returns the od.readable property. Same for writable."""
+        var = self.sdo_node[0x1008]
+        self.assertIsInstance(var.readable, bool)
+        self.assertTrue(var.readable)
+        self.assertIsInstance(var.writable, bool)
+        self.assertFalse(var.writable)
+
 
 class TestSDO(unittest.TestCase):
     """
@@ -92,7 +152,7 @@ def setUp(self):
     def test_expedited_upload(self):
         self.data = [
             (TX, b'\x40\x18\x10\x01\x00\x00\x00\x00'),
-            (RX, b'\x43\x18\x10\x01\x04\x00\x00\x00')
+            (RX, b'\x43\x18\x10\x01\x04\x00\x00\x00'),
         ]
         vendor_id = self.network[2].sdo[0x1018][1].raw
         self.assertEqual(vendor_id, 4)
@@ -117,7 +177,7 @@ def test_expedited_upload(self):
     def test_size_not_specified(self):
         self.data = [
             (TX, b'\x40\x00\x14\x02\x00\x00\x00\x00'),
-            (RX, b'\x42\x00\x14\x02\xfe\x00\x00\x00')
+            (RX, b'\x42\x00\x14\x02\xfe\x00\x00\x00'),
         ]
         # This method used to truncate to 1 byte, but returns raw content now
         data = self.network[2].sdo.upload(0x1400, 2)
@@ -127,7 +187,7 @@ def test_size_not_specified(self):
     def test_expedited_download(self):
         self.data = [
             (TX, b'\x2b\x17\x10\x00\xa0\x0f\x00\x00'),
-            (RX, b'\x60\x17\x10\x00\x00\x00\x00\x00')
+            (RX, b'\x60\x17\x10\x00\x00\x00\x00\x00'),
         ]
         self.network[2].sdo[0x1017].raw = 4000
         self.assertTrue(self.message_sent)
@@ -135,15 +195,15 @@ def test_expedited_download(self):
     def test_segmented_upload(self):
         self.data = [
             (TX, b'\x40\x08\x10\x00\x00\x00\x00\x00'),
-            (RX, b'\x41\x08\x10\x00\x1A\x00\x00\x00'),
+            (RX, b'\x41\x08\x10\x00\x1a\x00\x00\x00'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x54\x69\x6E\x79\x20\x4E\x6F'),
+            (RX, b'\x00\x54\x69\x6e\x79\x20\x4e\x6f'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x10\x64\x65\x20\x2D\x20\x4D\x65'),
+            (RX, b'\x10\x64\x65\x20\x2d\x20\x4d\x65'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x67\x61\x20\x44\x6F\x6D\x61'),
+            (RX, b'\x00\x67\x61\x20\x44\x6f\x6d\x61'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x15\x69\x6E\x73\x20\x21\x00\x00')
+            (RX, b'\x15\x69\x6e\x73\x20\x21\x00\x00'),
         ]
         device_name = self.network[2].sdo[0x1008].raw
         self.assertEqual(device_name, "Tiny Node - Mega Domains !")
@@ -159,6 +219,86 @@ def test_segmented_upload_too_much_data(self):
         device_name = self.network[2].sdo[0x1008].raw
         self.assertEqual(device_name, "Tiny")
 
+    def test_segmented_upload_toggle_bit_mismatch(self):
+        """Server returns wrong toggle bit; client aborts and raises SdoCommunicationError."""
+        self.data = [
+            (TX, b'\x40\x08\x10\x00\x00\x00\x00\x00'),  # upload initiate 0x1008:00
+            (RX, b'\x41\x08\x10\x00\x0a\x00\x00\x00'),  # segmented, size=10
+            (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),  # first segment request, toggle=0
+            (RX, b'\x10\x41\x42\x43\x44\x45\x46\x47'),  # server returns toggle=1 (wrong)
+            (TX, b'\x80\x00\x00\x00\x00\x00\x03\x05'),  # abort: TOGGLE_NOT_ALTERNATED
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            _ = self.network[2].sdo[0x1008].raw
+        self.assertIn("Toggle bit mismatch", str(cm.exception))
+
+    def test_upload_initiate_unexpected_response(self):
+        """ReadableStream raises when server response command is not RESPONSE_UPLOAD."""
+        self.data = [
+            (TX, b'\x40\x18\x10\x01\x00\x00\x00\x00'),  # upload initiate 0x1018:01
+            (RX, b'\x20\x18\x10\x01\x00\x00\x00\x00'),  # bad: 0x20 & 0xE0 = 0x20 ≠ 0x40
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            _ = self.network[2].sdo[0x1018][1].raw
+        self.assertIn("Unexpected response 0x20", str(cm.exception))
+
+    def test_upload_initiate_wrong_index(self):
+        """ReadableStream raises when server responds for a different index."""
+        self.data = [
+            (TX, b'\x40\x18\x10\x01\x00\x00\x00\x00'),  # upload initiate 0x1018:01
+            (RX, b'\x43\x00\x20\x00\x04\x00\x00\x00'),  # response for 0x2000:00 instead
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            _ = self.network[2].sdo[0x1018][1].raw
+        self.assertIn("0x2000", str(cm.exception))
+
+    def test_segmented_upload_unexpected_segment_response(self):
+        """ReadableStream aborts and raises when segment response command is wrong."""
+        self.data = [
+            (TX, b'\x40\x08\x10\x00\x00\x00\x00\x00'),  # upload initiate 0x1008:00
+            (RX, b'\x41\x08\x10\x00\x0a\x00\x00\x00'),  # segmented, size=10
+            (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),  # segment request, toggle=0
+            (RX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),  # bad: 0x60 & 0xE0 = 0x60 ≠ 0x00
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort: INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            _ = self.network[2].sdo[0x1008].raw
+        self.assertIn("Unexpected response 0x60", str(cm.exception))
+
+    def test_segmented_download_initiate_unexpected_response(self):
+        """WritableStream aborts and raises when download initiate response command is wrong."""
+        self.data = [
+            (TX, b'\x21\x00\x20\x00\x0a\x00\x00\x00'),  # segmented download 0x2000:00, size=10
+            (RX, b'\x40\x00\x20\x00\x00\x00\x00\x00'),  # bad: 0x40 ≠ RESPONSE_DOWNLOAD 0x60
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort: INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            self.network[2].sdo[0x2000].raw = 'ABCDEFGHIJ'
+        self.assertIn("Unexpected response 0x40", str(cm.exception))
+
+    def test_expedited_download_unexpected_response(self):
+        """WritableStream aborts and raises when expedited download response command is wrong."""
+        self.data = [
+            (TX, b'\x2f\x00\x14\x02\xff\x00\x00\x00'),  # expedited download 0x1400:02
+            (RX, b'\x40\x00\x14\x02\x00\x00\x00\x00'),  # bad: 0x40 & 0xE0 = 0x40 ≠ 0x60
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort: INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError):
+            self.network[2].sdo[0x1400][2].raw = 0xff
+
+    def test_segmented_download_write_unexpected_response(self):
+        """WritableStream aborts and raises when the segment download response command is wrong."""
+        self.data = [
+            (TX, b'\x21\x00\x20\x00\x0d\x00\x00\x00'),  # segmented download 0x2000:00, size=13
+            (RX, b'\x60\x00\x20\x00\x00\x00\x00\x00'),  # RESPONSE_DOWNLOAD OK
+            (TX, b'\x00\x41\x20\x6c\x6f\x6e\x67\x20'),  # first segment 'A long ', toggle=0
+            (RX, b'\x40\x00\x00\x00\x00\x00\x00\x00'),  # bad: 0x40 & 0xE0 = 0x40 ≠ 0x20
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort: INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            self.network[2].sdo[0x2000].raw = 'A long string'
+        self.assertIn("expected 0x20", str(cm.exception))
+
     def test_segmented_download(self):
         self.data = [
             (TX, b'\x21\x00\x20\x00\x0d\x00\x00\x00'),
@@ -166,9 +306,9 @@ def test_segmented_download(self):
             (TX, b'\x00\x41\x20\x6c\x6f\x6e\x67\x20'),
             (RX, b'\x20\x00\x20\x00\x00\x00\x00\x00'),
             (TX, b'\x13\x73\x74\x72\x69\x6e\x67\x00'),
-            (RX, b'\x30\x00\x20\x00\x00\x00\x00\x00')
+            (RX, b'\x30\x00\x20\x00\x00\x00\x00\x00'),
         ]
-        self.network[2].sdo['Writable string'].raw = 'A long string'
+        self.network[2].sdo["Writable string"].raw = 'A long string'
 
     def test_block_download(self):
         self.data = [
@@ -181,13 +321,194 @@ def test_block_download(self):
             (TX, b'\x85\x2e\x2e\x00\x00\x00\x00\x00'),
             (RX, b'\xa2\x05\x7f\x00\x00\x00\x00\x00'),
             (TX, b'\xd5\x45\x69\x00\x00\x00\x00\x00'),
-            (RX, b'\xa1\x00\x00\x00\x00\x00\x00\x00')
+            (RX, b'\xa1\x00\x00\x00\x00\x00\x00\x00'),
         ]
         data = b'A really really long string...'
-        with self.network[2].sdo['Writable string'].open(
-            'wb', size=len(data), block_transfer=True) as fp:
+        with (
+            self.network[2]
+            .sdo["Writable string"]
+            .open('wb', size=len(data), block_transfer=True) as fp
+        ):
+            fp.write(data)
+
+    def test_block_download_retransmit(self):
+        """Server acknowledges only 3 of 5 sequences; client must retransmit the rest."""
+        self.data = [
+            (TX, b'\xc6\x00\x20\x00\x23\x00\x00\x00'),  # init block download, size=35, CRC
+            (RX, b'\xa4\x00\x20\x00\x05\x00\x00\x00'),  # server init resp, blksize=5, CRC
+            (TX, b'\x01\x41\x42\x43\x44\x45\x46\x47'),  # seq 1: ABCDEFG
+            (TX, b'\x02\x48\x49\x4a\x4b\x4c\x4d\x4e'),  # seq 2: HIJKLMN
+            (TX, b'\x03\x4f\x50\x51\x52\x53\x54\x55'),  # seq 3: OPQRSTU
+            (TX, b'\x04\x56\x57\x58\x59\x5a\x31\x32'),  # seq 4: VWXYZ12
+            (TX, b'\x85\x33\x34\x35\x36\x37\x38\x39'),  # seq 5 (NO_MORE_BLOCKS): 3456789
+            (RX, b'\xa2\x03\x05\x00\x00\x00\x00\x00'),  # ack: only 3 received, blksize=5
+            (TX, b'\x01\x56\x57\x58\x59\x5a\x31\x32'),  # retransmit seq 1: VWXYZ12
+            (TX, b'\x82\x33\x34\x35\x36\x37\x38\x39'),  # retransmit seq 2 (NO_MORE_BLOCKS): 3456789
+            (RX, b'\xa2\x02\x05\x00\x00\x00\x00\x00'),  # ack: all 2 received, blksize=5
+            (TX, b'\xc1\x80\x00\x00\x00\x00\x00\x00'),  # end block transfer, CRC=0x0080
+            (RX, b'\xa1\x00\x00\x00\x00\x00\x00\x00'),  # server confirms end
+        ]
+        data = b'ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789'
+        with (
+            self.network[2]
+            .sdo["Writable string"]
+            .open('wb', size=len(data), block_transfer=True) as fp
+        ):
             fp.write(data)
 
+    def test_block_download_initiate_unexpected_response(self):
+        """BlockDownloadStream aborts and raises when block download initiate response is wrong."""
+        data = b'A really really long string...'  # 30 bytes
+        self.data = [
+            (TX, b'\xc6\x00\x20\x00\x1e\x00\x00\x00'),  # block download initiate, size=30
+            (RX, b'\x40\x00\x20\x00\x00\x00\x00\x00'),  # bad: 0x40 & 0xE0 = 0x40 ≠ 0xA0
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort: INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo["Writable string"].open('wb', size=len(data), block_transfer=True) as fp:
+                fp.write(data)
+        self.assertIn("Unexpected response 0x40", str(cm.exception))
+
+    def test_block_upload_initiate_unexpected_response(self):
+        """BlockUploadStream aborts and raises when block upload initiate response is wrong."""
+        self.data = [
+            (TX, b'\xa4\x08\x10\x00\x7f\x00\x00\x00'),  # block upload initiate 0x1008:00
+            (RX, b'\x40\x08\x10\x00\x00\x00\x00\x00'),  # bad: 0x40 & 0xE0 = 0x40 ≠ 0xC0
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort: INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo[0x1008].open('rb', block_transfer=True) as fp:
+                fp.read()
+        self.assertIn("Unexpected response 0x40", str(cm.exception))
+
+    def test_block_download_unsuccessful(self):
+        """BlockDownloadStream.close raises when server does not confirm end block transfer."""
+        data = b'A really really long string...'  # 30 bytes
+        self.data = [
+            (TX, b'\xc6\x00\x20\x00\x1e\x00\x00\x00'),
+            (RX, b'\xa4\x00\x20\x00\x7f\x00\x00\x00'),
+            (TX, b'\x01\x41\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x02\x79\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x03\x79\x20\x6c\x6f\x6e\x67\x20'),
+            (TX, b'\x04\x73\x74\x72\x69\x6e\x67\x2e'),
+            (TX, b'\x85\x2e\x2e\x00\x00\x00\x00\x00'),
+            (RX, b'\xa2\x05\x7f\x00\x00\x00\x00\x00'),
+            (TX, b'\xd5\x45\x69\x00\x00\x00\x00\x00'),
+            (RX, b'\xa0\x00\x00\x00\x00\x00\x00\x00'),  # bad: END_BLOCK_TRANSFER bit not set
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo["Writable string"].open('wb', size=len(data), block_transfer=True) as fp:
+                fp.write(data)
+        self.assertIn("Block download unsuccessful", str(cm.exception))
+
+    def test_block_download_no_crc(self):
+        """Block download with request_crc_support=False omits CRC bytes."""
+        data = b'A really really long string...'  # 30 bytes
+        self.data = [
+            (TX, b'\xc2\x00\x20\x00\x1e\x00\x00\x00'),  # init: BLOCK_SIZE_SPECIFIED, no CRC_SUPPORTED
+            (RX, b'\xa0\x00\x20\x00\x7f\x00\x00\x00'),  # server resp: blksize=127, no CRC
+            (TX, b'\x01\x41\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x02\x79\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x03\x79\x20\x6c\x6f\x6e\x67\x20'),
+            (TX, b'\x04\x73\x74\x72\x69\x6e\x67\x2e'),
+            (TX, b'\x85\x2e\x2e\x00\x00\x00\x00\x00'),
+            (RX, b'\xa2\x05\x7f\x00\x00\x00\x00\x00'),
+            (TX, b'\xd5\x00\x00\x00\x00\x00\x00\x00'),  # end: no CRC bytes
+            (RX, b'\xa1\x00\x00\x00\x00\x00\x00\x00'),
+        ]
+        with self.network[2].sdo["Writable string"].open(
+                'wb', size=len(data), block_transfer=True, request_crc_support=False) as fp:
+            fp.write(data)
+
+    def test_block_download_block_ack_wrong_command(self):
+        """BlockDownloadStream._block_ack aborts when the ACK command byte is wrong."""
+        data = b'A really really long string...'  # 30 bytes
+        self.data = [
+            (TX, b'\xc6\x00\x20\x00\x1e\x00\x00\x00'),
+            (RX, b'\xa4\x00\x20\x00\x7f\x00\x00\x00'),
+            (TX, b'\x01\x41\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x02\x79\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x03\x79\x20\x6c\x6f\x6e\x67\x20'),
+            (TX, b'\x04\x73\x74\x72\x69\x6e\x67\x2e'),
+            (TX, b'\x85\x2e\x2e\x00\x00\x00\x00\x00'),
+            (RX, b'\x62\x05\x7f\x00\x00\x00\x00\x00'),  # bad: 0x62 & 0xE0 = 0x60 != RESPONSE_BLOCK_DOWNLOAD
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort INVALID_COMMAND_SPECIFIER
+            # close() runs in finally block and sends END_BLOCK_TRANSFER (CRC included, _done=True)
+            (TX, b'\xd5\x45\x69\x00\x00\x00\x00\x00'),
+            (RX, b'\xa1\x00\x00\x00\x00\x00\x00\x00'),
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo["Writable string"].open(
+                    'wb', size=len(data), block_transfer=True) as fp:
+                fp.write(data)
+        self.assertIn("Unexpected response 0x62", str(cm.exception))
+
+    def test_block_download_block_ack_no_transfer_response(self):
+        """BlockDownloadStream._block_ack aborts when BLOCK_TRANSFER_RESPONSE bit is not set."""
+        data = b'A really really long string...'  # 30 bytes
+        self.data = [
+            (TX, b'\xc6\x00\x20\x00\x1e\x00\x00\x00'),
+            (RX, b'\xa4\x00\x20\x00\x7f\x00\x00\x00'),
+            (TX, b'\x01\x41\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x02\x79\x20\x72\x65\x61\x6c\x6c'),
+            (TX, b'\x03\x79\x20\x6c\x6f\x6e\x67\x20'),
+            (TX, b'\x04\x73\x74\x72\x69\x6e\x67\x2e'),
+            (TX, b'\x85\x2e\x2e\x00\x00\x00\x00\x00'),
+            (RX, b'\xa0\x05\x7f\x00\x00\x00\x00\x00'),  # bad: 0xA0 & 0x3 = 0 != BLOCK_TRANSFER_RESPONSE
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),  # abort INVALID_COMMAND_SPECIFIER
+            (TX, b'\xd5\x45\x69\x00\x00\x00\x00\x00'),  # close() END_BLOCK_TRANSFER (CRC)
+            (RX, b'\xa1\x00\x00\x00\x00\x00\x00\x00'),
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo["Writable string"].open(
+                    'wb', size=len(data), block_transfer=True) as fp:
+                fp.write(data)
+        self.assertIn("block download response", str(cm.exception))
+
+    def test_block_download_wrong_index_response(self):
+        """BlockDownloadStream aborts when server responds with wrong index."""
+        data = b'A really really long string...'  # 30 bytes
+        self.data = [
+            (TX, b'\xc6\x00\x20\x00\x1e\x00\x00\x00'),   # init for 0x2000:00
+            (RX, b'\xa4\x08\x10\x00\x7f\x00\x00\x00'),   # server responds for 0x1008:00 (wrong)
+            (TX, b'\x80\x00\x00\x00\x00\x00\x00\x08'),   # abort GENERAL_ERROR
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo["Writable string"].open(
+                    'wb', size=len(data), block_transfer=True) as fp:
+                fp.write(data)
+        self.assertIn("0x1008", str(cm.exception))
+
+    def test_block_upload_wrong_index_response(self):
+        """BlockUploadStream raises when server responds with wrong index (no abort sent)."""
+        self.data = [
+            (TX, b'\xa4\x08\x10\x00\x7f\x00\x00\x00'),   # initiate for 0x1008:00
+            (RX, b'\xc4\x00\x20\x00\x1a\x00\x00\x00'),   # server responds for 0x2000:00 (wrong)
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo[0x1008].open('rb', block_transfer=True) as fp:
+                fp.read()
+        self.assertIn("0x2000", str(cm.exception))
+
+    def test_block_upload_end_unexpected_response(self):
+        """BlockUploadStream._end_upload aborts when end-of-block response has wrong command."""
+        self.data = [
+            (TX, b'\xa4\x08\x10\x00\x7f\x00\x00\x00'),
+            (RX, b'\xc6\x08\x10\x00\x1a\x00\x00\x00'),
+            (TX, b'\xa3\x00\x00\x00\x00\x00\x00\x00'),
+            (RX, b'\x01\x54\x69\x6e\x79\x20\x4e\x6f'),
+            (RX, b'\x02\x64\x65\x20\x2d\x20\x4d\x65'),
+            (RX, b'\x03\x67\x61\x20\x44\x6f\x6d\x61'),
+            (RX, b'\x84\x69\x6e\x73\x20\x21\x00\x00'),
+            (TX, b'\xa2\x04\x7f\x00\x00\x00\x00\x00'),
+            (RX, b'\x40\x40\xe1\x00\x00\x00\x00\x00'),   # bad: 0x40 & 0xE0 = 0x40 != RESPONSE_BLOCK_UPLOAD
+            (TX, b'\x80\x00\x00\x00\x01\x00\x04\x05'),   # abort INVALID_COMMAND_SPECIFIER
+        ]
+        with self.assertRaises(canopen.SdoCommunicationError) as cm:
+            with self.network[2].sdo[0x1008].open('r', block_transfer=True) as fp:
+                fp.read()
+        self.assertIn("Unexpected response 0x40", str(cm.exception))
+
     def test_segmented_download_zero_length(self):
         self.data = [
             (TX, b'\x21\x00\x20\x00\x00\x00\x00\x00'),
@@ -520,6 +841,26 @@ def test_sdo_block_upload_retransmit(self):
             data = fp.read()
         self.assertEqual(data, 39 * 'the crazy fox jumps over the lazy dog\n')
 
+    def test_block_upload_wrong_seqno(self):
+        """Server sends wrong sequence number first; client must retransmit and recover."""
+        self.data = [
+            (TX, b'\xa4\x08\x10\x00\x7f\x00\x00\x00'),  # init block upload
+            (RX, b'\xc6\x08\x10\x00\x1a\x00\x00\x00'),  # server init resp, size=26
+            (TX, b'\xa3\x00\x00\x00\x00\x00\x00\x00'),  # start upload
+            (RX, b'\x02\x54\x69\x6e\x79\x20\x4e\x6f'),  # WRONG: seqno=2 instead of 1
+            (TX, b'\xa2\x00\x7f\x00\x00\x00\x00\x00'),  # retransmit request: ack_block ackseq=0
+            (RX, b'\x01\x54\x69\x6e\x79\x20\x4e\x6f'),  # seqno=1 "Tiny No"
+            (RX, b'\x02\x64\x65\x20\x2d\x20\x4d\x65'),  # seqno=2 "de - Me"
+            (RX, b'\x03\x67\x61\x20\x44\x6f\x6d\x61'),  # seqno=3 "ga Doma"
+            (RX, b'\x84\x69\x6e\x73\x20\x21\x00\x00'),  # seqno=4 NO_MORE_BLOCKS "ins !"
+            (TX, b'\xa2\x04\x7f\x00\x00\x00\x00\x00'),  # ack_block ackseq=4
+            (RX, b'\xc9\x40\xe1\x00\x00\x00\x00\x00'),  # end block upload
+            (TX, b'\xa1\x00\x00\x00\x00\x00\x00\x00'),  # end ack
+        ]
+        with self.network[2].sdo[0x1008].open('r', block_transfer=True) as fp:
+            data = fp.read()
+        self.assertEqual(data, 'Tiny Node - Mega Domains !')
+
     def test_writable_file(self):
         self.data = [
             (TX, b'\x20\x00\x20\x00\x00\x00\x00\x00'),
@@ -529,9 +870,9 @@ def test_writable_file(self):
             (TX, b'\x1a\x38\x39\x00\x00\x00\x00\x00'),
             (RX, b'\x30\x00\x20\x00\x00\x00\x00\x00'),
             (TX, b'\x0f\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x20\x00\x20\x00\x00\x00\x00\x00')
+            (RX, b'\x20\x00\x20\x00\x00\x00\x00\x00'),
         ]
-        with self.network[2].sdo['Writable string'].open('wb') as fp:
+        with self.network[2].sdo["Writable string"].open('wb') as fp:
             fp.write(b'1234')
             fp.write(b'56789')
         self.assertTrue(fp.closed)
@@ -542,7 +883,7 @@ def test_writable_file(self):
     def test_abort(self):
         self.data = [
             (TX, b'\x40\x18\x10\x01\x00\x00\x00\x00'),
-            (RX, b'\x80\x18\x10\x01\x11\x00\x09\x06')
+            (RX, b'\x80\x18\x10\x01\x11\x00\x09\x06'),
         ]
         with self.assertRaises(canopen.SdoAbortedError) as cm:
             _ = self.network[2].sdo[0x1018][1].raw
@@ -552,6 +893,58 @@ def test_add_sdo_channel(self):
         client = self.network[2].add_sdo(0x123456, 0x234567)
         self.assertIn(client, self.network[2].sdo_channels)
 
+    def test_send_request_retries_on_can_error(self):
+        """send_request retries after a CanError and succeeds on the next attempt."""
+        call_count = [0]
+
+        def send_with_one_failure(can_id, data, remote=False):
+            call_count[0] += 1
+            if call_count[0] == 1:
+                raise CanError("Simulated buffer overflow")
+            self._send_message(can_id, data, remote)
+
+        self.network[2].sdo.MAX_RETRIES = 2
+        self.network.send_message = send_with_one_failure
+        self.data = [
+            (TX, b'\x40\x18\x10\x01\x00\x00\x00\x00'),
+            (RX, b'\x43\x18\x10\x01\x04\x00\x00\x00'),
+        ]
+        vendor_id = self.network[2].sdo[0x1018][1].raw
+        self.assertEqual(vendor_id, 4)
+        self.assertEqual(call_count[0], 2)
+
+    def test_send_request_raises_after_retries_exhausted(self):
+        """send_request raises CanError when all retries are exhausted."""
+        def always_fail(can_id, data, remote=False):
+            raise CanError("Simulated buffer overflow")
+
+        self.network[2].sdo.MAX_RETRIES = 1
+        self.network.send_message = always_fail
+        with self.assertRaises(CanError):
+            _ = self.network[2].sdo[0x1018][1].raw
+
+    def test_pause_before_send_delays_message(self):
+        """send_request does not send before PAUSE_BEFORE_SEND seconds have elapsed."""
+        pause = 0.05
+        self.network[2].sdo.PAUSE_BEFORE_SEND = pause
+        send_times = []
+
+        def timed_send(can_id, data, remote=False):
+            send_times.append(time.monotonic())
+            self._send_message(can_id, data, remote)
+
+        self.network.send_message = timed_send
+        self.data = [
+            (TX, b'\x40\x18\x10\x01\x00\x00\x00\x00'),
+            (RX, b'\x43\x18\x10\x01\x04\x00\x00\x00'),
+        ]
+        start = time.monotonic()
+        _ = self.network[2].sdo[0x1018][1].raw
+        self.assertTrue(send_times, "send_message was never called")
+        elapsed = send_times[0] - start
+        self.assertGreaterEqual(elapsed, pause,
+            f"Message sent too early: {elapsed:.4f}s < {pause}s pause")
+
 
 class TestSDOClientDatatypes(unittest.TestCase):
     """Test the SDO client uploads with the different data types in CANopen."""
@@ -563,7 +956,7 @@ def _send_message(self, can_id, data, remote=False):
         with the provided data.
         """
         next_data = self.data.pop(0)
-        self.assertEqual(next_data[0], TX, "No transmission was expected")
+        self.assertEqual(next_data[0], TX, 'No transmission was expected')
         self.assertSequenceEqual(data, next_data[1])
         self.assertEqual(can_id, 0x602)
         while self.data and self.data[0][0] == RX:
@@ -581,7 +974,7 @@ def setUp(self):
     def test_boolean(self):
         self.data = [
             (TX, b'\x40\x01\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x4f\x01\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x4f\x01\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.BOOLEAN, 0)
         self.assertEqual(data, b'\xfe')
@@ -589,7 +982,7 @@ def test_boolean(self):
     def test_unsigned8(self):
         self.data = [
             (TX, b'\x40\x05\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x4f\x05\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x4f\x05\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.UNSIGNED8, 0)
         self.assertEqual(data, b'\xfe')
@@ -597,7 +990,7 @@ def test_unsigned8(self):
     def test_unsigned16(self):
         self.data = [
             (TX, b'\x40\x06\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x4b\x06\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x4b\x06\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.UNSIGNED16, 0)
         self.assertEqual(data, b'\xfe\xfd')
@@ -605,7 +998,7 @@ def test_unsigned16(self):
     def test_unsigned24(self):
         self.data = [
             (TX, b'\x40\x16\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x47\x16\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x47\x16\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.UNSIGNED24, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc')
@@ -613,7 +1006,7 @@ def test_unsigned24(self):
     def test_unsigned32(self):
         self.data = [
             (TX, b'\x40\x07\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x43\x07\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x43\x07\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.UNSIGNED32, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc\xfb')
@@ -663,7 +1056,7 @@ def test_unsigned64(self):
     def test_integer8(self):
         self.data = [
             (TX, b'\x40\x02\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x4f\x02\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x4f\x02\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.INTEGER8, 0)
         self.assertEqual(data, b'\xfe')
@@ -671,7 +1064,7 @@ def test_integer8(self):
     def test_integer16(self):
         self.data = [
             (TX, b'\x40\x03\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x4b\x03\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x4b\x03\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.INTEGER16, 0)
         self.assertEqual(data, b'\xfe\xfd')
@@ -679,7 +1072,7 @@ def test_integer16(self):
     def test_integer24(self):
         self.data = [
             (TX, b'\x40\x10\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x47\x10\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x47\x10\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.INTEGER24, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc')
@@ -687,7 +1080,7 @@ def test_integer24(self):
     def test_integer32(self):
         self.data = [
             (TX, b'\x40\x04\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x43\x04\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x43\x04\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.INTEGER32, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc\xfb')
@@ -737,7 +1130,7 @@ def test_integer64(self):
     def test_real32(self):
         self.data = [
             (TX, b'\x40\x08\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x43\x08\x20\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x43\x08\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.REAL32, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc\xfb')
@@ -757,15 +1150,15 @@ def test_real64(self):
     def test_visible_string(self):
         self.data = [
             (TX, b'\x40\x09\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x41\x09\x20\x00\x1A\x00\x00\x00'),
+            (RX, b'\x41\x09\x20\x00\x1a\x00\x00\x00'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x54\x69\x6E\x79\x20\x4E\x6F'),
+            (RX, b'\x00\x54\x69\x6e\x79\x20\x4e\x6f'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x10\x64\x65\x20\x2D\x20\x4D\x65'),
+            (RX, b'\x10\x64\x65\x20\x2d\x20\x4d\x65'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x67\x61\x20\x44\x6F\x6D\x61'),
+            (RX, b'\x00\x67\x61\x20\x44\x6f\x6d\x61'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x15\x69\x6E\x73\x20\x21\x00\x00')
+            (RX, b'\x15\x69\x6e\x73\x20\x21\x00\x00'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.VISIBLE_STRING, 0)
         self.assertEqual(data, b'Tiny Node - Mega Domains !')
@@ -773,15 +1166,15 @@ def test_visible_string(self):
     def test_unicode_string(self):
         self.data = [
             (TX, b'\x40\x0b\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x41\x0b\x20\x00\x1A\x00\x00\x00'),
+            (RX, b'\x41\x0b\x20\x00\x1a\x00\x00\x00'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x54\x69\x6E\x79\x20\x4E\x6F'),
+            (RX, b'\x00\x54\x69\x6e\x79\x20\x4e\x6f'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x10\x64\x65\x20\x2D\x20\x4D\x65'),
+            (RX, b'\x10\x64\x65\x20\x2d\x20\x4d\x65'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x67\x61\x20\x44\x6F\x6D\x61'),
+            (RX, b'\x00\x67\x61\x20\x44\x6f\x6d\x61'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x15\x69\x6E\x73\x20\x21\x00\x00')
+            (RX, b'\x15\x69\x6e\x73\x20\x21\x00\x00'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.UNICODE_STRING, 0)
         self.assertEqual(data, b'Tiny Node - Mega Domains !')
@@ -789,15 +1182,15 @@ def test_unicode_string(self):
     def test_octet_string(self):
         self.data = [
             (TX, b'\x40\x0a\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x41\x0a\x20\x00\x1A\x00\x00\x00'),
+            (RX, b'\x41\x0a\x20\x00\x1a\x00\x00\x00'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x54\x69\x6E\x79\x20\x4E\x6F'),
+            (RX, b'\x00\x54\x69\x6e\x79\x20\x4e\x6f'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x10\x64\x65\x20\x2D\x20\x4D\x65'),
+            (RX, b'\x10\x64\x65\x20\x2d\x20\x4d\x65'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x67\x61\x20\x44\x6F\x6D\x61'),
+            (RX, b'\x00\x67\x61\x20\x44\x6f\x6d\x61'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x15\x69\x6E\x73\x20\x21\x00\x00')
+            (RX, b'\x15\x69\x6e\x73\x20\x21\x00\x00'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.OCTET_STRING, 0)
         self.assertEqual(data, b'Tiny Node - Mega Domains !')
@@ -805,15 +1198,15 @@ def test_octet_string(self):
     def test_domain(self):
         self.data = [
             (TX, b'\x40\x0f\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x41\x0f\x20\x00\x1A\x00\x00\x00'),
+            (RX, b'\x41\x0f\x20\x00\x1a\x00\x00\x00'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x54\x69\x6E\x79\x20\x4E\x6F'),
+            (RX, b'\x00\x54\x69\x6e\x79\x20\x4e\x6f'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x10\x64\x65\x20\x2D\x20\x4D\x65'),
+            (RX, b'\x10\x64\x65\x20\x2d\x20\x4d\x65'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x00\x67\x61\x20\x44\x6F\x6D\x61'),
+            (RX, b'\x00\x67\x61\x20\x44\x6f\x6d\x61'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
-            (RX, b'\x15\x69\x6E\x73\x20\x21\x00\x00')
+            (RX, b'\x15\x69\x6e\x73\x20\x21\x00\x00'),
         ]
         data = self.network[2].sdo.upload(0x2000 + dt.DOMAIN, 0)
         self.assertEqual(data, b'Tiny Node - Mega Domains !')
@@ -821,8 +1214,8 @@ def test_domain(self):
     def test_unknown_od_32(self):
         """Test an unknown OD entry of 32 bits (4 bytes)."""
         self.data = [
-            (TX, b'\x40\xFF\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x43\xFF\x20\x00\xfe\xfd\xfc\xfb')
+            (TX, b'\x40\xff\x20\x00\x00\x00\x00\x00'),
+            (RX, b'\x43\xff\x20\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x20FF, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc\xfb')
@@ -830,15 +1223,17 @@ def test_unknown_od_32(self):
     def test_unknown_od_112(self):
         """Test an unknown OD entry of 112 bits (14 bytes)."""
         self.data = [
-            (TX, b'\x40\xFF\x20\x00\x00\x00\x00\x00'),
-            (RX, b'\x41\xFF\x20\x00\xfe\xfd\xfc\xfb'),
+            (TX, b'\x40\xff\x20\x00\x00\x00\x00\x00'),
+            (RX, b'\x41\xff\x20\x00\xfe\xfd\xfc\xfb'),
             (TX, b'\x60\x00\x00\x00\x00\x00\x00\x00'),
             (RX, b'\x00\xb2\x01\x20\x02\x91\x12\x03'),
             (TX, b'\x70\x00\x00\x00\x00\x00\x00\x00'),
             (RX, b'\x11\x19\x21\x70\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x20FF, 0)
-        self.assertEqual(data, b'\xb2\x01\x20\x02\x91\x12\x03\x19\x21\x70\xfe\xfd\xfc\xfb')
+        self.assertEqual(
+            data, b'\xb2\x01\x20\x02\x91\x12\x03\x19\x21\x70\xfe\xfd\xfc\xfb'
+        )
 
     def test_unknown_datatype32(self):
         """Test an unknown datatype, but known OD, of 32 bits (4 bytes)."""
@@ -849,7 +1244,7 @@ def test_unknown_datatype32(self):
             self.node.object_dictionary.add_object(fake_var)
         self.data = [
             (TX, b'\x40\x00\x21\x00\x00\x00\x00\x00'),
-            (RX, b'\x43\x00\x21\x00\xfe\xfd\xfc\xfb')
+            (RX, b'\x43\x00\x21\x00\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2100, 0)
         self.assertEqual(data, b'\xfe\xfd\xfc\xfb')
@@ -870,7 +1265,127 @@ def test_unknown_datatype112(self):
             (RX, b'\x11\x19\x21\x70\xfe\xfd\xfc\xfb'),
         ]
         data = self.network[2].sdo.upload(0x2100, 0)
-        self.assertEqual(data, b'\xb2\x01\x20\x02\x91\x12\x03\x19\x21\x70\xfe\xfd\xfc\xfb')
+        self.assertEqual(
+            data, b'\xb2\x01\x20\x02\x91\x12\x03\x19\x21\x70\xfe\xfd\xfc\xfb'
+        )
+
+
+class TestSdoAbortedError(unittest.TestCase):
+    """Unit tests for SdoAbortedError construction and helpers."""
+
+    def test_init_with_int_code(self):
+        for code in canopen.SdoAbortedError.CODES:
+            exc = canopen.SdoAbortedError(code)
+            self.assertEqual(exc.code, code)
+
+    def test_str_known_code(self):
+        for code, description in canopen.SdoAbortedError.CODES.items():
+            exc = canopen.SdoAbortedError(code)
+            self.assertIn(description, str(exc))
+
+    def test_str_unknown_code(self):
+        exc = canopen.SdoAbortedError(0xDEADBEEF)
+        self.assertIn("0xDEADBEEF", str(exc))
+
+    def test_eq(self):
+        for code, description in canopen.SdoAbortedError.CODES.items():
+            # Test equality with another instance of the same code, and with the code and description directly
+            self.assertEqual(canopen.SdoAbortedError(code),
+                             canopen.SdoAbortedError(description))
+            self.assertEqual(canopen.SdoAbortedError(code),
+                             code)
+            self.assertEqual(canopen.SdoAbortedError(code),
+                             description)
+        
+        self.assertNotEqual(canopen.SdoAbortedError(0x06090011),
+                            canopen.SdoAbortedError(0x08000000))
+        
+        self.assertNotEqual(canopen.SdoAbortedError(0x06090011), "Value range of parameter exceeded")
+
+        with self.assertRaises(TypeError):
+            canopen.SdoAbortedError(code) == 0.5  # Unsupported type for comparison
+
+    def test_init_from_string(self):
+        for code, description in canopen.SdoAbortedError.CODES.items():
+            exc = canopen.SdoAbortedError(description)
+            self.assertEqual(exc.code, code)
+
+    def test_init_from_unknown_string(self):
+        with self.assertRaises(ValueError):
+            canopen.SdoAbortedError("This description does not exist")
+
+
+class TestSDOServer(unittest.TestCase):
+    """Test the SDO server (LocalNode) directly by injecting raw CAN messages."""
+
+    def setUp(self):
+        network = canopen.Network()
+        network.NOTIFIER_SHUTDOWN_TIMEOUT = 0.0
+        self.responses = []
+        network.send_message = lambda cobid, data, remote=False: self.responses.append(bytes(data))
+        self.local_node = network.create_node(2, SAMPLE_EDS)
+
+    def test_expedited_download_no_size_specified(self):
+        """Expedited download without SIZE_SPECIFIED: server defaults to reading 4 bytes."""
+        # Command: REQUEST_DOWNLOAD (0x20) | EXPEDITED (0x02) — no SIZE_SPECIFIED
+        # Target: 0x1400:01 (COB-ID RPDO1, UNSIGNED32, rw)
+        request = bytearray(8)
+        index = 0x1400
+        subindex = 1
+        value = 0x201
+        SDO_STRUCT.pack_into(request, 0, REQUEST_DOWNLOAD | EXPEDITED, index, subindex)
+        struct.pack_into('<I', request, 4, value)  # value to write
+        self.local_node.sdo.on_request(0x602, request, 0.0)
+        # Server must reply with RESPONSE_DOWNLOAD for the same index/subindex
+        self.assertEqual(len(self.responses), 1)
+        command_r, index_r, subindex_r = SDO_STRUCT.unpack(self.responses[0][:4])  # Check that the first 4 bytes are a valid SDO header
+        self.assertEqual(command_r, RESPONSE_DOWNLOAD)
+        self.assertEqual(index_r, index)
+        self.assertEqual(subindex_r, subindex)
+        # Value must have been stored
+        self.assertEqual(self.local_node.sdo[index][subindex].raw, value)
+
+    def test_segmented_upload_toggle_bit_mismatch(self):
+        """Server aborts with TOGGLE_NOT_ALTERNATED when client sends wrong toggle on upload."""
+        # Initiate segmented upload for 0x1008:00 (Device Name, 'TEST DEVICE' = 11 bytes)
+        self.local_node.sdo.on_request(
+            0x602, b'\x40\x08\x10\x00\x00\x00\x00\x00', 0.0)
+        # Server should have responded with segmented initiate (not expedited)
+        self.assertEqual(len(self.responses), 1)
+        self.assertEqual(self.responses[0][0] & EXPEDITED, 0)
+
+        # Send segment request with wrong toggle bit (0x10 instead of 0x00)
+        self.local_node.sdo.on_request(
+            0x602, b'\x70\x00\x00\x00\x00\x00\x00\x00', 0.0)
+        # Server must respond with an abort
+        self.assertEqual(len(self.responses), 2)
+        cmd, = struct.unpack_from("B", self.responses[1])
+        self.assertEqual(cmd, RESPONSE_ABORTED)
+        code, = struct.unpack_from("<L", self.responses[1], 4)
+        self.assertEqual(code, ABORT_TOGGLE_NOT_ALTERNATED)
+
+    def test_segmented_download_toggle_bit_mismatch(self):
+        """Server aborts with TOGGLE_NOT_ALTERNATED when client repeats wrong toggle on download."""
+        # Initiate segmented download for 0x2000:00 (Writable string, 13 bytes)
+        self.local_node.sdo.on_request(
+            0x602, b'\x21\x00\x20\x00\x0d\x00\x00\x00', 0.0)
+        self.assertEqual(len(self.responses), 1)
+
+        # First segment correctly (toggle=0): 7 bytes of 'A long '
+        self.local_node.sdo.on_request(
+            0x602, b'\x00\x41\x20\x6c\x6f\x6e\x67\x20', 0.0)
+        self.assertEqual(len(self.responses), 2)
+
+        # Second segment with wrong toggle (0 again, should be 0x10)
+        self.local_node.sdo.on_request(
+            0x602, b'\x00\x73\x74\x72\x69\x6e\x67\x00', 0.0)
+        # Server must respond with an abort
+        self.assertEqual(len(self.responses), 3)
+        cmd, = struct.unpack_from("B", self.responses[2])
+        self.assertEqual(cmd, RESPONSE_ABORTED)
+        code, = struct.unpack_from("<L", self.responses[2], 4)
+        self.assertEqual(code, ABORT_TOGGLE_NOT_ALTERNATED)
+
 
 if __name__ == "__main__":
     unittest.main()