text: #!/usr/bin/env python
  # Copyright (C) 2015-2021 Swift Navigation Inc.
  # Contact: https://support.swiftnav.com
  #
  # This source is subject to the license found in the file 'LICENSE' which must
  # be be distributed together with this source. All other rights reserved.
  #
  # THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
  # EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  # WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
  
  
  """
  Messages for reading/writing the device's onboard flash memory. Many of
  these messages target specific flash memory peripherals used in Swift
  Navigation devices: the STM32 flash and the M25Pxx FPGA configuration flash
  from Piksi 2.3.1.  This module does not apply to Piksi Multi.
  """
  
  import json
  
  import construct
  
  from sbp.msg import SBP, SENDER_ID
  from sbp.utils import fmt_repr, exclude_fields, walk_json_dict, containerize
  
  # Automatically generated from piksi/yaml/swiftnav/sbp/flash.yaml with generate.py.
  # Please do not hand edit!
  
  
  SBP_MSG_FLASH_PROGRAM = 0x00E6
  class MsgFlashProgram(SBP):
    """SBP class for message MSG_FLASH_PROGRAM (0x00E6).
  
    You can have MSG_FLASH_PROGRAM inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash program message programs a set of addresses of either the STM or
    M25 flash. The device replies with either a MSG_FLASH_DONE message
    containing the return code FLASH_OK (0) on success, or FLASH_INVALID_LEN (2)
    if the maximum write size is exceeded. Note that the sector-containing
    addresses must be erased before addresses can be programmed.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    target : int
      Target flags
    addr_start : array
      Starting address offset to program
    addr_len : int
      Length of set of addresses to program, counting up from starting address
    data : array
      Data to program addresses with, with length N=addr_len
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'target' / construct.Int8ul,
                     'addr_start' / construct.Array(3, construct.Int8ul),
                     'addr_len' / construct.Int8ul,
                     'data' / construct.GreedyRange(construct.Int8ul),)
    __slots__ = [
                 'target',
                 'addr_start',
                 'addr_len',
                 'data',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgFlashProgram,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgFlashProgram, self).__init__()
        self.msg_type = SBP_MSG_FLASH_PROGRAM
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.target = kwargs.pop('target')
        self.addr_start = kwargs.pop('addr_start')
        self.addr_len = kwargs.pop('addr_len')
        self.data = kwargs.pop('data')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgFlashProgram.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgFlashProgram(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgFlashProgram._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgFlashProgram._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgFlashProgram._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgFlashProgram, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_FLASH_DONE = 0x00E0
  class MsgFlashDone(SBP):
    """SBP class for message MSG_FLASH_DONE (0x00E0).
  
    You can have MSG_FLASH_DONE inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    This message defines success or failure codes for a variety of flash memory
    requests from the host to the device. Flash read and write messages, such as
    MSG_FLASH_READ_REQ, or MSG_FLASH_PROGRAM, may return this message on
    failure.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    response : int
      Response flags
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'response' / construct.Int8ul,)
    __slots__ = [
                 'response',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgFlashDone,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgFlashDone, self).__init__()
        self.msg_type = SBP_MSG_FLASH_DONE
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.response = kwargs.pop('response')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgFlashDone.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgFlashDone(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgFlashDone._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgFlashDone._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgFlashDone._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgFlashDone, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_FLASH_READ_REQ = 0x00E7
  class MsgFlashReadReq(SBP):
    """SBP class for message MSG_FLASH_READ_REQ (0x00E7).
  
    You can have MSG_FLASH_READ_REQ inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash read message reads a set of addresses of either the STM or M25
    onboard flash. The device replies with a MSG_FLASH_READ_RESP message
    containing either the read data on success or a MSG_FLASH_DONE message
    containing the return code FLASH_INVALID_LEN (2) if the maximum read size is
    exceeded or FLASH_INVALID_ADDR (3) if the address is outside of the allowed
    range.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    target : int
      Target flags
    addr_start : array
      Starting address offset to read from
    addr_len : int
      Length of set of addresses to read, counting up from starting address
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'target' / construct.Int8ul,
                     'addr_start' / construct.Array(3, construct.Int8ul),
                     'addr_len' / construct.Int8ul,)
    __slots__ = [
                 'target',
                 'addr_start',
                 'addr_len',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgFlashReadReq,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgFlashReadReq, self).__init__()
        self.msg_type = SBP_MSG_FLASH_READ_REQ
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.target = kwargs.pop('target')
        self.addr_start = kwargs.pop('addr_start')
        self.addr_len = kwargs.pop('addr_len')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgFlashReadReq.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgFlashReadReq(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgFlashReadReq._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgFlashReadReq._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgFlashReadReq._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgFlashReadReq, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_FLASH_READ_RESP = 0x00E1
  class MsgFlashReadResp(SBP):
    """SBP class for message MSG_FLASH_READ_RESP (0x00E1).
  
    You can have MSG_FLASH_READ_RESP inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash read message reads a set of addresses of either the STM or M25
    onboard flash. The device replies with a MSG_FLASH_READ_RESP message
    containing either the read data on success or a MSG_FLASH_DONE message
    containing the return code FLASH_INVALID_LEN (2) if the maximum read size is
    exceeded or FLASH_INVALID_ADDR (3) if the address is outside of the allowed
    range.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    target : int
      Target flags
    addr_start : array
      Starting address offset to read from
    addr_len : int
      Length of set of addresses to read, counting up from starting address
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'target' / construct.Int8ul,
                     'addr_start' / construct.Array(3, construct.Int8ul),
                     'addr_len' / construct.Int8ul,)
    __slots__ = [
                 'target',
                 'addr_start',
                 'addr_len',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgFlashReadResp,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgFlashReadResp, self).__init__()
        self.msg_type = SBP_MSG_FLASH_READ_RESP
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.target = kwargs.pop('target')
        self.addr_start = kwargs.pop('addr_start')
        self.addr_len = kwargs.pop('addr_len')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgFlashReadResp.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgFlashReadResp(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgFlashReadResp._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgFlashReadResp._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgFlashReadResp._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgFlashReadResp, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_FLASH_ERASE = 0x00E2
  class MsgFlashErase(SBP):
    """SBP class for message MSG_FLASH_ERASE (0x00E2).
  
    You can have MSG_FLASH_ERASE inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash erase message from the host erases a sector of either the STM or
    M25 onboard flash memory. The device will reply with a MSG_FLASH_DONE
    message containing the return code - FLASH_OK (0) on success or
    FLASH_INVALID_FLASH (1) if the flash specified is invalid.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    target : int
      Target flags
    sector_num : int
      Flash sector number to erase (0-11 for the STM, 0-15 for the M25)
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'target' / construct.Int8ul,
                     'sector_num' / construct.Int32ul,)
    __slots__ = [
                 'target',
                 'sector_num',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgFlashErase,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgFlashErase, self).__init__()
        self.msg_type = SBP_MSG_FLASH_ERASE
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.target = kwargs.pop('target')
        self.sector_num = kwargs.pop('sector_num')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgFlashErase.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgFlashErase(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgFlashErase._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgFlashErase._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgFlashErase._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgFlashErase, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_STM_FLASH_LOCK_SECTOR = 0x00E3
  class MsgStmFlashLockSector(SBP):
    """SBP class for message MSG_STM_FLASH_LOCK_SECTOR (0x00E3).
  
    You can have MSG_STM_FLASH_LOCK_SECTOR inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash lock message locks a sector of the STM flash memory. The device
    replies with a MSG_FLASH_DONE message.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    sector : int
      Flash sector number to lock
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'sector' / construct.Int32ul,)
    __slots__ = [
                 'sector',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgStmFlashLockSector,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgStmFlashLockSector, self).__init__()
        self.msg_type = SBP_MSG_STM_FLASH_LOCK_SECTOR
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.sector = kwargs.pop('sector')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgStmFlashLockSector.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgStmFlashLockSector(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgStmFlashLockSector._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgStmFlashLockSector._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgStmFlashLockSector._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgStmFlashLockSector, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_STM_FLASH_UNLOCK_SECTOR = 0x00E4
  class MsgStmFlashUnlockSector(SBP):
    """SBP class for message MSG_STM_FLASH_UNLOCK_SECTOR (0x00E4).
  
    You can have MSG_STM_FLASH_UNLOCK_SECTOR inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash unlock message unlocks a sector of the STM flash memory. The
    device replies with a MSG_FLASH_DONE message.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    sector : int
      Flash sector number to unlock
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'sector' / construct.Int32ul,)
    __slots__ = [
                 'sector',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgStmFlashUnlockSector,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgStmFlashUnlockSector, self).__init__()
        self.msg_type = SBP_MSG_STM_FLASH_UNLOCK_SECTOR
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.sector = kwargs.pop('sector')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgStmFlashUnlockSector.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgStmFlashUnlockSector(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgStmFlashUnlockSector._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgStmFlashUnlockSector._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgStmFlashUnlockSector._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgStmFlashUnlockSector, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_STM_UNIQUE_ID_REQ = 0x00E8
  class MsgStmUniqueIdReq(SBP):
    """SBP class for message MSG_STM_UNIQUE_ID_REQ (0x00E8).
  
    You can have MSG_STM_UNIQUE_ID_REQ inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    This message reads the device's hard-coded unique ID. The host requests the
    ID by sending a MSG_STM_UNIQUE_ID_REQ. The device responds with a
    MSG_STM_UNIQUE_ID_RESP with the 12-byte unique ID in the payload.
  
    """
    __slots__ = []
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgStmUniqueIdReq,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.payload = sbp.payload
      else:
        super( MsgStmUniqueIdReq, self).__init__()
        self.msg_type = SBP_MSG_STM_UNIQUE_ID_REQ
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.payload = b""
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgStmUniqueIdReq.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgStmUniqueIdReq(sbp, **d)
  
   
      
  SBP_MSG_STM_UNIQUE_ID_RESP = 0x00E5
  class MsgStmUniqueIdResp(SBP):
    """SBP class for message MSG_STM_UNIQUE_ID_RESP (0x00E5).
  
    You can have MSG_STM_UNIQUE_ID_RESP inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    This message reads the device's hard-coded unique ID. The host requests the
    ID by sending a MSG_STM_UNIQUE_ID_REQ. The device responds with a
    MSG_STM_UNIQUE_ID_RESP with the 12-byte unique ID in the payload.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    stm_id : array
      Device unique ID
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'stm_id' / construct.Array(12, construct.Int8ul),)
    __slots__ = [
                 'stm_id',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgStmUniqueIdResp,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgStmUniqueIdResp, self).__init__()
        self.msg_type = SBP_MSG_STM_UNIQUE_ID_RESP
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.stm_id = kwargs.pop('stm_id')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgStmUniqueIdResp.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgStmUniqueIdResp(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgStmUniqueIdResp._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgStmUniqueIdResp._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgStmUniqueIdResp._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgStmUniqueIdResp, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  SBP_MSG_M25_FLASH_WRITE_STATUS = 0x00F3
  class MsgM25FlashWriteStatus(SBP):
    """SBP class for message MSG_M25_FLASH_WRITE_STATUS (0x00F3).
  
    You can have MSG_M25_FLASH_WRITE_STATUS inherit its fields directly
    from an inherited SBP object, or construct it inline using a dict
    of its fields.
  
    
    The flash status message writes to the 8-bit M25 flash status register. The
    device replies with a MSG_FLASH_DONE message.
  
    Parameters
    ----------
    sbp : SBP
      SBP parent object to inherit from.
    status : array
      Byte to write to the M25 flash status register
    sender : int
      Optional sender ID, defaults to SENDER_ID (see sbp/msg.py).
  
    """
    _parser = construct.Struct(
                     'status' / construct.Array(1, construct.Int8ul),)
    __slots__ = [
                 'status',
                ]
  
    def __init__(self, sbp=None, **kwargs):
      if sbp:
        super( MsgM25FlashWriteStatus,
               self).__init__(sbp.msg_type, sbp.sender, sbp.length,
                              sbp.payload, sbp.crc)
        self.from_binary(sbp.payload)
      else:
        super( MsgM25FlashWriteStatus, self).__init__()
        self.msg_type = SBP_MSG_M25_FLASH_WRITE_STATUS
        self.sender = kwargs.pop('sender', SENDER_ID)
        self.status = kwargs.pop('status')
  
    def __repr__(self):
      return fmt_repr(self)
  
    @staticmethod
    def from_json(s):
      """Given a JSON-encoded string s, build a message object.
  
      """
      d = json.loads(s)
      return MsgM25FlashWriteStatus.from_json_dict(d)
  
    @staticmethod
    def from_json_dict(d):
      sbp = SBP.from_json_dict(d)
      return MsgM25FlashWriteStatus(sbp, **d)
  
   
    def from_binary(self, d):
      """Given a binary payload d, update the appropriate payload fields of
      the message.
  
      """
      p = MsgM25FlashWriteStatus._parser.parse(d)
      for n in self.__class__.__slots__:
        setattr(self, n, getattr(p, n))
  
    def to_binary(self):
      """Produce a framed/packed SBP message.
  
      """
      c = containerize(exclude_fields(self))
      self.payload = MsgM25FlashWriteStatus._parser.build(c)
      return self.pack()
  
    def into_buffer(self, buf, offset):
      """Produce a framed/packed SBP message into the provided buffer and offset.
  
      """
      self.payload = containerize(exclude_fields(self))
      self.parser = MsgM25FlashWriteStatus._parser
      self.stream_payload.reset(buf, offset)
      return self.pack_into(buf, offset, self._build_payload)
  
    def to_json_dict(self):
      self.to_binary()
      d = super( MsgM25FlashWriteStatus, self).to_json_dict()
      j = walk_json_dict(exclude_fields(self))
      d.update(j)
      return d
      
  
  msg_classes = {
    0x00E6: MsgFlashProgram,
    0x00E0: MsgFlashDone,
    0x00E7: MsgFlashReadReq,
    0x00E1: MsgFlashReadResp,
    0x00E2: MsgFlashErase,
    0x00E3: MsgStmFlashLockSector,
    0x00E4: MsgStmFlashUnlockSector,
    0x00E8: MsgStmUniqueIdReq,
    0x00E5: MsgStmUniqueIdResp,
    0x00F3: MsgM25FlashWriteStatus,
  }