{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# LANGUAGE NoImplicitPrelude           #-}
{-# LANGUAGE TemplateHaskell             #-}
{-# LANGUAGE RecordWildCards             #-}

-- |
-- Module:      SwiftNav.SBP.FileIo
-- Copyright:   Copyright (C) 2015-2021 Swift Navigation, Inc.
-- License:     MIT
-- Contact:     https://support.swiftnav.com
-- Stability:   experimental
-- Portability: portable
--
-- \< Messages for using device's onboard flash filesystem functionality. This
-- allows data to be stored persistently in the device's program flash with
-- wear-levelling using a simple filesystem interface. The file system
-- interface (CFS) defines an abstract API for reading directories and for
-- reading and writing files.
--
-- Note that some of these messages share the same message type ID for both
-- the host request and the device response. \>

module SwiftNav.SBP.FileIo
  ( module SwiftNav.SBP.FileIo
  ) where

import BasicPrelude
import Control.Lens
import Control.Monad.Loops
import Data.Binary
import Data.Binary.Get
import Data.Binary.IEEE754
import Data.Binary.Put
import Data.ByteString.Lazy    hiding (ByteString)
import Data.Int
import Data.Word
import SwiftNav.SBP.TH
import SwiftNav.SBP.Types

{-# ANN module ("HLint: ignore Use camelCase"::String) #-}
{-# ANN module ("HLint: ignore Redundant do"::String) #-}
{-# ANN module ("HLint: ignore Use newtype instead of data"::String) #-}


msgFileioReadReq :: Word16
msgFileioReadReq :: Word16
msgFileioReadReq = Word16
0x00A8

-- | SBP class for message MSG_FILEIO_READ_REQ (0x00A8).
--
-- The file read message reads a certain length (up to 255 bytes) from a given
-- offset into a file, and returns the data in a MSG_FILEIO_READ_RESP message
-- where the message length field indicates how many bytes were successfully
-- read. The sequence number in the request will be returned in the response.
-- If the message is invalid, a followup MSG_PRINT message will print "Invalid
-- fileio read message". A device will only respond to this message when it is
-- received from sender ID 0x42.
data MsgFileioReadReq = MsgFileioReadReq
  { MsgFileioReadReq -> Word32
_msgFileioReadReq_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadReq -> Word32
_msgFileioReadReq_offset   :: !Word32
    -- ^ File offset
  , MsgFileioReadReq -> Word8
_msgFileioReadReq_chunk_size :: !Word8
    -- ^ Chunk size to read
  , MsgFileioReadReq -> Text
_msgFileioReadReq_filename :: !Text
    -- ^ Name of the file to read from
  } deriving ( Int -> MsgFileioReadReq -> ShowS
[MsgFileioReadReq] -> ShowS
MsgFileioReadReq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadReq] -> ShowS
$cshowList :: [MsgFileioReadReq] -> ShowS
show :: MsgFileioReadReq -> String
$cshow :: MsgFileioReadReq -> String
showsPrec :: Int -> MsgFileioReadReq -> ShowS
$cshowsPrec :: Int -> MsgFileioReadReq -> ShowS
Show, ReadPrec [MsgFileioReadReq]
ReadPrec MsgFileioReadReq
Int -> ReadS MsgFileioReadReq
ReadS [MsgFileioReadReq]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadReq]
$creadListPrec :: ReadPrec [MsgFileioReadReq]
readPrec :: ReadPrec MsgFileioReadReq
$creadPrec :: ReadPrec MsgFileioReadReq
readList :: ReadS [MsgFileioReadReq]
$creadList :: ReadS [MsgFileioReadReq]
readsPrec :: Int -> ReadS MsgFileioReadReq
$creadsPrec :: Int -> ReadS MsgFileioReadReq
Read, MsgFileioReadReq -> MsgFileioReadReq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
$c/= :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
== :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
$c== :: MsgFileioReadReq -> MsgFileioReadReq -> Bool
Eq )

instance Binary MsgFileioReadReq where
  get :: Get MsgFileioReadReq
get = do
    Word32
_msgFileioReadReq_sequence <- Get Word32
getWord32le
    Word32
_msgFileioReadReq_offset <- Get Word32
getWord32le
    Word8
_msgFileioReadReq_chunk_size <- Get Word8
getWord8
    Text
_msgFileioReadReq_filename <- ByteString -> Text
decodeUtf8 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadReq {Word8
Word32
Text
_msgFileioReadReq_filename :: Text
_msgFileioReadReq_chunk_size :: Word8
_msgFileioReadReq_offset :: Word32
_msgFileioReadReq_sequence :: Word32
_msgFileioReadReq_filename :: Text
_msgFileioReadReq_chunk_size :: Word8
_msgFileioReadReq_offset :: Word32
_msgFileioReadReq_sequence :: Word32
..}

  put :: MsgFileioReadReq -> Put
put MsgFileioReadReq {Word8
Word32
Text
_msgFileioReadReq_filename :: Text
_msgFileioReadReq_chunk_size :: Word8
_msgFileioReadReq_offset :: Word32
_msgFileioReadReq_sequence :: Word32
_msgFileioReadReq_filename :: MsgFileioReadReq -> Text
_msgFileioReadReq_chunk_size :: MsgFileioReadReq -> Word8
_msgFileioReadReq_offset :: MsgFileioReadReq -> Word32
_msgFileioReadReq_sequence :: MsgFileioReadReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadReq_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioReadReq_offset
    Word8 -> Put
putWord8 Word8
_msgFileioReadReq_chunk_size
    ByteString -> Put
putByteString forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioReadReq_filename

$(makeSBP 'msgFileioReadReq ''MsgFileioReadReq)
$(makeJSON "_msgFileioReadReq_" ''MsgFileioReadReq)
$(makeLenses ''MsgFileioReadReq)

msgFileioReadResp :: Word16
msgFileioReadResp :: Word16
msgFileioReadResp = Word16
0x00A3

-- | SBP class for message MSG_FILEIO_READ_RESP (0x00A3).
--
-- The file read message reads a certain length (up to 255 bytes) from a given
-- offset into a file, and returns the data in a message where the message
-- length field indicates how many bytes were successfully read. The sequence
-- number in the response is preserved from the request.
data MsgFileioReadResp = MsgFileioReadResp
  { MsgFileioReadResp -> Word32
_msgFileioReadResp_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadResp -> [Word8]
_msgFileioReadResp_contents :: ![Word8]
    -- ^ Contents of read file
  } deriving ( Int -> MsgFileioReadResp -> ShowS
[MsgFileioReadResp] -> ShowS
MsgFileioReadResp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadResp] -> ShowS
$cshowList :: [MsgFileioReadResp] -> ShowS
show :: MsgFileioReadResp -> String
$cshow :: MsgFileioReadResp -> String
showsPrec :: Int -> MsgFileioReadResp -> ShowS
$cshowsPrec :: Int -> MsgFileioReadResp -> ShowS
Show, ReadPrec [MsgFileioReadResp]
ReadPrec MsgFileioReadResp
Int -> ReadS MsgFileioReadResp
ReadS [MsgFileioReadResp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadResp]
$creadListPrec :: ReadPrec [MsgFileioReadResp]
readPrec :: ReadPrec MsgFileioReadResp
$creadPrec :: ReadPrec MsgFileioReadResp
readList :: ReadS [MsgFileioReadResp]
$creadList :: ReadS [MsgFileioReadResp]
readsPrec :: Int -> ReadS MsgFileioReadResp
$creadsPrec :: Int -> ReadS MsgFileioReadResp
Read, MsgFileioReadResp -> MsgFileioReadResp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
$c/= :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
== :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
$c== :: MsgFileioReadResp -> MsgFileioReadResp -> Bool
Eq )

instance Binary MsgFileioReadResp where
  get :: Get MsgFileioReadResp
get = do
    Word32
_msgFileioReadResp_sequence <- Get Word32
getWord32le
    [Word8]
_msgFileioReadResp_contents <- forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
whileM (Bool -> Bool
not forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Bool
isEmpty) Get Word8
getWord8
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadResp {[Word8]
Word32
_msgFileioReadResp_contents :: [Word8]
_msgFileioReadResp_sequence :: Word32
_msgFileioReadResp_contents :: [Word8]
_msgFileioReadResp_sequence :: Word32
..}

  put :: MsgFileioReadResp -> Put
put MsgFileioReadResp {[Word8]
Word32
_msgFileioReadResp_contents :: [Word8]
_msgFileioReadResp_sequence :: Word32
_msgFileioReadResp_contents :: MsgFileioReadResp -> [Word8]
_msgFileioReadResp_sequence :: MsgFileioReadResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadResp_sequence
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word8 -> Put
putWord8 [Word8]
_msgFileioReadResp_contents

$(makeSBP 'msgFileioReadResp ''MsgFileioReadResp)
$(makeJSON "_msgFileioReadResp_" ''MsgFileioReadResp)
$(makeLenses ''MsgFileioReadResp)

msgFileioReadDirReq :: Word16
msgFileioReadDirReq :: Word16
msgFileioReadDirReq = Word16
0x00A9

-- | SBP class for message MSG_FILEIO_READ_DIR_REQ (0x00A9).
--
-- The read directory message lists the files in a directory on the device's
-- onboard flash file system.  The offset parameter can be used to skip the
-- first n elements of the file list. Returns a MSG_FILEIO_READ_DIR_RESP
-- message containing the directory listings as a NULL delimited list. The
-- listing is chunked over multiple SBP packets. The sequence number in the
-- request will be returned in the response.  If message is invalid, a
-- followup MSG_PRINT message will print "Invalid fileio read message". A
-- device will only respond to this message when it is received from sender ID
-- 0x42.
data MsgFileioReadDirReq = MsgFileioReadDirReq
  { MsgFileioReadDirReq -> Word32
_msgFileioReadDirReq_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadDirReq -> Word32
_msgFileioReadDirReq_offset :: !Word32
    -- ^ The offset to skip the first n elements of the file list
  , MsgFileioReadDirReq -> Text
_msgFileioReadDirReq_dirname :: !Text
    -- ^ Name of the directory to list
  } deriving ( Int -> MsgFileioReadDirReq -> ShowS
[MsgFileioReadDirReq] -> ShowS
MsgFileioReadDirReq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadDirReq] -> ShowS
$cshowList :: [MsgFileioReadDirReq] -> ShowS
show :: MsgFileioReadDirReq -> String
$cshow :: MsgFileioReadDirReq -> String
showsPrec :: Int -> MsgFileioReadDirReq -> ShowS
$cshowsPrec :: Int -> MsgFileioReadDirReq -> ShowS
Show, ReadPrec [MsgFileioReadDirReq]
ReadPrec MsgFileioReadDirReq
Int -> ReadS MsgFileioReadDirReq
ReadS [MsgFileioReadDirReq]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadDirReq]
$creadListPrec :: ReadPrec [MsgFileioReadDirReq]
readPrec :: ReadPrec MsgFileioReadDirReq
$creadPrec :: ReadPrec MsgFileioReadDirReq
readList :: ReadS [MsgFileioReadDirReq]
$creadList :: ReadS [MsgFileioReadDirReq]
readsPrec :: Int -> ReadS MsgFileioReadDirReq
$creadsPrec :: Int -> ReadS MsgFileioReadDirReq
Read, MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
$c/= :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
== :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
$c== :: MsgFileioReadDirReq -> MsgFileioReadDirReq -> Bool
Eq )

instance Binary MsgFileioReadDirReq where
  get :: Get MsgFileioReadDirReq
get = do
    Word32
_msgFileioReadDirReq_sequence <- Get Word32
getWord32le
    Word32
_msgFileioReadDirReq_offset <- Get Word32
getWord32le
    Text
_msgFileioReadDirReq_dirname <- ByteString -> Text
decodeUtf8 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadDirReq {Word32
Text
_msgFileioReadDirReq_dirname :: Text
_msgFileioReadDirReq_offset :: Word32
_msgFileioReadDirReq_sequence :: Word32
_msgFileioReadDirReq_dirname :: Text
_msgFileioReadDirReq_offset :: Word32
_msgFileioReadDirReq_sequence :: Word32
..}

  put :: MsgFileioReadDirReq -> Put
put MsgFileioReadDirReq {Word32
Text
_msgFileioReadDirReq_dirname :: Text
_msgFileioReadDirReq_offset :: Word32
_msgFileioReadDirReq_sequence :: Word32
_msgFileioReadDirReq_dirname :: MsgFileioReadDirReq -> Text
_msgFileioReadDirReq_offset :: MsgFileioReadDirReq -> Word32
_msgFileioReadDirReq_sequence :: MsgFileioReadDirReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadDirReq_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioReadDirReq_offset
    ByteString -> Put
putByteString forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioReadDirReq_dirname

$(makeSBP 'msgFileioReadDirReq ''MsgFileioReadDirReq)
$(makeJSON "_msgFileioReadDirReq_" ''MsgFileioReadDirReq)
$(makeLenses ''MsgFileioReadDirReq)

msgFileioReadDirResp :: Word16
msgFileioReadDirResp :: Word16
msgFileioReadDirResp = Word16
0x00AA

-- | SBP class for message MSG_FILEIO_READ_DIR_RESP (0x00AA).
--
-- The read directory message lists the files in a directory on the device's
-- onboard flash file system. Message contains the directory listings as a
-- NULL delimited list. The listing is chunked over multiple SBP packets and
-- the end of the list is identified by an packet with no entries. The
-- sequence number in the response is preserved from the request.
data MsgFileioReadDirResp = MsgFileioReadDirResp
  { MsgFileioReadDirResp -> Word32
_msgFileioReadDirResp_sequence :: !Word32
    -- ^ Read sequence number
  , MsgFileioReadDirResp -> [Word8]
_msgFileioReadDirResp_contents :: ![Word8]
    -- ^ Contents of read directory
  } deriving ( Int -> MsgFileioReadDirResp -> ShowS
[MsgFileioReadDirResp] -> ShowS
MsgFileioReadDirResp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioReadDirResp] -> ShowS
$cshowList :: [MsgFileioReadDirResp] -> ShowS
show :: MsgFileioReadDirResp -> String
$cshow :: MsgFileioReadDirResp -> String
showsPrec :: Int -> MsgFileioReadDirResp -> ShowS
$cshowsPrec :: Int -> MsgFileioReadDirResp -> ShowS
Show, ReadPrec [MsgFileioReadDirResp]
ReadPrec MsgFileioReadDirResp
Int -> ReadS MsgFileioReadDirResp
ReadS [MsgFileioReadDirResp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioReadDirResp]
$creadListPrec :: ReadPrec [MsgFileioReadDirResp]
readPrec :: ReadPrec MsgFileioReadDirResp
$creadPrec :: ReadPrec MsgFileioReadDirResp
readList :: ReadS [MsgFileioReadDirResp]
$creadList :: ReadS [MsgFileioReadDirResp]
readsPrec :: Int -> ReadS MsgFileioReadDirResp
$creadsPrec :: Int -> ReadS MsgFileioReadDirResp
Read, MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
$c/= :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
== :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
$c== :: MsgFileioReadDirResp -> MsgFileioReadDirResp -> Bool
Eq )

instance Binary MsgFileioReadDirResp where
  get :: Get MsgFileioReadDirResp
get = do
    Word32
_msgFileioReadDirResp_sequence <- Get Word32
getWord32le
    [Word8]
_msgFileioReadDirResp_contents <- forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
whileM (Bool -> Bool
not forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Bool
isEmpty) Get Word8
getWord8
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioReadDirResp {[Word8]
Word32
_msgFileioReadDirResp_contents :: [Word8]
_msgFileioReadDirResp_sequence :: Word32
_msgFileioReadDirResp_contents :: [Word8]
_msgFileioReadDirResp_sequence :: Word32
..}

  put :: MsgFileioReadDirResp -> Put
put MsgFileioReadDirResp {[Word8]
Word32
_msgFileioReadDirResp_contents :: [Word8]
_msgFileioReadDirResp_sequence :: Word32
_msgFileioReadDirResp_contents :: MsgFileioReadDirResp -> [Word8]
_msgFileioReadDirResp_sequence :: MsgFileioReadDirResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioReadDirResp_sequence
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word8 -> Put
putWord8 [Word8]
_msgFileioReadDirResp_contents

$(makeSBP 'msgFileioReadDirResp ''MsgFileioReadDirResp)
$(makeJSON "_msgFileioReadDirResp_" ''MsgFileioReadDirResp)
$(makeLenses ''MsgFileioReadDirResp)

msgFileioRemove :: Word16
msgFileioRemove :: Word16
msgFileioRemove = Word16
0x00AC

-- | SBP class for message MSG_FILEIO_REMOVE (0x00AC).
--
-- The file remove message deletes a file from the file system. If the message
-- is invalid, a followup MSG_PRINT message will print "Invalid fileio remove
-- message". A device will only process this message when it is received from
-- sender ID 0x42.
data MsgFileioRemove = MsgFileioRemove
  { MsgFileioRemove -> Text
_msgFileioRemove_filename :: !Text
    -- ^ Name of the file to delete
  } deriving ( Int -> MsgFileioRemove -> ShowS
[MsgFileioRemove] -> ShowS
MsgFileioRemove -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioRemove] -> ShowS
$cshowList :: [MsgFileioRemove] -> ShowS
show :: MsgFileioRemove -> String
$cshow :: MsgFileioRemove -> String
showsPrec :: Int -> MsgFileioRemove -> ShowS
$cshowsPrec :: Int -> MsgFileioRemove -> ShowS
Show, ReadPrec [MsgFileioRemove]
ReadPrec MsgFileioRemove
Int -> ReadS MsgFileioRemove
ReadS [MsgFileioRemove]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioRemove]
$creadListPrec :: ReadPrec [MsgFileioRemove]
readPrec :: ReadPrec MsgFileioRemove
$creadPrec :: ReadPrec MsgFileioRemove
readList :: ReadS [MsgFileioRemove]
$creadList :: ReadS [MsgFileioRemove]
readsPrec :: Int -> ReadS MsgFileioRemove
$creadsPrec :: Int -> ReadS MsgFileioRemove
Read, MsgFileioRemove -> MsgFileioRemove -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioRemove -> MsgFileioRemove -> Bool
$c/= :: MsgFileioRemove -> MsgFileioRemove -> Bool
== :: MsgFileioRemove -> MsgFileioRemove -> Bool
$c== :: MsgFileioRemove -> MsgFileioRemove -> Bool
Eq )

instance Binary MsgFileioRemove where
  get :: Get MsgFileioRemove
get = do
    Text
_msgFileioRemove_filename <- ByteString -> Text
decodeUtf8 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioRemove {Text
_msgFileioRemove_filename :: Text
_msgFileioRemove_filename :: Text
..}

  put :: MsgFileioRemove -> Put
put MsgFileioRemove {Text
_msgFileioRemove_filename :: Text
_msgFileioRemove_filename :: MsgFileioRemove -> Text
..} = do
    ByteString -> Put
putByteString forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioRemove_filename

$(makeSBP 'msgFileioRemove ''MsgFileioRemove)
$(makeJSON "_msgFileioRemove_" ''MsgFileioRemove)
$(makeLenses ''MsgFileioRemove)

msgFileioWriteReq :: Word16
msgFileioWriteReq :: Word16
msgFileioWriteReq = Word16
0x00AD

-- | SBP class for message MSG_FILEIO_WRITE_REQ (0x00AD).
--
-- The file write message writes a certain length (up to 255 bytes) of data to
-- a file at a given offset. Returns a copy of the original
-- MSG_FILEIO_WRITE_RESP message to check integrity of the write. The sequence
-- number in the request will be returned in the response. If message is
-- invalid, a followup MSG_PRINT message will print "Invalid fileio write
-- message". A device will only process this message when it is received from
-- sender ID 0x42.
data MsgFileioWriteReq = MsgFileioWriteReq
  { MsgFileioWriteReq -> Word32
_msgFileioWriteReq_sequence :: !Word32
    -- ^ Write sequence number
  , MsgFileioWriteReq -> Word32
_msgFileioWriteReq_offset :: !Word32
    -- ^ Offset into the file at which to start writing in bytes
  , MsgFileioWriteReq -> Text
_msgFileioWriteReq_filename :: !Text
    -- ^ Name of the file to write to
  , MsgFileioWriteReq -> [Word8]
_msgFileioWriteReq_data   :: ![Word8]
    -- ^ Variable-length array of data to write
  } deriving ( Int -> MsgFileioWriteReq -> ShowS
[MsgFileioWriteReq] -> ShowS
MsgFileioWriteReq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioWriteReq] -> ShowS
$cshowList :: [MsgFileioWriteReq] -> ShowS
show :: MsgFileioWriteReq -> String
$cshow :: MsgFileioWriteReq -> String
showsPrec :: Int -> MsgFileioWriteReq -> ShowS
$cshowsPrec :: Int -> MsgFileioWriteReq -> ShowS
Show, ReadPrec [MsgFileioWriteReq]
ReadPrec MsgFileioWriteReq
Int -> ReadS MsgFileioWriteReq
ReadS [MsgFileioWriteReq]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioWriteReq]
$creadListPrec :: ReadPrec [MsgFileioWriteReq]
readPrec :: ReadPrec MsgFileioWriteReq
$creadPrec :: ReadPrec MsgFileioWriteReq
readList :: ReadS [MsgFileioWriteReq]
$creadList :: ReadS [MsgFileioWriteReq]
readsPrec :: Int -> ReadS MsgFileioWriteReq
$creadsPrec :: Int -> ReadS MsgFileioWriteReq
Read, MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
$c/= :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
== :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
$c== :: MsgFileioWriteReq -> MsgFileioWriteReq -> Bool
Eq )

instance Binary MsgFileioWriteReq where
  get :: Get MsgFileioWriteReq
get = do
    Word32
_msgFileioWriteReq_sequence <- Get Word32
getWord32le
    Word32
_msgFileioWriteReq_offset <- Get Word32
getWord32le
    Text
_msgFileioWriteReq_filename <- ByteString -> Text
decodeUtf8 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ByteString
toStrict forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
getRemainingLazyByteString
    [Word8]
_msgFileioWriteReq_data <- forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
whileM (Bool -> Bool
not forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Bool
isEmpty) Get Word8
getWord8
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioWriteReq {[Word8]
Word32
Text
_msgFileioWriteReq_data :: [Word8]
_msgFileioWriteReq_filename :: Text
_msgFileioWriteReq_offset :: Word32
_msgFileioWriteReq_sequence :: Word32
_msgFileioWriteReq_data :: [Word8]
_msgFileioWriteReq_filename :: Text
_msgFileioWriteReq_offset :: Word32
_msgFileioWriteReq_sequence :: Word32
..}

  put :: MsgFileioWriteReq -> Put
put MsgFileioWriteReq {[Word8]
Word32
Text
_msgFileioWriteReq_data :: [Word8]
_msgFileioWriteReq_filename :: Text
_msgFileioWriteReq_offset :: Word32
_msgFileioWriteReq_sequence :: Word32
_msgFileioWriteReq_data :: MsgFileioWriteReq -> [Word8]
_msgFileioWriteReq_filename :: MsgFileioWriteReq -> Text
_msgFileioWriteReq_offset :: MsgFileioWriteReq -> Word32
_msgFileioWriteReq_sequence :: MsgFileioWriteReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioWriteReq_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioWriteReq_offset
    ByteString -> Put
putByteString forall a b. (a -> b) -> a -> b
$ Text -> ByteString
encodeUtf8 Text
_msgFileioWriteReq_filename
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Word8 -> Put
putWord8 [Word8]
_msgFileioWriteReq_data

$(makeSBP 'msgFileioWriteReq ''MsgFileioWriteReq)
$(makeJSON "_msgFileioWriteReq_" ''MsgFileioWriteReq)
$(makeLenses ''MsgFileioWriteReq)

msgFileioWriteResp :: Word16
msgFileioWriteResp :: Word16
msgFileioWriteResp = Word16
0x00AB

-- | SBP class for message MSG_FILEIO_WRITE_RESP (0x00AB).
--
-- The file write message writes a certain length (up to 255 bytes) of data to
-- a file at a given offset. The message is a copy of the original
-- MSG_FILEIO_WRITE_REQ message to check integrity of the write. The sequence
-- number in the response is preserved from the request.
data MsgFileioWriteResp = MsgFileioWriteResp
  { MsgFileioWriteResp -> Word32
_msgFileioWriteResp_sequence :: !Word32
    -- ^ Write sequence number
  } deriving ( Int -> MsgFileioWriteResp -> ShowS
[MsgFileioWriteResp] -> ShowS
MsgFileioWriteResp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioWriteResp] -> ShowS
$cshowList :: [MsgFileioWriteResp] -> ShowS
show :: MsgFileioWriteResp -> String
$cshow :: MsgFileioWriteResp -> String
showsPrec :: Int -> MsgFileioWriteResp -> ShowS
$cshowsPrec :: Int -> MsgFileioWriteResp -> ShowS
Show, ReadPrec [MsgFileioWriteResp]
ReadPrec MsgFileioWriteResp
Int -> ReadS MsgFileioWriteResp
ReadS [MsgFileioWriteResp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioWriteResp]
$creadListPrec :: ReadPrec [MsgFileioWriteResp]
readPrec :: ReadPrec MsgFileioWriteResp
$creadPrec :: ReadPrec MsgFileioWriteResp
readList :: ReadS [MsgFileioWriteResp]
$creadList :: ReadS [MsgFileioWriteResp]
readsPrec :: Int -> ReadS MsgFileioWriteResp
$creadsPrec :: Int -> ReadS MsgFileioWriteResp
Read, MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
$c/= :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
== :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
$c== :: MsgFileioWriteResp -> MsgFileioWriteResp -> Bool
Eq )

instance Binary MsgFileioWriteResp where
  get :: Get MsgFileioWriteResp
get = do
    Word32
_msgFileioWriteResp_sequence <- Get Word32
getWord32le
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioWriteResp {Word32
_msgFileioWriteResp_sequence :: Word32
_msgFileioWriteResp_sequence :: Word32
..}

  put :: MsgFileioWriteResp -> Put
put MsgFileioWriteResp {Word32
_msgFileioWriteResp_sequence :: Word32
_msgFileioWriteResp_sequence :: MsgFileioWriteResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioWriteResp_sequence

$(makeSBP 'msgFileioWriteResp ''MsgFileioWriteResp)
$(makeJSON "_msgFileioWriteResp_" ''MsgFileioWriteResp)
$(makeLenses ''MsgFileioWriteResp)

msgFileioConfigReq :: Word16
msgFileioConfigReq :: Word16
msgFileioConfigReq = Word16
0x1001

-- | SBP class for message MSG_FILEIO_CONFIG_REQ (0x1001).
--
-- Requests advice on the optimal configuration for a FileIO transfer.  Newer
-- version of FileIO can support greater throughput by supporting a large
-- window of FileIO data that can be in-flight during read or write
-- operations.
data MsgFileioConfigReq = MsgFileioConfigReq
  { MsgFileioConfigReq -> Word32
_msgFileioConfigReq_sequence :: !Word32
    -- ^ Advice sequence number
  } deriving ( Int -> MsgFileioConfigReq -> ShowS
[MsgFileioConfigReq] -> ShowS
MsgFileioConfigReq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioConfigReq] -> ShowS
$cshowList :: [MsgFileioConfigReq] -> ShowS
show :: MsgFileioConfigReq -> String
$cshow :: MsgFileioConfigReq -> String
showsPrec :: Int -> MsgFileioConfigReq -> ShowS
$cshowsPrec :: Int -> MsgFileioConfigReq -> ShowS
Show, ReadPrec [MsgFileioConfigReq]
ReadPrec MsgFileioConfigReq
Int -> ReadS MsgFileioConfigReq
ReadS [MsgFileioConfigReq]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioConfigReq]
$creadListPrec :: ReadPrec [MsgFileioConfigReq]
readPrec :: ReadPrec MsgFileioConfigReq
$creadPrec :: ReadPrec MsgFileioConfigReq
readList :: ReadS [MsgFileioConfigReq]
$creadList :: ReadS [MsgFileioConfigReq]
readsPrec :: Int -> ReadS MsgFileioConfigReq
$creadsPrec :: Int -> ReadS MsgFileioConfigReq
Read, MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
$c/= :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
== :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
$c== :: MsgFileioConfigReq -> MsgFileioConfigReq -> Bool
Eq )

instance Binary MsgFileioConfigReq where
  get :: Get MsgFileioConfigReq
get = do
    Word32
_msgFileioConfigReq_sequence <- Get Word32
getWord32le
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioConfigReq {Word32
_msgFileioConfigReq_sequence :: Word32
_msgFileioConfigReq_sequence :: Word32
..}

  put :: MsgFileioConfigReq -> Put
put MsgFileioConfigReq {Word32
_msgFileioConfigReq_sequence :: Word32
_msgFileioConfigReq_sequence :: MsgFileioConfigReq -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioConfigReq_sequence

$(makeSBP 'msgFileioConfigReq ''MsgFileioConfigReq)
$(makeJSON "_msgFileioConfigReq_" ''MsgFileioConfigReq)
$(makeLenses ''MsgFileioConfigReq)

msgFileioConfigResp :: Word16
msgFileioConfigResp :: Word16
msgFileioConfigResp = Word16
0x1002

-- | SBP class for message MSG_FILEIO_CONFIG_RESP (0x1002).
--
-- The advice on the optimal configuration for a FileIO transfer.  Newer
-- version of FileIO can support greater throughput by supporting a large
-- window of FileIO data that can be in-flight during read or write
-- operations.
data MsgFileioConfigResp = MsgFileioConfigResp
  { MsgFileioConfigResp -> Word32
_msgFileioConfigResp_sequence     :: !Word32
    -- ^ Advice sequence number
  , MsgFileioConfigResp -> Word32
_msgFileioConfigResp_window_size  :: !Word32
    -- ^ The number of SBP packets in the data in-flight window
  , MsgFileioConfigResp -> Word32
_msgFileioConfigResp_batch_size   :: !Word32
    -- ^ The number of SBP packets sent in one PDU
  , MsgFileioConfigResp -> Word32
_msgFileioConfigResp_fileio_version :: !Word32
    -- ^ The version of FileIO that is supported
  } deriving ( Int -> MsgFileioConfigResp -> ShowS
[MsgFileioConfigResp] -> ShowS
MsgFileioConfigResp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MsgFileioConfigResp] -> ShowS
$cshowList :: [MsgFileioConfigResp] -> ShowS
show :: MsgFileioConfigResp -> String
$cshow :: MsgFileioConfigResp -> String
showsPrec :: Int -> MsgFileioConfigResp -> ShowS
$cshowsPrec :: Int -> MsgFileioConfigResp -> ShowS
Show, ReadPrec [MsgFileioConfigResp]
ReadPrec MsgFileioConfigResp
Int -> ReadS MsgFileioConfigResp
ReadS [MsgFileioConfigResp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MsgFileioConfigResp]
$creadListPrec :: ReadPrec [MsgFileioConfigResp]
readPrec :: ReadPrec MsgFileioConfigResp
$creadPrec :: ReadPrec MsgFileioConfigResp
readList :: ReadS [MsgFileioConfigResp]
$creadList :: ReadS [MsgFileioConfigResp]
readsPrec :: Int -> ReadS MsgFileioConfigResp
$creadsPrec :: Int -> ReadS MsgFileioConfigResp
Read, MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
$c/= :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
== :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
$c== :: MsgFileioConfigResp -> MsgFileioConfigResp -> Bool
Eq )

instance Binary MsgFileioConfigResp where
  get :: Get MsgFileioConfigResp
get = do
    Word32
_msgFileioConfigResp_sequence <- Get Word32
getWord32le
    Word32
_msgFileioConfigResp_window_size <- Get Word32
getWord32le
    Word32
_msgFileioConfigResp_batch_size <- Get Word32
getWord32le
    Word32
_msgFileioConfigResp_fileio_version <- Get Word32
getWord32le
    forall (f :: * -> *) a. Applicative f => a -> f a
pure MsgFileioConfigResp {Word32
_msgFileioConfigResp_fileio_version :: Word32
_msgFileioConfigResp_batch_size :: Word32
_msgFileioConfigResp_window_size :: Word32
_msgFileioConfigResp_sequence :: Word32
_msgFileioConfigResp_fileio_version :: Word32
_msgFileioConfigResp_batch_size :: Word32
_msgFileioConfigResp_window_size :: Word32
_msgFileioConfigResp_sequence :: Word32
..}

  put :: MsgFileioConfigResp -> Put
put MsgFileioConfigResp {Word32
_msgFileioConfigResp_fileio_version :: Word32
_msgFileioConfigResp_batch_size :: Word32
_msgFileioConfigResp_window_size :: Word32
_msgFileioConfigResp_sequence :: Word32
_msgFileioConfigResp_fileio_version :: MsgFileioConfigResp -> Word32
_msgFileioConfigResp_batch_size :: MsgFileioConfigResp -> Word32
_msgFileioConfigResp_window_size :: MsgFileioConfigResp -> Word32
_msgFileioConfigResp_sequence :: MsgFileioConfigResp -> Word32
..} = do
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_sequence
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_window_size
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_batch_size
    Word32 -> Put
putWord32le Word32
_msgFileioConfigResp_fileio_version

$(makeSBP 'msgFileioConfigResp ''MsgFileioConfigResp)
$(makeJSON "_msgFileioConfigResp_" ''MsgFileioConfigResp)
$(makeLenses ''MsgFileioConfigResp)