From 96fcdcbcb3d176f471ba5cf39e52461ea8eb529a Mon Sep 17 00:00:00 2001 From: hhvrc Date: Sun, 12 Jan 2025 19:59:11 +0100 Subject: [PATCH] Initial commit --- .gitignore | 1 + LICENSE | 661 ++++++++++++++++++ README.md | 7 + Serialization/Configuration/BackendConfig.go | 88 +++ .../Configuration/CaptivePortalConfig.go | 68 ++ Serialization/Configuration/EStopConfig.go | 98 +++ Serialization/Configuration/HubConfig.go | 175 +++++ .../Configuration/OtaUpdateChannel.go | 32 + .../Configuration/OtaUpdateConfig.go | 215 ++++++ Serialization/Configuration/OtaUpdateStep.go | 41 ++ Serialization/Configuration/RFConfig.go | 83 +++ .../Configuration/SerialInputConfig.go | 66 ++ Serialization/Configuration/WiFiConfig.go | 103 +++ .../Configuration/WiFiCredentials.go | 92 +++ Serialization/Gateway/BootStatus.go | 97 +++ Serialization/Gateway/GatewayToHubMessage.go | 76 ++ .../Gateway/GatewayToHubMessagePayload.go | 42 ++ Serialization/Gateway/HubToGatewayMessage.go | 76 ++ .../Gateway/HubToGatewayMessagePayload.go | 46 ++ Serialization/Gateway/OtaUpdateFailed.go | 90 +++ Serialization/Gateway/OtaUpdateProgress.go | 96 +++ Serialization/Gateway/OtaUpdateRequest.go | 67 ++ Serialization/Gateway/OtaUpdateStarted.go | 82 +++ Serialization/Gateway/Ping.go | 64 ++ Serialization/Gateway/Pong.go | 79 +++ Serialization/Gateway/ShockerCommand.go | 126 ++++ Serialization/Gateway/ShockerCommandList.go | 75 ++ Serialization/Gateway/Trigger.go | 64 ++ Serialization/Gateway/TriggerType.go | 39 ++ Serialization/Local/AccountLinkCommand.go | 60 ++ .../Local/AccountLinkCommandResult.go | 64 ++ Serialization/Local/AccountLinkResultCode.go | 44 ++ Serialization/Local/AccountUnlinkCommand.go | 64 ++ Serialization/Local/ErrorMessage.go | 60 ++ Serialization/Local/HubToLocalMessage.go | 76 ++ .../Local/HubToLocalMessagePayload.go | 56 ++ Serialization/Local/LocalToHubMessage.go | 76 ++ .../Local/LocalToHubMessagePayload.go | 83 +++ .../Local/OtaUpdateCheckForUpdatesCommand.go | 60 ++ .../OtaUpdateHandleUpdateRequestCommand.go | 64 ++ ...aUpdateSetAllowBackendManagementCommand.go | 64 ++ .../Local/OtaUpdateSetCheckIntervalCommand.go | 64 ++ .../Local/OtaUpdateSetDomainCommand.go | 60 ++ .../Local/OtaUpdateSetIsEnabledCommand.go | 64 ++ ...taUpdateSetRequireManualApprovalCommand.go | 64 ++ .../Local/OtaUpdateSetUpdateChannelCommand.go | 60 ++ .../Local/OtaUpdateStartUpdateCommand.go | 71 ++ Serialization/Local/ReadyMessage.go | 178 +++++ Serialization/Local/SetEstopEnabledCommand.go | 64 ++ .../Local/SetEstopEnabledCommandResult.go | 79 +++ Serialization/Local/SetEstopPinCommand.go | 64 ++ .../Local/SetEstopPinCommandResult.go | 79 +++ Serialization/Local/SetGPIOResultCode.go | 32 + Serialization/Local/SetRfTxPinCommand.go | 64 ++ .../Local/SetRfTxPinCommandResult.go | 79 +++ Serialization/Local/WifiGotIpEvent.go | 60 ++ Serialization/Local/WifiLostIpEvent.go | 60 ++ .../Local/WifiNetworkConnectCommand.go | 60 ++ .../Local/WifiNetworkDisconnectCommand.go | 64 ++ Serialization/Local/WifiNetworkEvent.go | 92 +++ .../Local/WifiNetworkForgetCommand.go | 60 ++ Serialization/Local/WifiNetworkSaveCommand.go | 86 +++ Serialization/Local/WifiScanCommand.go | 64 ++ Serialization/Local/WifiScanStatusMessage.go | 66 ++ Serialization/Types/FirmwareBootType.go | 32 + Serialization/Types/OtaUpdateProgressTask.go | 44 ++ Serialization/Types/SemVer.go | 116 +++ Serialization/Types/ShockerCommandType.go | 35 + Serialization/Types/ShockerModelType.go | 32 + Serialization/Types/WifiAuthMode.go | 53 ++ Serialization/Types/WifiNetwork.go | 131 ++++ Serialization/Types/WifiNetworkEventType.go | 44 ++ Serialization/Types/WifiScanStatus.go | 41 ++ go.mod | 8 + go.sum | 4 + main.go | 328 +++++++++ 76 files changed, 6122 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 Serialization/Configuration/BackendConfig.go create mode 100644 Serialization/Configuration/CaptivePortalConfig.go create mode 100644 Serialization/Configuration/EStopConfig.go create mode 100644 Serialization/Configuration/HubConfig.go create mode 100644 Serialization/Configuration/OtaUpdateChannel.go create mode 100644 Serialization/Configuration/OtaUpdateConfig.go create mode 100644 Serialization/Configuration/OtaUpdateStep.go create mode 100644 Serialization/Configuration/RFConfig.go create mode 100644 Serialization/Configuration/SerialInputConfig.go create mode 100644 Serialization/Configuration/WiFiConfig.go create mode 100644 Serialization/Configuration/WiFiCredentials.go create mode 100644 Serialization/Gateway/BootStatus.go create mode 100644 Serialization/Gateway/GatewayToHubMessage.go create mode 100644 Serialization/Gateway/GatewayToHubMessagePayload.go create mode 100644 Serialization/Gateway/HubToGatewayMessage.go create mode 100644 Serialization/Gateway/HubToGatewayMessagePayload.go create mode 100644 Serialization/Gateway/OtaUpdateFailed.go create mode 100644 Serialization/Gateway/OtaUpdateProgress.go create mode 100644 Serialization/Gateway/OtaUpdateRequest.go create mode 100644 Serialization/Gateway/OtaUpdateStarted.go create mode 100644 Serialization/Gateway/Ping.go create mode 100644 Serialization/Gateway/Pong.go create mode 100644 Serialization/Gateway/ShockerCommand.go create mode 100644 Serialization/Gateway/ShockerCommandList.go create mode 100644 Serialization/Gateway/Trigger.go create mode 100644 Serialization/Gateway/TriggerType.go create mode 100644 Serialization/Local/AccountLinkCommand.go create mode 100644 Serialization/Local/AccountLinkCommandResult.go create mode 100644 Serialization/Local/AccountLinkResultCode.go create mode 100644 Serialization/Local/AccountUnlinkCommand.go create mode 100644 Serialization/Local/ErrorMessage.go create mode 100644 Serialization/Local/HubToLocalMessage.go create mode 100644 Serialization/Local/HubToLocalMessagePayload.go create mode 100644 Serialization/Local/LocalToHubMessage.go create mode 100644 Serialization/Local/LocalToHubMessagePayload.go create mode 100644 Serialization/Local/OtaUpdateCheckForUpdatesCommand.go create mode 100644 Serialization/Local/OtaUpdateHandleUpdateRequestCommand.go create mode 100644 Serialization/Local/OtaUpdateSetAllowBackendManagementCommand.go create mode 100644 Serialization/Local/OtaUpdateSetCheckIntervalCommand.go create mode 100644 Serialization/Local/OtaUpdateSetDomainCommand.go create mode 100644 Serialization/Local/OtaUpdateSetIsEnabledCommand.go create mode 100644 Serialization/Local/OtaUpdateSetRequireManualApprovalCommand.go create mode 100644 Serialization/Local/OtaUpdateSetUpdateChannelCommand.go create mode 100644 Serialization/Local/OtaUpdateStartUpdateCommand.go create mode 100644 Serialization/Local/ReadyMessage.go create mode 100644 Serialization/Local/SetEstopEnabledCommand.go create mode 100644 Serialization/Local/SetEstopEnabledCommandResult.go create mode 100644 Serialization/Local/SetEstopPinCommand.go create mode 100644 Serialization/Local/SetEstopPinCommandResult.go create mode 100644 Serialization/Local/SetGPIOResultCode.go create mode 100644 Serialization/Local/SetRfTxPinCommand.go create mode 100644 Serialization/Local/SetRfTxPinCommandResult.go create mode 100644 Serialization/Local/WifiGotIpEvent.go create mode 100644 Serialization/Local/WifiLostIpEvent.go create mode 100644 Serialization/Local/WifiNetworkConnectCommand.go create mode 100644 Serialization/Local/WifiNetworkDisconnectCommand.go create mode 100644 Serialization/Local/WifiNetworkEvent.go create mode 100644 Serialization/Local/WifiNetworkForgetCommand.go create mode 100644 Serialization/Local/WifiNetworkSaveCommand.go create mode 100644 Serialization/Local/WifiScanCommand.go create mode 100644 Serialization/Local/WifiScanStatusMessage.go create mode 100644 Serialization/Types/FirmwareBootType.go create mode 100644 Serialization/Types/OtaUpdateProgressTask.go create mode 100644 Serialization/Types/SemVer.go create mode 100644 Serialization/Types/ShockerCommandType.go create mode 100644 Serialization/Types/ShockerModelType.go create mode 100644 Serialization/Types/WifiAuthMode.go create mode 100644 Serialization/Types/WifiNetwork.go create mode 100644 Serialization/Types/WifiNetworkEventType.go create mode 100644 Serialization/Types/WifiScanStatus.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 main.go diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0cffcb3 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +config.json \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..bae94e1 --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..a5cd5f0 --- /dev/null +++ b/README.md @@ -0,0 +1,7 @@ +# OpenShock Dummy Hub + +Dummy hub for openshock, used for testing. + +## Support + +You can support the openshock dev team here: [Sponsor OpenShock](https://github.com/sponsors/OpenShock) diff --git a/Serialization/Configuration/BackendConfig.go b/Serialization/Configuration/BackendConfig.go new file mode 100644 index 0000000..378dd5e --- /dev/null +++ b/Serialization/Configuration/BackendConfig.go @@ -0,0 +1,88 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BackendConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsBackendConfig(buf []byte, offset flatbuffers.UOffsetT) *BackendConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BackendConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishBackendConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsBackendConfig(buf []byte, offset flatbuffers.UOffsetT) *BackendConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BackendConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedBackendConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *BackendConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BackendConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// Domain name of the backend server, e.g. "api.shocklink.net" +func (rcv *BackendConfig) Domain() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Domain name of the backend server, e.g. "api.shocklink.net" +/// Authentication token for the backend server +func (rcv *BackendConfig) AuthToken() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Authentication token for the backend server +/// Override the Live-Control-Gateway (LCG) URL +func (rcv *BackendConfig) LcgOverride() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Override the Live-Control-Gateway (LCG) URL +func BackendConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func BackendConfigAddDomain(builder *flatbuffers.Builder, domain flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(domain), 0) +} +func BackendConfigAddAuthToken(builder *flatbuffers.Builder, authToken flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(authToken), 0) +} +func BackendConfigAddLcgOverride(builder *flatbuffers.Builder, lcgOverride flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(lcgOverride), 0) +} +func BackendConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/CaptivePortalConfig.go b/Serialization/Configuration/CaptivePortalConfig.go new file mode 100644 index 0000000..6f54d68 --- /dev/null +++ b/Serialization/Configuration/CaptivePortalConfig.go @@ -0,0 +1,68 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CaptivePortalConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsCaptivePortalConfig(buf []byte, offset flatbuffers.UOffsetT) *CaptivePortalConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CaptivePortalConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishCaptivePortalConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsCaptivePortalConfig(buf []byte, offset flatbuffers.UOffsetT) *CaptivePortalConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CaptivePortalConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedCaptivePortalConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *CaptivePortalConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CaptivePortalConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// Whether the captive portal is forced to be enabled +/// The captive portal will otherwise shut down when a gateway connection is established +func (rcv *CaptivePortalConfig) AlwaysEnabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Whether the captive portal is forced to be enabled +/// The captive portal will otherwise shut down when a gateway connection is established +func (rcv *CaptivePortalConfig) MutateAlwaysEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func CaptivePortalConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func CaptivePortalConfigAddAlwaysEnabled(builder *flatbuffers.Builder, alwaysEnabled bool) { + builder.PrependBoolSlot(0, alwaysEnabled, false) +} +func CaptivePortalConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/EStopConfig.go b/Serialization/Configuration/EStopConfig.go new file mode 100644 index 0000000..4f80cfd --- /dev/null +++ b/Serialization/Configuration/EStopConfig.go @@ -0,0 +1,98 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type EStopConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsEStopConfig(buf []byte, offset flatbuffers.UOffsetT) *EStopConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &EStopConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishEStopConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsEStopConfig(buf []byte, offset flatbuffers.UOffsetT) *EStopConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &EStopConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedEStopConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *EStopConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *EStopConfig) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *EStopConfig) Enabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *EStopConfig) MutateEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// The GPIO pin connected to the E-Stop button +func (rcv *EStopConfig) GpioPin() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +/// The GPIO pin connected to the E-Stop button +func (rcv *EStopConfig) MutateGpioPin(n int8) bool { + return rcv._tab.MutateInt8Slot(6, n) +} + +/// Persistent state of the E-Stop button +func (rcv *EStopConfig) Active() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Persistent state of the E-Stop button +func (rcv *EStopConfig) MutateActive(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func EStopConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func EStopConfigAddEnabled(builder *flatbuffers.Builder, enabled bool) { + builder.PrependBoolSlot(0, enabled, false) +} +func EStopConfigAddGpioPin(builder *flatbuffers.Builder, gpioPin int8) { + builder.PrependInt8Slot(1, gpioPin, 0) +} +func EStopConfigAddActive(builder *flatbuffers.Builder, active bool) { + builder.PrependBoolSlot(2, active, false) +} +func EStopConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/HubConfig.go b/Serialization/Configuration/HubConfig.go new file mode 100644 index 0000000..a5d4804 --- /dev/null +++ b/Serialization/Configuration/HubConfig.go @@ -0,0 +1,175 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type HubConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsHubConfig(buf []byte, offset flatbuffers.UOffsetT) *HubConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HubConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishHubConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsHubConfig(buf []byte, offset flatbuffers.UOffsetT) *HubConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HubConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedHubConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *HubConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HubConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// RF Transmitter configuration +func (rcv *HubConfig) Rf(obj *RFConfig) *RFConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(RFConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// RF Transmitter configuration +/// WiFi configuration +func (rcv *HubConfig) Wifi(obj *WiFiConfig) *WiFiConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(WiFiConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// WiFi configuration +/// Captive portal configuration +func (rcv *HubConfig) CaptivePortal(obj *CaptivePortalConfig) *CaptivePortalConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(CaptivePortalConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// Captive portal configuration +/// Backend configuration +func (rcv *HubConfig) Backend(obj *BackendConfig) *BackendConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(BackendConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// Backend configuration +/// Serial input configuration +func (rcv *HubConfig) SerialInput(obj *SerialInputConfig) *SerialInputConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(SerialInputConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// Serial input configuration +/// OTA update configuration +func (rcv *HubConfig) OtaUpdate(obj *OtaUpdateConfig) *OtaUpdateConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(OtaUpdateConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// OTA update configuration +/// E-Stop configuration +func (rcv *HubConfig) Estop(obj *EStopConfig) *EStopConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(EStopConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// E-Stop configuration +func HubConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(7) +} +func HubConfigAddRf(builder *flatbuffers.Builder, rf flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(rf), 0) +} +func HubConfigAddWifi(builder *flatbuffers.Builder, wifi flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(wifi), 0) +} +func HubConfigAddCaptivePortal(builder *flatbuffers.Builder, captivePortal flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(captivePortal), 0) +} +func HubConfigAddBackend(builder *flatbuffers.Builder, backend flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(backend), 0) +} +func HubConfigAddSerialInput(builder *flatbuffers.Builder, serialInput flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(serialInput), 0) +} +func HubConfigAddOtaUpdate(builder *flatbuffers.Builder, otaUpdate flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(otaUpdate), 0) +} +func HubConfigAddEstop(builder *flatbuffers.Builder, estop flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(estop), 0) +} +func HubConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/OtaUpdateChannel.go b/Serialization/Configuration/OtaUpdateChannel.go new file mode 100644 index 0000000..ea00232 --- /dev/null +++ b/Serialization/Configuration/OtaUpdateChannel.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import "strconv" + +type OtaUpdateChannel byte + +const ( + OtaUpdateChannelStable OtaUpdateChannel = 0 + OtaUpdateChannelBeta OtaUpdateChannel = 1 + OtaUpdateChannelDevelop OtaUpdateChannel = 2 +) + +var EnumNamesOtaUpdateChannel = map[OtaUpdateChannel]string{ + OtaUpdateChannelStable: "Stable", + OtaUpdateChannelBeta: "Beta", + OtaUpdateChannelDevelop: "Develop", +} + +var EnumValuesOtaUpdateChannel = map[string]OtaUpdateChannel{ + "Stable": OtaUpdateChannelStable, + "Beta": OtaUpdateChannelBeta, + "Develop": OtaUpdateChannelDevelop, +} + +func (v OtaUpdateChannel) String() string { + if s, ok := EnumNamesOtaUpdateChannel[v]; ok { + return s + } + return "OtaUpdateChannel(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Configuration/OtaUpdateConfig.go b/Serialization/Configuration/OtaUpdateConfig.go new file mode 100644 index 0000000..28f8789 --- /dev/null +++ b/Serialization/Configuration/OtaUpdateConfig.go @@ -0,0 +1,215 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateConfig(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateConfig(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// Indicates whether OTA updates are enabled. +func (rcv *OtaUpdateConfig) IsEnabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indicates whether OTA updates are enabled. +func (rcv *OtaUpdateConfig) MutateIsEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// The domain name of the OTA Content Delivery Network (CDN). +func (rcv *OtaUpdateConfig) CdnDomain() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// The domain name of the OTA Content Delivery Network (CDN). +/// The update channel to use. +func (rcv *OtaUpdateConfig) UpdateChannel() OtaUpdateChannel { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return OtaUpdateChannel(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +/// The update channel to use. +func (rcv *OtaUpdateConfig) MutateUpdateChannel(n OtaUpdateChannel) bool { + return rcv._tab.MutateByteSlot(8, byte(n)) +} + +/// Indicates whether to check for updates on startup. +func (rcv *OtaUpdateConfig) CheckOnStartup() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indicates whether to check for updates on startup. +func (rcv *OtaUpdateConfig) MutateCheckOnStartup(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +/// Indicates whether to check for updates periodically. +func (rcv *OtaUpdateConfig) CheckPeriodically() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indicates whether to check for updates periodically. +func (rcv *OtaUpdateConfig) MutateCheckPeriodically(n bool) bool { + return rcv._tab.MutateBoolSlot(12, n) +} + +/// The interval in minutes between periodic update checks. +func (rcv *OtaUpdateConfig) CheckInterval() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +/// The interval in minutes between periodic update checks. +func (rcv *OtaUpdateConfig) MutateCheckInterval(n uint16) bool { + return rcv._tab.MutateUint16Slot(14, n) +} + +/// Indicates if the backend is authorized to manage the hub's update version on behalf of the user. +func (rcv *OtaUpdateConfig) AllowBackendManagement() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indicates if the backend is authorized to manage the hub's update version on behalf of the user. +func (rcv *OtaUpdateConfig) MutateAllowBackendManagement(n bool) bool { + return rcv._tab.MutateBoolSlot(16, n) +} + +/// Indicates if manual approval via serial input or captive portal is required before installing updates. +func (rcv *OtaUpdateConfig) RequireManualApproval() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Indicates if manual approval via serial input or captive portal is required before installing updates. +func (rcv *OtaUpdateConfig) MutateRequireManualApproval(n bool) bool { + return rcv._tab.MutateBoolSlot(18, n) +} + +/// Update process ID, used to track the update process server-side across reboots. +func (rcv *OtaUpdateConfig) UpdateId() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +/// Update process ID, used to track the update process server-side across reboots. +func (rcv *OtaUpdateConfig) MutateUpdateId(n int32) bool { + return rcv._tab.MutateInt32Slot(20, n) +} + +/// Indicates what step of the update process the hub is currently in, used to detect failed updates for status reporting. +func (rcv *OtaUpdateConfig) UpdateStep() OtaUpdateStep { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return OtaUpdateStep(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +/// Indicates what step of the update process the hub is currently in, used to detect failed updates for status reporting. +func (rcv *OtaUpdateConfig) MutateUpdateStep(n OtaUpdateStep) bool { + return rcv._tab.MutateByteSlot(22, byte(n)) +} + +func OtaUpdateConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(10) +} +func OtaUpdateConfigAddIsEnabled(builder *flatbuffers.Builder, isEnabled bool) { + builder.PrependBoolSlot(0, isEnabled, false) +} +func OtaUpdateConfigAddCdnDomain(builder *flatbuffers.Builder, cdnDomain flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(cdnDomain), 0) +} +func OtaUpdateConfigAddUpdateChannel(builder *flatbuffers.Builder, updateChannel OtaUpdateChannel) { + builder.PrependByteSlot(2, byte(updateChannel), 0) +} +func OtaUpdateConfigAddCheckOnStartup(builder *flatbuffers.Builder, checkOnStartup bool) { + builder.PrependBoolSlot(3, checkOnStartup, false) +} +func OtaUpdateConfigAddCheckPeriodically(builder *flatbuffers.Builder, checkPeriodically bool) { + builder.PrependBoolSlot(4, checkPeriodically, false) +} +func OtaUpdateConfigAddCheckInterval(builder *flatbuffers.Builder, checkInterval uint16) { + builder.PrependUint16Slot(5, checkInterval, 0) +} +func OtaUpdateConfigAddAllowBackendManagement(builder *flatbuffers.Builder, allowBackendManagement bool) { + builder.PrependBoolSlot(6, allowBackendManagement, false) +} +func OtaUpdateConfigAddRequireManualApproval(builder *flatbuffers.Builder, requireManualApproval bool) { + builder.PrependBoolSlot(7, requireManualApproval, false) +} +func OtaUpdateConfigAddUpdateId(builder *flatbuffers.Builder, updateId int32) { + builder.PrependInt32Slot(8, updateId, 0) +} +func OtaUpdateConfigAddUpdateStep(builder *flatbuffers.Builder, updateStep OtaUpdateStep) { + builder.PrependByteSlot(9, byte(updateStep), 0) +} +func OtaUpdateConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/OtaUpdateStep.go b/Serialization/Configuration/OtaUpdateStep.go new file mode 100644 index 0000000..5293f8a --- /dev/null +++ b/Serialization/Configuration/OtaUpdateStep.go @@ -0,0 +1,41 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import "strconv" + +type OtaUpdateStep byte + +const ( + OtaUpdateStepNone OtaUpdateStep = 0 + OtaUpdateStepUpdating OtaUpdateStep = 1 + OtaUpdateStepUpdated OtaUpdateStep = 2 + OtaUpdateStepValidating OtaUpdateStep = 3 + OtaUpdateStepValidated OtaUpdateStep = 4 + OtaUpdateStepRollingBack OtaUpdateStep = 5 +) + +var EnumNamesOtaUpdateStep = map[OtaUpdateStep]string{ + OtaUpdateStepNone: "None", + OtaUpdateStepUpdating: "Updating", + OtaUpdateStepUpdated: "Updated", + OtaUpdateStepValidating: "Validating", + OtaUpdateStepValidated: "Validated", + OtaUpdateStepRollingBack: "RollingBack", +} + +var EnumValuesOtaUpdateStep = map[string]OtaUpdateStep{ + "None": OtaUpdateStepNone, + "Updating": OtaUpdateStepUpdating, + "Updated": OtaUpdateStepUpdated, + "Validating": OtaUpdateStepValidating, + "Validated": OtaUpdateStepValidated, + "RollingBack": OtaUpdateStepRollingBack, +} + +func (v OtaUpdateStep) String() string { + if s, ok := EnumNamesOtaUpdateStep[v]; ok { + return s + } + return "OtaUpdateStep(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Configuration/RFConfig.go b/Serialization/Configuration/RFConfig.go new file mode 100644 index 0000000..4a3a336 --- /dev/null +++ b/Serialization/Configuration/RFConfig.go @@ -0,0 +1,83 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type RFConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsRFConfig(buf []byte, offset flatbuffers.UOffsetT) *RFConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &RFConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishRFConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsRFConfig(buf []byte, offset flatbuffers.UOffsetT) *RFConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &RFConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedRFConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *RFConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *RFConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// The GPIO pin connected to the RF modulator's data pin for transmitting (TX) +func (rcv *RFConfig) TxPin() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +/// The GPIO pin connected to the RF modulator's data pin for transmitting (TX) +func (rcv *RFConfig) MutateTxPin(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +/// Whether to transmit keepalive messages to keep the shockers from entering sleep mode +func (rcv *RFConfig) KeepaliveEnabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Whether to transmit keepalive messages to keep the shockers from entering sleep mode +func (rcv *RFConfig) MutateKeepaliveEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func RFConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func RFConfigAddTxPin(builder *flatbuffers.Builder, txPin int8) { + builder.PrependInt8Slot(0, txPin, 0) +} +func RFConfigAddKeepaliveEnabled(builder *flatbuffers.Builder, keepaliveEnabled bool) { + builder.PrependBoolSlot(1, keepaliveEnabled, false) +} +func RFConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/SerialInputConfig.go b/Serialization/Configuration/SerialInputConfig.go new file mode 100644 index 0000000..a21e82f --- /dev/null +++ b/Serialization/Configuration/SerialInputConfig.go @@ -0,0 +1,66 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SerialInputConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsSerialInputConfig(buf []byte, offset flatbuffers.UOffsetT) *SerialInputConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SerialInputConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishSerialInputConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSerialInputConfig(buf []byte, offset flatbuffers.UOffsetT) *SerialInputConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SerialInputConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSerialInputConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SerialInputConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SerialInputConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// Whether to echo typed characters back to the serial console +func (rcv *SerialInputConfig) EchoEnabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +/// Whether to echo typed characters back to the serial console +func (rcv *SerialInputConfig) MutateEchoEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func SerialInputConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func SerialInputConfigAddEchoEnabled(builder *flatbuffers.Builder, echoEnabled bool) { + builder.PrependBoolSlot(0, echoEnabled, true) +} +func SerialInputConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/WiFiConfig.go b/Serialization/Configuration/WiFiConfig.go new file mode 100644 index 0000000..c0781f8 --- /dev/null +++ b/Serialization/Configuration/WiFiConfig.go @@ -0,0 +1,103 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WiFiConfig struct { + _tab flatbuffers.Table +} + +func GetRootAsWiFiConfig(buf []byte, offset flatbuffers.UOffsetT) *WiFiConfig { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WiFiConfig{} + x.Init(buf, n+offset) + return x +} + +func FinishWiFiConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWiFiConfig(buf []byte, offset flatbuffers.UOffsetT) *WiFiConfig { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WiFiConfig{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWiFiConfigBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WiFiConfig) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WiFiConfig) Table() flatbuffers.Table { + return rcv._tab +} + +/// Access point SSID +func (rcv *WiFiConfig) ApSsid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Access point SSID +/// Hub hostname +func (rcv *WiFiConfig) Hostname() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Hub hostname +/// WiFi network credentials +func (rcv *WiFiConfig) Credentials(obj *WiFiCredentials, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *WiFiConfig) CredentialsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// WiFi network credentials +func WiFiConfigStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func WiFiConfigAddApSsid(builder *flatbuffers.Builder, apSsid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(apSsid), 0) +} +func WiFiConfigAddHostname(builder *flatbuffers.Builder, hostname flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(hostname), 0) +} +func WiFiConfigAddCredentials(builder *flatbuffers.Builder, credentials flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(credentials), 0) +} +func WiFiConfigStartCredentialsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func WiFiConfigEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Configuration/WiFiCredentials.go b/Serialization/Configuration/WiFiCredentials.go new file mode 100644 index 0000000..b035a28 --- /dev/null +++ b/Serialization/Configuration/WiFiCredentials.go @@ -0,0 +1,92 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Configuration + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WiFiCredentials struct { + _tab flatbuffers.Table +} + +func GetRootAsWiFiCredentials(buf []byte, offset flatbuffers.UOffsetT) *WiFiCredentials { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WiFiCredentials{} + x.Init(buf, n+offset) + return x +} + +func FinishWiFiCredentialsBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWiFiCredentials(buf []byte, offset flatbuffers.UOffsetT) *WiFiCredentials { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WiFiCredentials{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWiFiCredentialsBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WiFiCredentials) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WiFiCredentials) Table() flatbuffers.Table { + return rcv._tab +} + +/// ID of the WiFi network credentials, used for referencing the credentials with a low memory footprint +func (rcv *WiFiCredentials) Id() byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetByte(o + rcv._tab.Pos) + } + return 0 +} + +/// ID of the WiFi network credentials, used for referencing the credentials with a low memory footprint +func (rcv *WiFiCredentials) MutateId(n byte) bool { + return rcv._tab.MutateByteSlot(4, n) +} + +/// SSID of the WiFi network +func (rcv *WiFiCredentials) Ssid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// SSID of the WiFi network +/// Password of the WiFi network +func (rcv *WiFiCredentials) Password() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Password of the WiFi network +func WiFiCredentialsStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func WiFiCredentialsAddId(builder *flatbuffers.Builder, id byte) { + builder.PrependByteSlot(0, id, 0) +} +func WiFiCredentialsAddSsid(builder *flatbuffers.Builder, ssid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(ssid), 0) +} +func WiFiCredentialsAddPassword(builder *flatbuffers.Builder, password flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(password), 0) +} +func WiFiCredentialsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/BootStatus.go b/Serialization/Gateway/BootStatus.go new file mode 100644 index 0000000..298709a --- /dev/null +++ b/Serialization/Gateway/BootStatus.go @@ -0,0 +1,97 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type BootStatus struct { + _tab flatbuffers.Table +} + +func GetRootAsBootStatus(buf []byte, offset flatbuffers.UOffsetT) *BootStatus { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BootStatus{} + x.Init(buf, n+offset) + return x +} + +func FinishBootStatusBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsBootStatus(buf []byte, offset flatbuffers.UOffsetT) *BootStatus { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BootStatus{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedBootStatusBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *BootStatus) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BootStatus) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *BootStatus) BootType() OpenShock__Serialization__Types.FirmwareBootType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return OpenShock__Serialization__Types.FirmwareBootType(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *BootStatus) MutateBootType(n OpenShock__Serialization__Types.FirmwareBootType) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *BootStatus) FirmwareVersion(obj *OpenShock__Serialization__Types.SemVer) *OpenShock__Serialization__Types.SemVer { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(OpenShock__Serialization__Types.SemVer) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *BootStatus) OtaUpdateId() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *BootStatus) MutateOtaUpdateId(n int32) bool { + return rcv._tab.MutateInt32Slot(8, n) +} + +func BootStatusStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func BootStatusAddBootType(builder *flatbuffers.Builder, bootType OpenShock__Serialization__Types.FirmwareBootType) { + builder.PrependByteSlot(0, byte(bootType), 0) +} +func BootStatusAddFirmwareVersion(builder *flatbuffers.Builder, firmwareVersion flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(firmwareVersion), 0) +} +func BootStatusAddOtaUpdateId(builder *flatbuffers.Builder, otaUpdateId int32) { + builder.PrependInt32Slot(2, otaUpdateId, 0) +} +func BootStatusEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/GatewayToHubMessage.go b/Serialization/Gateway/GatewayToHubMessage.go new file mode 100644 index 0000000..957f623 --- /dev/null +++ b/Serialization/Gateway/GatewayToHubMessage.go @@ -0,0 +1,76 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type GatewayToHubMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsGatewayToHubMessage(buf []byte, offset flatbuffers.UOffsetT) *GatewayToHubMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &GatewayToHubMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishGatewayToHubMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsGatewayToHubMessage(buf []byte, offset flatbuffers.UOffsetT) *GatewayToHubMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &GatewayToHubMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedGatewayToHubMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *GatewayToHubMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *GatewayToHubMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *GatewayToHubMessage) PayloadType() GatewayToHubMessagePayload { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return GatewayToHubMessagePayload(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *GatewayToHubMessage) MutatePayloadType(n GatewayToHubMessagePayload) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *GatewayToHubMessage) Payload(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func GatewayToHubMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func GatewayToHubMessageAddPayloadType(builder *flatbuffers.Builder, payloadType GatewayToHubMessagePayload) { + builder.PrependByteSlot(0, byte(payloadType), 0) +} +func GatewayToHubMessageAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(payload), 0) +} +func GatewayToHubMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/GatewayToHubMessagePayload.go b/Serialization/Gateway/GatewayToHubMessagePayload.go new file mode 100644 index 0000000..ed3978c --- /dev/null +++ b/Serialization/Gateway/GatewayToHubMessagePayload.go @@ -0,0 +1,42 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import "strconv" + +type GatewayToHubMessagePayload byte + +const ( + GatewayToHubMessagePayloadNONE GatewayToHubMessagePayload = 0 + /// Ping message, should immediately be responded to with a pong + GatewayToHubMessagePayloadPing GatewayToHubMessagePayload = 1 + /// Trigger a specific action on the hub + GatewayToHubMessagePayloadTrigger GatewayToHubMessagePayload = 2 + /// Send a list of shocker commands to the hub + GatewayToHubMessagePayloadShockerCommandList GatewayToHubMessagePayload = 3 + /// Request an OTA update to be performed + GatewayToHubMessagePayloadOtaUpdateRequest GatewayToHubMessagePayload = 4 +) + +var EnumNamesGatewayToHubMessagePayload = map[GatewayToHubMessagePayload]string{ + GatewayToHubMessagePayloadNONE: "NONE", + GatewayToHubMessagePayloadPing: "Ping", + GatewayToHubMessagePayloadTrigger: "Trigger", + GatewayToHubMessagePayloadShockerCommandList: "ShockerCommandList", + GatewayToHubMessagePayloadOtaUpdateRequest: "OtaUpdateRequest", +} + +var EnumValuesGatewayToHubMessagePayload = map[string]GatewayToHubMessagePayload{ + "NONE": GatewayToHubMessagePayloadNONE, + "Ping": GatewayToHubMessagePayloadPing, + "Trigger": GatewayToHubMessagePayloadTrigger, + "ShockerCommandList": GatewayToHubMessagePayloadShockerCommandList, + "OtaUpdateRequest": GatewayToHubMessagePayloadOtaUpdateRequest, +} + +func (v GatewayToHubMessagePayload) String() string { + if s, ok := EnumNamesGatewayToHubMessagePayload[v]; ok { + return s + } + return "GatewayToHubMessagePayload(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Gateway/HubToGatewayMessage.go b/Serialization/Gateway/HubToGatewayMessage.go new file mode 100644 index 0000000..9b85cdd --- /dev/null +++ b/Serialization/Gateway/HubToGatewayMessage.go @@ -0,0 +1,76 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type HubToGatewayMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsHubToGatewayMessage(buf []byte, offset flatbuffers.UOffsetT) *HubToGatewayMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HubToGatewayMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishHubToGatewayMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsHubToGatewayMessage(buf []byte, offset flatbuffers.UOffsetT) *HubToGatewayMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HubToGatewayMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedHubToGatewayMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *HubToGatewayMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HubToGatewayMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *HubToGatewayMessage) PayloadType() HubToGatewayMessagePayload { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return HubToGatewayMessagePayload(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *HubToGatewayMessage) MutatePayloadType(n HubToGatewayMessagePayload) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *HubToGatewayMessage) Payload(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func HubToGatewayMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func HubToGatewayMessageAddPayloadType(builder *flatbuffers.Builder, payloadType HubToGatewayMessagePayload) { + builder.PrependByteSlot(0, byte(payloadType), 0) +} +func HubToGatewayMessageAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(payload), 0) +} +func HubToGatewayMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/HubToGatewayMessagePayload.go b/Serialization/Gateway/HubToGatewayMessagePayload.go new file mode 100644 index 0000000..29e478f --- /dev/null +++ b/Serialization/Gateway/HubToGatewayMessagePayload.go @@ -0,0 +1,46 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import "strconv" + +type HubToGatewayMessagePayload byte + +const ( + HubToGatewayMessagePayloadNONE HubToGatewayMessagePayload = 0 + /// Respond to a ping message + HubToGatewayMessagePayloadPong HubToGatewayMessagePayload = 1 + /// Report the current boot status, used to report firmware version and OTA update results + HubToGatewayMessagePayloadBootStatus HubToGatewayMessagePayload = 2 + /// Report that an OTA update has started + HubToGatewayMessagePayloadOtaUpdateStarted HubToGatewayMessagePayload = 3 + /// Report the progress of an OTA update + HubToGatewayMessagePayloadOtaUpdateProgress HubToGatewayMessagePayload = 4 + /// Report that an OTA update has failed + HubToGatewayMessagePayloadOtaUpdateFailed HubToGatewayMessagePayload = 5 +) + +var EnumNamesHubToGatewayMessagePayload = map[HubToGatewayMessagePayload]string{ + HubToGatewayMessagePayloadNONE: "NONE", + HubToGatewayMessagePayloadPong: "Pong", + HubToGatewayMessagePayloadBootStatus: "BootStatus", + HubToGatewayMessagePayloadOtaUpdateStarted: "OtaUpdateStarted", + HubToGatewayMessagePayloadOtaUpdateProgress: "OtaUpdateProgress", + HubToGatewayMessagePayloadOtaUpdateFailed: "OtaUpdateFailed", +} + +var EnumValuesHubToGatewayMessagePayload = map[string]HubToGatewayMessagePayload{ + "NONE": HubToGatewayMessagePayloadNONE, + "Pong": HubToGatewayMessagePayloadPong, + "BootStatus": HubToGatewayMessagePayloadBootStatus, + "OtaUpdateStarted": HubToGatewayMessagePayloadOtaUpdateStarted, + "OtaUpdateProgress": HubToGatewayMessagePayloadOtaUpdateProgress, + "OtaUpdateFailed": HubToGatewayMessagePayloadOtaUpdateFailed, +} + +func (v HubToGatewayMessagePayload) String() string { + if s, ok := EnumNamesHubToGatewayMessagePayload[v]; ok { + return s + } + return "HubToGatewayMessagePayload(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Gateway/OtaUpdateFailed.go b/Serialization/Gateway/OtaUpdateFailed.go new file mode 100644 index 0000000..96e7792 --- /dev/null +++ b/Serialization/Gateway/OtaUpdateFailed.go @@ -0,0 +1,90 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateFailed struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateFailed(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateFailed { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateFailed{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateFailedBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateFailed(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateFailed { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateFailed{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateFailedBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateFailed) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateFailed) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateFailed) UpdateId() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *OtaUpdateFailed) MutateUpdateId(n int32) bool { + return rcv._tab.MutateInt32Slot(4, n) +} + +func (rcv *OtaUpdateFailed) Message() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *OtaUpdateFailed) Fatal() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *OtaUpdateFailed) MutateFatal(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func OtaUpdateFailedStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func OtaUpdateFailedAddUpdateId(builder *flatbuffers.Builder, updateId int32) { + builder.PrependInt32Slot(0, updateId, 0) +} +func OtaUpdateFailedAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(message), 0) +} +func OtaUpdateFailedAddFatal(builder *flatbuffers.Builder, fatal bool) { + builder.PrependBoolSlot(2, fatal, false) +} +func OtaUpdateFailedEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/OtaUpdateProgress.go b/Serialization/Gateway/OtaUpdateProgress.go new file mode 100644 index 0000000..11bdd79 --- /dev/null +++ b/Serialization/Gateway/OtaUpdateProgress.go @@ -0,0 +1,96 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type OtaUpdateProgress struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateProgress(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateProgress { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateProgress{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateProgressBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateProgress(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateProgress { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateProgress{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateProgressBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateProgress) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateProgress) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateProgress) UpdateId() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *OtaUpdateProgress) MutateUpdateId(n int32) bool { + return rcv._tab.MutateInt32Slot(4, n) +} + +func (rcv *OtaUpdateProgress) Task() OpenShock__Serialization__Types.OtaUpdateProgressTask { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return OpenShock__Serialization__Types.OtaUpdateProgressTask(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *OtaUpdateProgress) MutateTask(n OpenShock__Serialization__Types.OtaUpdateProgressTask) bool { + return rcv._tab.MutateByteSlot(6, byte(n)) +} + +func (rcv *OtaUpdateProgress) Progress() float32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat32(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *OtaUpdateProgress) MutateProgress(n float32) bool { + return rcv._tab.MutateFloat32Slot(8, n) +} + +func OtaUpdateProgressStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func OtaUpdateProgressAddUpdateId(builder *flatbuffers.Builder, updateId int32) { + builder.PrependInt32Slot(0, updateId, 0) +} +func OtaUpdateProgressAddTask(builder *flatbuffers.Builder, task OpenShock__Serialization__Types.OtaUpdateProgressTask) { + builder.PrependByteSlot(1, byte(task), 0) +} +func OtaUpdateProgressAddProgress(builder *flatbuffers.Builder, progress float32) { + builder.PrependFloat32Slot(2, progress, 0.0) +} +func OtaUpdateProgressEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/OtaUpdateRequest.go b/Serialization/Gateway/OtaUpdateRequest.go new file mode 100644 index 0000000..e711e69 --- /dev/null +++ b/Serialization/Gateway/OtaUpdateRequest.go @@ -0,0 +1,67 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type OtaUpdateRequest struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateRequest(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateRequest { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateRequest{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateRequest(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateRequest { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateRequest{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateRequest) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateRequest) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateRequest) Version(obj *OpenShock__Serialization__Types.SemVer) *OpenShock__Serialization__Types.SemVer { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(OpenShock__Serialization__Types.SemVer) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func OtaUpdateRequestStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateRequestAddVersion(builder *flatbuffers.Builder, version flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(version), 0) +} +func OtaUpdateRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/OtaUpdateStarted.go b/Serialization/Gateway/OtaUpdateStarted.go new file mode 100644 index 0000000..b3a8003 --- /dev/null +++ b/Serialization/Gateway/OtaUpdateStarted.go @@ -0,0 +1,82 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type OtaUpdateStarted struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateStarted(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateStarted { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateStarted{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateStartedBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateStarted(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateStarted { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateStarted{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateStartedBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateStarted) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateStarted) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateStarted) UpdateId() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *OtaUpdateStarted) MutateUpdateId(n int32) bool { + return rcv._tab.MutateInt32Slot(4, n) +} + +func (rcv *OtaUpdateStarted) Version(obj *OpenShock__Serialization__Types.SemVer) *OpenShock__Serialization__Types.SemVer { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(OpenShock__Serialization__Types.SemVer) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func OtaUpdateStartedStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func OtaUpdateStartedAddUpdateId(builder *flatbuffers.Builder, updateId int32) { + builder.PrependInt32Slot(0, updateId, 0) +} +func OtaUpdateStartedAddVersion(builder *flatbuffers.Builder, version flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(version), 0) +} +func OtaUpdateStartedEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/Ping.go b/Serialization/Gateway/Ping.go new file mode 100644 index 0000000..55ff4c8 --- /dev/null +++ b/Serialization/Gateway/Ping.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Ping struct { + _tab flatbuffers.Table +} + +func GetRootAsPing(buf []byte, offset flatbuffers.UOffsetT) *Ping { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Ping{} + x.Init(buf, n+offset) + return x +} + +func FinishPingBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsPing(buf []byte, offset flatbuffers.UOffsetT) *Ping { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Ping{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedPingBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Ping) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Ping) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Ping) UnixUtcTime() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Ping) MutateUnixUtcTime(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func PingStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func PingAddUnixUtcTime(builder *flatbuffers.Builder, unixUtcTime uint64) { + builder.PrependUint64Slot(0, unixUtcTime, 0) +} +func PingEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/Pong.go b/Serialization/Gateway/Pong.go new file mode 100644 index 0000000..71f18ab --- /dev/null +++ b/Serialization/Gateway/Pong.go @@ -0,0 +1,79 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Pong struct { + _tab flatbuffers.Table +} + +func GetRootAsPong(buf []byte, offset flatbuffers.UOffsetT) *Pong { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Pong{} + x.Init(buf, n+offset) + return x +} + +func FinishPongBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsPong(buf []byte, offset flatbuffers.UOffsetT) *Pong { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Pong{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedPongBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Pong) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Pong) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Pong) Uptime() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Pong) MutateUptime(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +func (rcv *Pong) Rssi() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Pong) MutateRssi(n int32) bool { + return rcv._tab.MutateInt32Slot(6, n) +} + +func PongStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func PongAddUptime(builder *flatbuffers.Builder, uptime uint64) { + builder.PrependUint64Slot(0, uptime, 0) +} +func PongAddRssi(builder *flatbuffers.Builder, rssi int32) { + builder.PrependInt32Slot(1, rssi, 0) +} +func PongEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/ShockerCommand.go b/Serialization/Gateway/ShockerCommand.go new file mode 100644 index 0000000..fa0277c --- /dev/null +++ b/Serialization/Gateway/ShockerCommand.go @@ -0,0 +1,126 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type ShockerCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsShockerCommand(buf []byte, offset flatbuffers.UOffsetT) *ShockerCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ShockerCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishShockerCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsShockerCommand(buf []byte, offset flatbuffers.UOffsetT) *ShockerCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ShockerCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedShockerCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *ShockerCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ShockerCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ShockerCommand) Model() OpenShock__Serialization__Types.ShockerModelType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return OpenShock__Serialization__Types.ShockerModelType(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ShockerCommand) MutateModel(n OpenShock__Serialization__Types.ShockerModelType) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *ShockerCommand) Id() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ShockerCommand) MutateId(n uint16) bool { + return rcv._tab.MutateUint16Slot(6, n) +} + +func (rcv *ShockerCommand) Type() OpenShock__Serialization__Types.ShockerCommandType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return OpenShock__Serialization__Types.ShockerCommandType(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ShockerCommand) MutateType(n OpenShock__Serialization__Types.ShockerCommandType) bool { + return rcv._tab.MutateByteSlot(8, byte(n)) +} + +func (rcv *ShockerCommand) Intensity() byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetByte(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ShockerCommand) MutateIntensity(n byte) bool { + return rcv._tab.MutateByteSlot(10, n) +} + +func (rcv *ShockerCommand) Duration() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *ShockerCommand) MutateDuration(n uint16) bool { + return rcv._tab.MutateUint16Slot(12, n) +} + +func ShockerCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func ShockerCommandAddModel(builder *flatbuffers.Builder, model OpenShock__Serialization__Types.ShockerModelType) { + builder.PrependByteSlot(0, byte(model), 0) +} +func ShockerCommandAddId(builder *flatbuffers.Builder, id uint16) { + builder.PrependUint16Slot(1, id, 0) +} +func ShockerCommandAddType(builder *flatbuffers.Builder, type_ OpenShock__Serialization__Types.ShockerCommandType) { + builder.PrependByteSlot(2, byte(type_), 0) +} +func ShockerCommandAddIntensity(builder *flatbuffers.Builder, intensity byte) { + builder.PrependByteSlot(3, intensity, 0) +} +func ShockerCommandAddDuration(builder *flatbuffers.Builder, duration uint16) { + builder.PrependUint16Slot(4, duration, 0) +} +func ShockerCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/ShockerCommandList.go b/Serialization/Gateway/ShockerCommandList.go new file mode 100644 index 0000000..dcf59c6 --- /dev/null +++ b/Serialization/Gateway/ShockerCommandList.go @@ -0,0 +1,75 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ShockerCommandList struct { + _tab flatbuffers.Table +} + +func GetRootAsShockerCommandList(buf []byte, offset flatbuffers.UOffsetT) *ShockerCommandList { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ShockerCommandList{} + x.Init(buf, n+offset) + return x +} + +func FinishShockerCommandListBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsShockerCommandList(buf []byte, offset flatbuffers.UOffsetT) *ShockerCommandList { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ShockerCommandList{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedShockerCommandListBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *ShockerCommandList) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ShockerCommandList) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ShockerCommandList) Commands(obj *ShockerCommand, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *ShockerCommandList) CommandsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func ShockerCommandListStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ShockerCommandListAddCommands(builder *flatbuffers.Builder, commands flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(commands), 0) +} +func ShockerCommandListStartCommandsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ShockerCommandListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/Trigger.go b/Serialization/Gateway/Trigger.go new file mode 100644 index 0000000..5aae9ed --- /dev/null +++ b/Serialization/Gateway/Trigger.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Trigger struct { + _tab flatbuffers.Table +} + +func GetRootAsTrigger(buf []byte, offset flatbuffers.UOffsetT) *Trigger { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Trigger{} + x.Init(buf, n+offset) + return x +} + +func FinishTriggerBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsTrigger(buf []byte, offset flatbuffers.UOffsetT) *Trigger { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Trigger{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedTriggerBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Trigger) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Trigger) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Trigger) Type() TriggerType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return TriggerType(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Trigger) MutateType(n TriggerType) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func TriggerStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func TriggerAddType(builder *flatbuffers.Builder, type_ TriggerType) { + builder.PrependByteSlot(0, byte(type_), 0) +} +func TriggerEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Gateway/TriggerType.go b/Serialization/Gateway/TriggerType.go new file mode 100644 index 0000000..244c574 --- /dev/null +++ b/Serialization/Gateway/TriggerType.go @@ -0,0 +1,39 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Gateway + +import "strconv" + +type TriggerType byte + +const ( + /// Restart the hub + TriggerTypeRestart TriggerType = 0 + /// Trigger the emergency stop on the hub, this does however not allow for resetting it + TriggerTypeEmergencyStop TriggerType = 1 + /// Enable the captive portal + TriggerTypeCaptivePortalEnable TriggerType = 2 + /// Disable the captive portal + TriggerTypeCaptivePortalDisable TriggerType = 3 +) + +var EnumNamesTriggerType = map[TriggerType]string{ + TriggerTypeRestart: "Restart", + TriggerTypeEmergencyStop: "EmergencyStop", + TriggerTypeCaptivePortalEnable: "CaptivePortalEnable", + TriggerTypeCaptivePortalDisable: "CaptivePortalDisable", +} + +var EnumValuesTriggerType = map[string]TriggerType{ + "Restart": TriggerTypeRestart, + "EmergencyStop": TriggerTypeEmergencyStop, + "CaptivePortalEnable": TriggerTypeCaptivePortalEnable, + "CaptivePortalDisable": TriggerTypeCaptivePortalDisable, +} + +func (v TriggerType) String() string { + if s, ok := EnumNamesTriggerType[v]; ok { + return s + } + return "TriggerType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Local/AccountLinkCommand.go b/Serialization/Local/AccountLinkCommand.go new file mode 100644 index 0000000..93d5f06 --- /dev/null +++ b/Serialization/Local/AccountLinkCommand.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type AccountLinkCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsAccountLinkCommand(buf []byte, offset flatbuffers.UOffsetT) *AccountLinkCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AccountLinkCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishAccountLinkCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsAccountLinkCommand(buf []byte, offset flatbuffers.UOffsetT) *AccountLinkCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AccountLinkCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedAccountLinkCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *AccountLinkCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AccountLinkCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *AccountLinkCommand) Code() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func AccountLinkCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AccountLinkCommandAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(code), 0) +} +func AccountLinkCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/AccountLinkCommandResult.go b/Serialization/Local/AccountLinkCommandResult.go new file mode 100644 index 0000000..1dd5845 --- /dev/null +++ b/Serialization/Local/AccountLinkCommandResult.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type AccountLinkCommandResult struct { + _tab flatbuffers.Table +} + +func GetRootAsAccountLinkCommandResult(buf []byte, offset flatbuffers.UOffsetT) *AccountLinkCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AccountLinkCommandResult{} + x.Init(buf, n+offset) + return x +} + +func FinishAccountLinkCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsAccountLinkCommandResult(buf []byte, offset flatbuffers.UOffsetT) *AccountLinkCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AccountLinkCommandResult{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedAccountLinkCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *AccountLinkCommandResult) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AccountLinkCommandResult) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *AccountLinkCommandResult) Result() AccountLinkResultCode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return AccountLinkResultCode(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *AccountLinkCommandResult) MutateResult(n AccountLinkResultCode) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func AccountLinkCommandResultStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AccountLinkCommandResultAddResult(builder *flatbuffers.Builder, result AccountLinkResultCode) { + builder.PrependByteSlot(0, byte(result), 0) +} +func AccountLinkCommandResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/AccountLinkResultCode.go b/Serialization/Local/AccountLinkResultCode.go new file mode 100644 index 0000000..4426eac --- /dev/null +++ b/Serialization/Local/AccountLinkResultCode.go @@ -0,0 +1,44 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import "strconv" + +type AccountLinkResultCode byte + +const ( + AccountLinkResultCodeSuccess AccountLinkResultCode = 0 + AccountLinkResultCodeCodeRequired AccountLinkResultCode = 1 + AccountLinkResultCodeInvalidCodeLength AccountLinkResultCode = 2 + AccountLinkResultCodeNoInternetConnection AccountLinkResultCode = 3 + AccountLinkResultCodeInvalidCode AccountLinkResultCode = 4 + AccountLinkResultCodeRateLimited AccountLinkResultCode = 5 + AccountLinkResultCodeInternalError AccountLinkResultCode = 6 +) + +var EnumNamesAccountLinkResultCode = map[AccountLinkResultCode]string{ + AccountLinkResultCodeSuccess: "Success", + AccountLinkResultCodeCodeRequired: "CodeRequired", + AccountLinkResultCodeInvalidCodeLength: "InvalidCodeLength", + AccountLinkResultCodeNoInternetConnection: "NoInternetConnection", + AccountLinkResultCodeInvalidCode: "InvalidCode", + AccountLinkResultCodeRateLimited: "RateLimited", + AccountLinkResultCodeInternalError: "InternalError", +} + +var EnumValuesAccountLinkResultCode = map[string]AccountLinkResultCode{ + "Success": AccountLinkResultCodeSuccess, + "CodeRequired": AccountLinkResultCodeCodeRequired, + "InvalidCodeLength": AccountLinkResultCodeInvalidCodeLength, + "NoInternetConnection": AccountLinkResultCodeNoInternetConnection, + "InvalidCode": AccountLinkResultCodeInvalidCode, + "RateLimited": AccountLinkResultCodeRateLimited, + "InternalError": AccountLinkResultCodeInternalError, +} + +func (v AccountLinkResultCode) String() string { + if s, ok := EnumNamesAccountLinkResultCode[v]; ok { + return s + } + return "AccountLinkResultCode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Local/AccountUnlinkCommand.go b/Serialization/Local/AccountUnlinkCommand.go new file mode 100644 index 0000000..9dff515 --- /dev/null +++ b/Serialization/Local/AccountUnlinkCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type AccountUnlinkCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsAccountUnlinkCommand(buf []byte, offset flatbuffers.UOffsetT) *AccountUnlinkCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AccountUnlinkCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishAccountUnlinkCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsAccountUnlinkCommand(buf []byte, offset flatbuffers.UOffsetT) *AccountUnlinkCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AccountUnlinkCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedAccountUnlinkCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *AccountUnlinkCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AccountUnlinkCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *AccountUnlinkCommand) Placeholder() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *AccountUnlinkCommand) MutatePlaceholder(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func AccountUnlinkCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AccountUnlinkCommandAddPlaceholder(builder *flatbuffers.Builder, placeholder bool) { + builder.PrependBoolSlot(0, placeholder, false) +} +func AccountUnlinkCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/ErrorMessage.go b/Serialization/Local/ErrorMessage.go new file mode 100644 index 0000000..5a92652 --- /dev/null +++ b/Serialization/Local/ErrorMessage.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type ErrorMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsErrorMessage(buf []byte, offset flatbuffers.UOffsetT) *ErrorMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ErrorMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishErrorMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsErrorMessage(buf []byte, offset flatbuffers.UOffsetT) *ErrorMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ErrorMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedErrorMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *ErrorMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ErrorMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ErrorMessage) Message() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func ErrorMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ErrorMessageAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(message), 0) +} +func ErrorMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/HubToLocalMessage.go b/Serialization/Local/HubToLocalMessage.go new file mode 100644 index 0000000..847b580 --- /dev/null +++ b/Serialization/Local/HubToLocalMessage.go @@ -0,0 +1,76 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type HubToLocalMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsHubToLocalMessage(buf []byte, offset flatbuffers.UOffsetT) *HubToLocalMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &HubToLocalMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishHubToLocalMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsHubToLocalMessage(buf []byte, offset flatbuffers.UOffsetT) *HubToLocalMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &HubToLocalMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedHubToLocalMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *HubToLocalMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *HubToLocalMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *HubToLocalMessage) PayloadType() HubToLocalMessagePayload { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return HubToLocalMessagePayload(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *HubToLocalMessage) MutatePayloadType(n HubToLocalMessagePayload) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *HubToLocalMessage) Payload(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func HubToLocalMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func HubToLocalMessageAddPayloadType(builder *flatbuffers.Builder, payloadType HubToLocalMessagePayload) { + builder.PrependByteSlot(0, byte(payloadType), 0) +} +func HubToLocalMessageAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(payload), 0) +} +func HubToLocalMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/HubToLocalMessagePayload.go b/Serialization/Local/HubToLocalMessagePayload.go new file mode 100644 index 0000000..20603a1 --- /dev/null +++ b/Serialization/Local/HubToLocalMessagePayload.go @@ -0,0 +1,56 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import "strconv" + +type HubToLocalMessagePayload byte + +const ( + HubToLocalMessagePayloadNONE HubToLocalMessagePayload = 0 + HubToLocalMessagePayloadReadyMessage HubToLocalMessagePayload = 1 + HubToLocalMessagePayloadErrorMessage HubToLocalMessagePayload = 2 + HubToLocalMessagePayloadWifiScanStatusMessage HubToLocalMessagePayload = 3 + HubToLocalMessagePayloadWifiNetworkEvent HubToLocalMessagePayload = 4 + HubToLocalMessagePayloadWifiGotIpEvent HubToLocalMessagePayload = 5 + HubToLocalMessagePayloadWifiLostIpEvent HubToLocalMessagePayload = 6 + HubToLocalMessagePayloadAccountLinkCommandResult HubToLocalMessagePayload = 7 + HubToLocalMessagePayloadSetRfTxPinCommandResult HubToLocalMessagePayload = 8 + HubToLocalMessagePayloadSetEstopEnabledCommandResult HubToLocalMessagePayload = 9 + HubToLocalMessagePayloadSetEstopPinCommandResult HubToLocalMessagePayload = 10 +) + +var EnumNamesHubToLocalMessagePayload = map[HubToLocalMessagePayload]string{ + HubToLocalMessagePayloadNONE: "NONE", + HubToLocalMessagePayloadReadyMessage: "ReadyMessage", + HubToLocalMessagePayloadErrorMessage: "ErrorMessage", + HubToLocalMessagePayloadWifiScanStatusMessage: "WifiScanStatusMessage", + HubToLocalMessagePayloadWifiNetworkEvent: "WifiNetworkEvent", + HubToLocalMessagePayloadWifiGotIpEvent: "WifiGotIpEvent", + HubToLocalMessagePayloadWifiLostIpEvent: "WifiLostIpEvent", + HubToLocalMessagePayloadAccountLinkCommandResult: "AccountLinkCommandResult", + HubToLocalMessagePayloadSetRfTxPinCommandResult: "SetRfTxPinCommandResult", + HubToLocalMessagePayloadSetEstopEnabledCommandResult: "SetEstopEnabledCommandResult", + HubToLocalMessagePayloadSetEstopPinCommandResult: "SetEstopPinCommandResult", +} + +var EnumValuesHubToLocalMessagePayload = map[string]HubToLocalMessagePayload{ + "NONE": HubToLocalMessagePayloadNONE, + "ReadyMessage": HubToLocalMessagePayloadReadyMessage, + "ErrorMessage": HubToLocalMessagePayloadErrorMessage, + "WifiScanStatusMessage": HubToLocalMessagePayloadWifiScanStatusMessage, + "WifiNetworkEvent": HubToLocalMessagePayloadWifiNetworkEvent, + "WifiGotIpEvent": HubToLocalMessagePayloadWifiGotIpEvent, + "WifiLostIpEvent": HubToLocalMessagePayloadWifiLostIpEvent, + "AccountLinkCommandResult": HubToLocalMessagePayloadAccountLinkCommandResult, + "SetRfTxPinCommandResult": HubToLocalMessagePayloadSetRfTxPinCommandResult, + "SetEstopEnabledCommandResult": HubToLocalMessagePayloadSetEstopEnabledCommandResult, + "SetEstopPinCommandResult": HubToLocalMessagePayloadSetEstopPinCommandResult, +} + +func (v HubToLocalMessagePayload) String() string { + if s, ok := EnumNamesHubToLocalMessagePayload[v]; ok { + return s + } + return "HubToLocalMessagePayload(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Local/LocalToHubMessage.go b/Serialization/Local/LocalToHubMessage.go new file mode 100644 index 0000000..ba68d99 --- /dev/null +++ b/Serialization/Local/LocalToHubMessage.go @@ -0,0 +1,76 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LocalToHubMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsLocalToHubMessage(buf []byte, offset flatbuffers.UOffsetT) *LocalToHubMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LocalToHubMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishLocalToHubMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsLocalToHubMessage(buf []byte, offset flatbuffers.UOffsetT) *LocalToHubMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LocalToHubMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedLocalToHubMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *LocalToHubMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LocalToHubMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *LocalToHubMessage) PayloadType() LocalToHubMessagePayload { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return LocalToHubMessagePayload(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *LocalToHubMessage) MutatePayloadType(n LocalToHubMessagePayload) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *LocalToHubMessage) Payload(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func LocalToHubMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func LocalToHubMessageAddPayloadType(builder *flatbuffers.Builder, payloadType LocalToHubMessagePayload) { + builder.PrependByteSlot(0, byte(payloadType), 0) +} +func LocalToHubMessageAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(payload), 0) +} +func LocalToHubMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/LocalToHubMessagePayload.go b/Serialization/Local/LocalToHubMessagePayload.go new file mode 100644 index 0000000..f82ff51 --- /dev/null +++ b/Serialization/Local/LocalToHubMessagePayload.go @@ -0,0 +1,83 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import "strconv" + +type LocalToHubMessagePayload byte + +const ( + LocalToHubMessagePayloadNONE LocalToHubMessagePayload = 0 + LocalToHubMessagePayloadWifiScanCommand LocalToHubMessagePayload = 1 + LocalToHubMessagePayloadWifiNetworkSaveCommand LocalToHubMessagePayload = 2 + LocalToHubMessagePayloadWifiNetworkForgetCommand LocalToHubMessagePayload = 3 + LocalToHubMessagePayloadWifiNetworkConnectCommand LocalToHubMessagePayload = 4 + LocalToHubMessagePayloadWifiNetworkDisconnectCommand LocalToHubMessagePayload = 5 + LocalToHubMessagePayloadOtaUpdateSetIsEnabledCommand LocalToHubMessagePayload = 6 + LocalToHubMessagePayloadOtaUpdateSetDomainCommand LocalToHubMessagePayload = 7 + LocalToHubMessagePayloadOtaUpdateSetUpdateChannelCommand LocalToHubMessagePayload = 8 + LocalToHubMessagePayloadOtaUpdateSetCheckIntervalCommand LocalToHubMessagePayload = 9 + LocalToHubMessagePayloadOtaUpdateSetAllowBackendManagementCommand LocalToHubMessagePayload = 10 + LocalToHubMessagePayloadOtaUpdateSetRequireManualApprovalCommand LocalToHubMessagePayload = 11 + LocalToHubMessagePayloadOtaUpdateHandleUpdateRequestCommand LocalToHubMessagePayload = 12 + LocalToHubMessagePayloadOtaUpdateCheckForUpdatesCommand LocalToHubMessagePayload = 13 + LocalToHubMessagePayloadOtaUpdateStartUpdateCommand LocalToHubMessagePayload = 14 + LocalToHubMessagePayloadAccountLinkCommand LocalToHubMessagePayload = 15 + LocalToHubMessagePayloadAccountUnlinkCommand LocalToHubMessagePayload = 16 + LocalToHubMessagePayloadSetRfTxPinCommand LocalToHubMessagePayload = 17 + LocalToHubMessagePayloadSetEstopEnabledCommand LocalToHubMessagePayload = 18 + LocalToHubMessagePayloadSetEstopPinCommand LocalToHubMessagePayload = 19 +) + +var EnumNamesLocalToHubMessagePayload = map[LocalToHubMessagePayload]string{ + LocalToHubMessagePayloadNONE: "NONE", + LocalToHubMessagePayloadWifiScanCommand: "WifiScanCommand", + LocalToHubMessagePayloadWifiNetworkSaveCommand: "WifiNetworkSaveCommand", + LocalToHubMessagePayloadWifiNetworkForgetCommand: "WifiNetworkForgetCommand", + LocalToHubMessagePayloadWifiNetworkConnectCommand: "WifiNetworkConnectCommand", + LocalToHubMessagePayloadWifiNetworkDisconnectCommand: "WifiNetworkDisconnectCommand", + LocalToHubMessagePayloadOtaUpdateSetIsEnabledCommand: "OtaUpdateSetIsEnabledCommand", + LocalToHubMessagePayloadOtaUpdateSetDomainCommand: "OtaUpdateSetDomainCommand", + LocalToHubMessagePayloadOtaUpdateSetUpdateChannelCommand: "OtaUpdateSetUpdateChannelCommand", + LocalToHubMessagePayloadOtaUpdateSetCheckIntervalCommand: "OtaUpdateSetCheckIntervalCommand", + LocalToHubMessagePayloadOtaUpdateSetAllowBackendManagementCommand: "OtaUpdateSetAllowBackendManagementCommand", + LocalToHubMessagePayloadOtaUpdateSetRequireManualApprovalCommand: "OtaUpdateSetRequireManualApprovalCommand", + LocalToHubMessagePayloadOtaUpdateHandleUpdateRequestCommand: "OtaUpdateHandleUpdateRequestCommand", + LocalToHubMessagePayloadOtaUpdateCheckForUpdatesCommand: "OtaUpdateCheckForUpdatesCommand", + LocalToHubMessagePayloadOtaUpdateStartUpdateCommand: "OtaUpdateStartUpdateCommand", + LocalToHubMessagePayloadAccountLinkCommand: "AccountLinkCommand", + LocalToHubMessagePayloadAccountUnlinkCommand: "AccountUnlinkCommand", + LocalToHubMessagePayloadSetRfTxPinCommand: "SetRfTxPinCommand", + LocalToHubMessagePayloadSetEstopEnabledCommand: "SetEstopEnabledCommand", + LocalToHubMessagePayloadSetEstopPinCommand: "SetEstopPinCommand", +} + +var EnumValuesLocalToHubMessagePayload = map[string]LocalToHubMessagePayload{ + "NONE": LocalToHubMessagePayloadNONE, + "WifiScanCommand": LocalToHubMessagePayloadWifiScanCommand, + "WifiNetworkSaveCommand": LocalToHubMessagePayloadWifiNetworkSaveCommand, + "WifiNetworkForgetCommand": LocalToHubMessagePayloadWifiNetworkForgetCommand, + "WifiNetworkConnectCommand": LocalToHubMessagePayloadWifiNetworkConnectCommand, + "WifiNetworkDisconnectCommand": LocalToHubMessagePayloadWifiNetworkDisconnectCommand, + "OtaUpdateSetIsEnabledCommand": LocalToHubMessagePayloadOtaUpdateSetIsEnabledCommand, + "OtaUpdateSetDomainCommand": LocalToHubMessagePayloadOtaUpdateSetDomainCommand, + "OtaUpdateSetUpdateChannelCommand": LocalToHubMessagePayloadOtaUpdateSetUpdateChannelCommand, + "OtaUpdateSetCheckIntervalCommand": LocalToHubMessagePayloadOtaUpdateSetCheckIntervalCommand, + "OtaUpdateSetAllowBackendManagementCommand": LocalToHubMessagePayloadOtaUpdateSetAllowBackendManagementCommand, + "OtaUpdateSetRequireManualApprovalCommand": LocalToHubMessagePayloadOtaUpdateSetRequireManualApprovalCommand, + "OtaUpdateHandleUpdateRequestCommand": LocalToHubMessagePayloadOtaUpdateHandleUpdateRequestCommand, + "OtaUpdateCheckForUpdatesCommand": LocalToHubMessagePayloadOtaUpdateCheckForUpdatesCommand, + "OtaUpdateStartUpdateCommand": LocalToHubMessagePayloadOtaUpdateStartUpdateCommand, + "AccountLinkCommand": LocalToHubMessagePayloadAccountLinkCommand, + "AccountUnlinkCommand": LocalToHubMessagePayloadAccountUnlinkCommand, + "SetRfTxPinCommand": LocalToHubMessagePayloadSetRfTxPinCommand, + "SetEstopEnabledCommand": LocalToHubMessagePayloadSetEstopEnabledCommand, + "SetEstopPinCommand": LocalToHubMessagePayloadSetEstopPinCommand, +} + +func (v LocalToHubMessagePayload) String() string { + if s, ok := EnumNamesLocalToHubMessagePayload[v]; ok { + return s + } + return "LocalToHubMessagePayload(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Local/OtaUpdateCheckForUpdatesCommand.go b/Serialization/Local/OtaUpdateCheckForUpdatesCommand.go new file mode 100644 index 0000000..3c76255 --- /dev/null +++ b/Serialization/Local/OtaUpdateCheckForUpdatesCommand.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateCheckForUpdatesCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateCheckForUpdatesCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateCheckForUpdatesCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateCheckForUpdatesCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateCheckForUpdatesCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateCheckForUpdatesCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateCheckForUpdatesCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateCheckForUpdatesCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateCheckForUpdatesCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateCheckForUpdatesCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateCheckForUpdatesCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateCheckForUpdatesCommand) Channel() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func OtaUpdateCheckForUpdatesCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateCheckForUpdatesCommandAddChannel(builder *flatbuffers.Builder, channel flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(channel), 0) +} +func OtaUpdateCheckForUpdatesCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateHandleUpdateRequestCommand.go b/Serialization/Local/OtaUpdateHandleUpdateRequestCommand.go new file mode 100644 index 0000000..79d1724 --- /dev/null +++ b/Serialization/Local/OtaUpdateHandleUpdateRequestCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateHandleUpdateRequestCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateHandleUpdateRequestCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateHandleUpdateRequestCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateHandleUpdateRequestCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateHandleUpdateRequestCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateHandleUpdateRequestCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateHandleUpdateRequestCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateHandleUpdateRequestCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateHandleUpdateRequestCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateHandleUpdateRequestCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateHandleUpdateRequestCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateHandleUpdateRequestCommand) Accept() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *OtaUpdateHandleUpdateRequestCommand) MutateAccept(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func OtaUpdateHandleUpdateRequestCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateHandleUpdateRequestCommandAddAccept(builder *flatbuffers.Builder, accept bool) { + builder.PrependBoolSlot(0, accept, false) +} +func OtaUpdateHandleUpdateRequestCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateSetAllowBackendManagementCommand.go b/Serialization/Local/OtaUpdateSetAllowBackendManagementCommand.go new file mode 100644 index 0000000..31d3e2a --- /dev/null +++ b/Serialization/Local/OtaUpdateSetAllowBackendManagementCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateSetAllowBackendManagementCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateSetAllowBackendManagementCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetAllowBackendManagementCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateSetAllowBackendManagementCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateSetAllowBackendManagementCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateSetAllowBackendManagementCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetAllowBackendManagementCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateSetAllowBackendManagementCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateSetAllowBackendManagementCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateSetAllowBackendManagementCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateSetAllowBackendManagementCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateSetAllowBackendManagementCommand) Allow() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *OtaUpdateSetAllowBackendManagementCommand) MutateAllow(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func OtaUpdateSetAllowBackendManagementCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateSetAllowBackendManagementCommandAddAllow(builder *flatbuffers.Builder, allow bool) { + builder.PrependBoolSlot(0, allow, false) +} +func OtaUpdateSetAllowBackendManagementCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateSetCheckIntervalCommand.go b/Serialization/Local/OtaUpdateSetCheckIntervalCommand.go new file mode 100644 index 0000000..372860c --- /dev/null +++ b/Serialization/Local/OtaUpdateSetCheckIntervalCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateSetCheckIntervalCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateSetCheckIntervalCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetCheckIntervalCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateSetCheckIntervalCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateSetCheckIntervalCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateSetCheckIntervalCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetCheckIntervalCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateSetCheckIntervalCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateSetCheckIntervalCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateSetCheckIntervalCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateSetCheckIntervalCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateSetCheckIntervalCommand) Interval() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *OtaUpdateSetCheckIntervalCommand) MutateInterval(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func OtaUpdateSetCheckIntervalCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateSetCheckIntervalCommandAddInterval(builder *flatbuffers.Builder, interval uint16) { + builder.PrependUint16Slot(0, interval, 0) +} +func OtaUpdateSetCheckIntervalCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateSetDomainCommand.go b/Serialization/Local/OtaUpdateSetDomainCommand.go new file mode 100644 index 0000000..dde6f5f --- /dev/null +++ b/Serialization/Local/OtaUpdateSetDomainCommand.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateSetDomainCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateSetDomainCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetDomainCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateSetDomainCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateSetDomainCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateSetDomainCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetDomainCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateSetDomainCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateSetDomainCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateSetDomainCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateSetDomainCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateSetDomainCommand) Domain() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func OtaUpdateSetDomainCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateSetDomainCommandAddDomain(builder *flatbuffers.Builder, domain flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(domain), 0) +} +func OtaUpdateSetDomainCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateSetIsEnabledCommand.go b/Serialization/Local/OtaUpdateSetIsEnabledCommand.go new file mode 100644 index 0000000..38eba30 --- /dev/null +++ b/Serialization/Local/OtaUpdateSetIsEnabledCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateSetIsEnabledCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateSetIsEnabledCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetIsEnabledCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateSetIsEnabledCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateSetIsEnabledCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateSetIsEnabledCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetIsEnabledCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateSetIsEnabledCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateSetIsEnabledCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateSetIsEnabledCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateSetIsEnabledCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateSetIsEnabledCommand) Enabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *OtaUpdateSetIsEnabledCommand) MutateEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func OtaUpdateSetIsEnabledCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateSetIsEnabledCommandAddEnabled(builder *flatbuffers.Builder, enabled bool) { + builder.PrependBoolSlot(0, enabled, false) +} +func OtaUpdateSetIsEnabledCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateSetRequireManualApprovalCommand.go b/Serialization/Local/OtaUpdateSetRequireManualApprovalCommand.go new file mode 100644 index 0000000..fa174a8 --- /dev/null +++ b/Serialization/Local/OtaUpdateSetRequireManualApprovalCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateSetRequireManualApprovalCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateSetRequireManualApprovalCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetRequireManualApprovalCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateSetRequireManualApprovalCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateSetRequireManualApprovalCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateSetRequireManualApprovalCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetRequireManualApprovalCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateSetRequireManualApprovalCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateSetRequireManualApprovalCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateSetRequireManualApprovalCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateSetRequireManualApprovalCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateSetRequireManualApprovalCommand) Require() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *OtaUpdateSetRequireManualApprovalCommand) MutateRequire(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func OtaUpdateSetRequireManualApprovalCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateSetRequireManualApprovalCommandAddRequire(builder *flatbuffers.Builder, require bool) { + builder.PrependBoolSlot(0, require, false) +} +func OtaUpdateSetRequireManualApprovalCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateSetUpdateChannelCommand.go b/Serialization/Local/OtaUpdateSetUpdateChannelCommand.go new file mode 100644 index 0000000..4d7c1ce --- /dev/null +++ b/Serialization/Local/OtaUpdateSetUpdateChannelCommand.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateSetUpdateChannelCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateSetUpdateChannelCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetUpdateChannelCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateSetUpdateChannelCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateSetUpdateChannelCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateSetUpdateChannelCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateSetUpdateChannelCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateSetUpdateChannelCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateSetUpdateChannelCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateSetUpdateChannelCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateSetUpdateChannelCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateSetUpdateChannelCommand) Channel() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func OtaUpdateSetUpdateChannelCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func OtaUpdateSetUpdateChannelCommandAddChannel(builder *flatbuffers.Builder, channel flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(channel), 0) +} +func OtaUpdateSetUpdateChannelCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/OtaUpdateStartUpdateCommand.go b/Serialization/Local/OtaUpdateStartUpdateCommand.go new file mode 100644 index 0000000..6c667b8 --- /dev/null +++ b/Serialization/Local/OtaUpdateStartUpdateCommand.go @@ -0,0 +1,71 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type OtaUpdateStartUpdateCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsOtaUpdateStartUpdateCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateStartUpdateCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &OtaUpdateStartUpdateCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishOtaUpdateStartUpdateCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsOtaUpdateStartUpdateCommand(buf []byte, offset flatbuffers.UOffsetT) *OtaUpdateStartUpdateCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &OtaUpdateStartUpdateCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedOtaUpdateStartUpdateCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *OtaUpdateStartUpdateCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *OtaUpdateStartUpdateCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *OtaUpdateStartUpdateCommand) Channel() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *OtaUpdateStartUpdateCommand) Version() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func OtaUpdateStartUpdateCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func OtaUpdateStartUpdateCommandAddChannel(builder *flatbuffers.Builder, channel flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(channel), 0) +} +func OtaUpdateStartUpdateCommandAddVersion(builder *flatbuffers.Builder, version flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(version), 0) +} +func OtaUpdateStartUpdateCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/ReadyMessage.go b/Serialization/Local/ReadyMessage.go new file mode 100644 index 0000000..a9910cd --- /dev/null +++ b/Serialization/Local/ReadyMessage.go @@ -0,0 +1,178 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Configuration "OpenShock/Serialization/Configuration" + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type ReadyMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsReadyMessage(buf []byte, offset flatbuffers.UOffsetT) *ReadyMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ReadyMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishReadyMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsReadyMessage(buf []byte, offset flatbuffers.UOffsetT) *ReadyMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ReadyMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedReadyMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *ReadyMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ReadyMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ReadyMessage) Poggies() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *ReadyMessage) MutatePoggies(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func (rcv *ReadyMessage) ConnectedWifi(obj *OpenShock__Serialization__Types.WifiNetwork) *OpenShock__Serialization__Types.WifiNetwork { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(OpenShock__Serialization__Types.WifiNetwork) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *ReadyMessage) AccountLinked() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *ReadyMessage) MutateAccountLinked(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func (rcv *ReadyMessage) Config(obj *OpenShock__Serialization__Configuration.HubConfig) *OpenShock__Serialization__Configuration.HubConfig { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(OpenShock__Serialization__Configuration.HubConfig) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *ReadyMessage) GpioValidInputs(j int) int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *ReadyMessage) GpioValidInputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *ReadyMessage) MutateGpioValidInputs(j int, n int8) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func (rcv *ReadyMessage) GpioValidOutputs(j int) int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *ReadyMessage) GpioValidOutputsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *ReadyMessage) MutateGpioValidOutputs(j int, n int8) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateInt8(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +func ReadyMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func ReadyMessageAddPoggies(builder *flatbuffers.Builder, poggies bool) { + builder.PrependBoolSlot(0, poggies, false) +} +func ReadyMessageAddConnectedWifi(builder *flatbuffers.Builder, connectedWifi flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(connectedWifi), 0) +} +func ReadyMessageAddAccountLinked(builder *flatbuffers.Builder, accountLinked bool) { + builder.PrependBoolSlot(2, accountLinked, false) +} +func ReadyMessageAddConfig(builder *flatbuffers.Builder, config flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(config), 0) +} +func ReadyMessageAddGpioValidInputs(builder *flatbuffers.Builder, gpioValidInputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(gpioValidInputs), 0) +} +func ReadyMessageStartGpioValidInputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func ReadyMessageAddGpioValidOutputs(builder *flatbuffers.Builder, gpioValidOutputs flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(gpioValidOutputs), 0) +} +func ReadyMessageStartGpioValidOutputsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func ReadyMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/SetEstopEnabledCommand.go b/Serialization/Local/SetEstopEnabledCommand.go new file mode 100644 index 0000000..e58c3c3 --- /dev/null +++ b/Serialization/Local/SetEstopEnabledCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SetEstopEnabledCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsSetEstopEnabledCommand(buf []byte, offset flatbuffers.UOffsetT) *SetEstopEnabledCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SetEstopEnabledCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishSetEstopEnabledCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSetEstopEnabledCommand(buf []byte, offset flatbuffers.UOffsetT) *SetEstopEnabledCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SetEstopEnabledCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSetEstopEnabledCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SetEstopEnabledCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SetEstopEnabledCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SetEstopEnabledCommand) Enabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *SetEstopEnabledCommand) MutateEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func SetEstopEnabledCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func SetEstopEnabledCommandAddEnabled(builder *flatbuffers.Builder, enabled bool) { + builder.PrependBoolSlot(0, enabled, false) +} +func SetEstopEnabledCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/SetEstopEnabledCommandResult.go b/Serialization/Local/SetEstopEnabledCommandResult.go new file mode 100644 index 0000000..b8a2218 --- /dev/null +++ b/Serialization/Local/SetEstopEnabledCommandResult.go @@ -0,0 +1,79 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SetEstopEnabledCommandResult struct { + _tab flatbuffers.Table +} + +func GetRootAsSetEstopEnabledCommandResult(buf []byte, offset flatbuffers.UOffsetT) *SetEstopEnabledCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SetEstopEnabledCommandResult{} + x.Init(buf, n+offset) + return x +} + +func FinishSetEstopEnabledCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSetEstopEnabledCommandResult(buf []byte, offset flatbuffers.UOffsetT) *SetEstopEnabledCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SetEstopEnabledCommandResult{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSetEstopEnabledCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SetEstopEnabledCommandResult) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SetEstopEnabledCommandResult) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SetEstopEnabledCommandResult) Enabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *SetEstopEnabledCommandResult) MutateEnabled(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func (rcv *SetEstopEnabledCommandResult) Success() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *SetEstopEnabledCommandResult) MutateSuccess(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func SetEstopEnabledCommandResultStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func SetEstopEnabledCommandResultAddEnabled(builder *flatbuffers.Builder, enabled bool) { + builder.PrependBoolSlot(0, enabled, false) +} +func SetEstopEnabledCommandResultAddSuccess(builder *flatbuffers.Builder, success bool) { + builder.PrependBoolSlot(1, success, false) +} +func SetEstopEnabledCommandResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/SetEstopPinCommand.go b/Serialization/Local/SetEstopPinCommand.go new file mode 100644 index 0000000..fa4d56d --- /dev/null +++ b/Serialization/Local/SetEstopPinCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SetEstopPinCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsSetEstopPinCommand(buf []byte, offset flatbuffers.UOffsetT) *SetEstopPinCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SetEstopPinCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishSetEstopPinCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSetEstopPinCommand(buf []byte, offset flatbuffers.UOffsetT) *SetEstopPinCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SetEstopPinCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSetEstopPinCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SetEstopPinCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SetEstopPinCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SetEstopPinCommand) Pin() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SetEstopPinCommand) MutatePin(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +func SetEstopPinCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func SetEstopPinCommandAddPin(builder *flatbuffers.Builder, pin int8) { + builder.PrependInt8Slot(0, pin, 0) +} +func SetEstopPinCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/SetEstopPinCommandResult.go b/Serialization/Local/SetEstopPinCommandResult.go new file mode 100644 index 0000000..1094977 --- /dev/null +++ b/Serialization/Local/SetEstopPinCommandResult.go @@ -0,0 +1,79 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SetEstopPinCommandResult struct { + _tab flatbuffers.Table +} + +func GetRootAsSetEstopPinCommandResult(buf []byte, offset flatbuffers.UOffsetT) *SetEstopPinCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SetEstopPinCommandResult{} + x.Init(buf, n+offset) + return x +} + +func FinishSetEstopPinCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSetEstopPinCommandResult(buf []byte, offset flatbuffers.UOffsetT) *SetEstopPinCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SetEstopPinCommandResult{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSetEstopPinCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SetEstopPinCommandResult) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SetEstopPinCommandResult) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SetEstopPinCommandResult) GpioPin() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SetEstopPinCommandResult) MutateGpioPin(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +func (rcv *SetEstopPinCommandResult) Result() SetGPIOResultCode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return SetGPIOResultCode(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *SetEstopPinCommandResult) MutateResult(n SetGPIOResultCode) bool { + return rcv._tab.MutateByteSlot(6, byte(n)) +} + +func SetEstopPinCommandResultStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func SetEstopPinCommandResultAddGpioPin(builder *flatbuffers.Builder, gpioPin int8) { + builder.PrependInt8Slot(0, gpioPin, 0) +} +func SetEstopPinCommandResultAddResult(builder *flatbuffers.Builder, result SetGPIOResultCode) { + builder.PrependByteSlot(1, byte(result), 0) +} +func SetEstopPinCommandResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/SetGPIOResultCode.go b/Serialization/Local/SetGPIOResultCode.go new file mode 100644 index 0000000..d861a39 --- /dev/null +++ b/Serialization/Local/SetGPIOResultCode.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import "strconv" + +type SetGPIOResultCode byte + +const ( + SetGPIOResultCodeSuccess SetGPIOResultCode = 0 + SetGPIOResultCodeInvalidPin SetGPIOResultCode = 1 + SetGPIOResultCodeInternalError SetGPIOResultCode = 2 +) + +var EnumNamesSetGPIOResultCode = map[SetGPIOResultCode]string{ + SetGPIOResultCodeSuccess: "Success", + SetGPIOResultCodeInvalidPin: "InvalidPin", + SetGPIOResultCodeInternalError: "InternalError", +} + +var EnumValuesSetGPIOResultCode = map[string]SetGPIOResultCode{ + "Success": SetGPIOResultCodeSuccess, + "InvalidPin": SetGPIOResultCodeInvalidPin, + "InternalError": SetGPIOResultCodeInternalError, +} + +func (v SetGPIOResultCode) String() string { + if s, ok := EnumNamesSetGPIOResultCode[v]; ok { + return s + } + return "SetGPIOResultCode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Local/SetRfTxPinCommand.go b/Serialization/Local/SetRfTxPinCommand.go new file mode 100644 index 0000000..220a686 --- /dev/null +++ b/Serialization/Local/SetRfTxPinCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SetRfTxPinCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsSetRfTxPinCommand(buf []byte, offset flatbuffers.UOffsetT) *SetRfTxPinCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SetRfTxPinCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishSetRfTxPinCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSetRfTxPinCommand(buf []byte, offset flatbuffers.UOffsetT) *SetRfTxPinCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SetRfTxPinCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSetRfTxPinCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SetRfTxPinCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SetRfTxPinCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SetRfTxPinCommand) Pin() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SetRfTxPinCommand) MutatePin(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +func SetRfTxPinCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func SetRfTxPinCommandAddPin(builder *flatbuffers.Builder, pin int8) { + builder.PrependInt8Slot(0, pin, 0) +} +func SetRfTxPinCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/SetRfTxPinCommandResult.go b/Serialization/Local/SetRfTxPinCommandResult.go new file mode 100644 index 0000000..c8c275d --- /dev/null +++ b/Serialization/Local/SetRfTxPinCommandResult.go @@ -0,0 +1,79 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SetRfTxPinCommandResult struct { + _tab flatbuffers.Table +} + +func GetRootAsSetRfTxPinCommandResult(buf []byte, offset flatbuffers.UOffsetT) *SetRfTxPinCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SetRfTxPinCommandResult{} + x.Init(buf, n+offset) + return x +} + +func FinishSetRfTxPinCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSetRfTxPinCommandResult(buf []byte, offset flatbuffers.UOffsetT) *SetRfTxPinCommandResult { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SetRfTxPinCommandResult{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSetRfTxPinCommandResultBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SetRfTxPinCommandResult) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SetRfTxPinCommandResult) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SetRfTxPinCommandResult) Pin() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SetRfTxPinCommandResult) MutatePin(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +func (rcv *SetRfTxPinCommandResult) Result() SetGPIOResultCode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return SetGPIOResultCode(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *SetRfTxPinCommandResult) MutateResult(n SetGPIOResultCode) bool { + return rcv._tab.MutateByteSlot(6, byte(n)) +} + +func SetRfTxPinCommandResultStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func SetRfTxPinCommandResultAddPin(builder *flatbuffers.Builder, pin int8) { + builder.PrependInt8Slot(0, pin, 0) +} +func SetRfTxPinCommandResultAddResult(builder *flatbuffers.Builder, result SetGPIOResultCode) { + builder.PrependByteSlot(1, byte(result), 0) +} +func SetRfTxPinCommandResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiGotIpEvent.go b/Serialization/Local/WifiGotIpEvent.go new file mode 100644 index 0000000..cc6590b --- /dev/null +++ b/Serialization/Local/WifiGotIpEvent.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiGotIpEvent struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiGotIpEvent(buf []byte, offset flatbuffers.UOffsetT) *WifiGotIpEvent { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiGotIpEvent{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiGotIpEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiGotIpEvent(buf []byte, offset flatbuffers.UOffsetT) *WifiGotIpEvent { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiGotIpEvent{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiGotIpEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiGotIpEvent) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiGotIpEvent) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiGotIpEvent) Ip() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func WifiGotIpEventStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiGotIpEventAddIp(builder *flatbuffers.Builder, ip flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ip), 0) +} +func WifiGotIpEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiLostIpEvent.go b/Serialization/Local/WifiLostIpEvent.go new file mode 100644 index 0000000..e6e9f77 --- /dev/null +++ b/Serialization/Local/WifiLostIpEvent.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiLostIpEvent struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiLostIpEvent(buf []byte, offset flatbuffers.UOffsetT) *WifiLostIpEvent { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiLostIpEvent{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiLostIpEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiLostIpEvent(buf []byte, offset flatbuffers.UOffsetT) *WifiLostIpEvent { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiLostIpEvent{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiLostIpEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiLostIpEvent) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiLostIpEvent) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiLostIpEvent) Ip() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func WifiLostIpEventStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiLostIpEventAddIp(builder *flatbuffers.Builder, ip flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ip), 0) +} +func WifiLostIpEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiNetworkConnectCommand.go b/Serialization/Local/WifiNetworkConnectCommand.go new file mode 100644 index 0000000..833ccf5 --- /dev/null +++ b/Serialization/Local/WifiNetworkConnectCommand.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiNetworkConnectCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiNetworkConnectCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkConnectCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiNetworkConnectCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiNetworkConnectCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiNetworkConnectCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkConnectCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiNetworkConnectCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiNetworkConnectCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiNetworkConnectCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiNetworkConnectCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiNetworkConnectCommand) Ssid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func WifiNetworkConnectCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiNetworkConnectCommandAddSsid(builder *flatbuffers.Builder, ssid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ssid), 0) +} +func WifiNetworkConnectCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiNetworkDisconnectCommand.go b/Serialization/Local/WifiNetworkDisconnectCommand.go new file mode 100644 index 0000000..a7f2961 --- /dev/null +++ b/Serialization/Local/WifiNetworkDisconnectCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiNetworkDisconnectCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiNetworkDisconnectCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkDisconnectCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiNetworkDisconnectCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiNetworkDisconnectCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiNetworkDisconnectCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkDisconnectCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiNetworkDisconnectCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiNetworkDisconnectCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiNetworkDisconnectCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiNetworkDisconnectCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiNetworkDisconnectCommand) Placeholder() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *WifiNetworkDisconnectCommand) MutatePlaceholder(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func WifiNetworkDisconnectCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiNetworkDisconnectCommandAddPlaceholder(builder *flatbuffers.Builder, placeholder bool) { + builder.PrependBoolSlot(0, placeholder, false) +} +func WifiNetworkDisconnectCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiNetworkEvent.go b/Serialization/Local/WifiNetworkEvent.go new file mode 100644 index 0000000..680a87d --- /dev/null +++ b/Serialization/Local/WifiNetworkEvent.go @@ -0,0 +1,92 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type WifiNetworkEvent struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiNetworkEvent(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkEvent { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiNetworkEvent{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiNetworkEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiNetworkEvent(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkEvent { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiNetworkEvent{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiNetworkEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiNetworkEvent) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiNetworkEvent) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiNetworkEvent) EventType() OpenShock__Serialization__Types.WifiNetworkEventType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return OpenShock__Serialization__Types.WifiNetworkEventType(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *WifiNetworkEvent) MutateEventType(n OpenShock__Serialization__Types.WifiNetworkEventType) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *WifiNetworkEvent) Networks(obj *OpenShock__Serialization__Types.WifiNetwork, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *WifiNetworkEvent) NetworksLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func WifiNetworkEventStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func WifiNetworkEventAddEventType(builder *flatbuffers.Builder, eventType OpenShock__Serialization__Types.WifiNetworkEventType) { + builder.PrependByteSlot(0, byte(eventType), 0) +} +func WifiNetworkEventAddNetworks(builder *flatbuffers.Builder, networks flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(networks), 0) +} +func WifiNetworkEventStartNetworksVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func WifiNetworkEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiNetworkForgetCommand.go b/Serialization/Local/WifiNetworkForgetCommand.go new file mode 100644 index 0000000..09f73e7 --- /dev/null +++ b/Serialization/Local/WifiNetworkForgetCommand.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiNetworkForgetCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiNetworkForgetCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkForgetCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiNetworkForgetCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiNetworkForgetCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiNetworkForgetCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkForgetCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiNetworkForgetCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiNetworkForgetCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiNetworkForgetCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiNetworkForgetCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiNetworkForgetCommand) Ssid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func WifiNetworkForgetCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiNetworkForgetCommandAddSsid(builder *flatbuffers.Builder, ssid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ssid), 0) +} +func WifiNetworkForgetCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiNetworkSaveCommand.go b/Serialization/Local/WifiNetworkSaveCommand.go new file mode 100644 index 0000000..a069deb --- /dev/null +++ b/Serialization/Local/WifiNetworkSaveCommand.go @@ -0,0 +1,86 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiNetworkSaveCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiNetworkSaveCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkSaveCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiNetworkSaveCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiNetworkSaveCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiNetworkSaveCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiNetworkSaveCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiNetworkSaveCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiNetworkSaveCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiNetworkSaveCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiNetworkSaveCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiNetworkSaveCommand) Ssid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *WifiNetworkSaveCommand) Password() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *WifiNetworkSaveCommand) Connect() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *WifiNetworkSaveCommand) MutateConnect(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func WifiNetworkSaveCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func WifiNetworkSaveCommandAddSsid(builder *flatbuffers.Builder, ssid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ssid), 0) +} +func WifiNetworkSaveCommandAddPassword(builder *flatbuffers.Builder, password flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(password), 0) +} +func WifiNetworkSaveCommandAddConnect(builder *flatbuffers.Builder, connect bool) { + builder.PrependBoolSlot(2, connect, false) +} +func WifiNetworkSaveCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiScanCommand.go b/Serialization/Local/WifiScanCommand.go new file mode 100644 index 0000000..50e65bb --- /dev/null +++ b/Serialization/Local/WifiScanCommand.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiScanCommand struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiScanCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiScanCommand { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiScanCommand{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiScanCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiScanCommand(buf []byte, offset flatbuffers.UOffsetT) *WifiScanCommand { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiScanCommand{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiScanCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiScanCommand) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiScanCommand) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiScanCommand) Run() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *WifiScanCommand) MutateRun(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func WifiScanCommandStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiScanCommandAddRun(builder *flatbuffers.Builder, run bool) { + builder.PrependBoolSlot(0, run, false) +} +func WifiScanCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Local/WifiScanStatusMessage.go b/Serialization/Local/WifiScanStatusMessage.go new file mode 100644 index 0000000..f55e000 --- /dev/null +++ b/Serialization/Local/WifiScanStatusMessage.go @@ -0,0 +1,66 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Local + +import ( + flatbuffers "github.com/google/flatbuffers/go" + + OpenShock__Serialization__Types "OpenShock/Serialization/Types" +) + +type WifiScanStatusMessage struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiScanStatusMessage(buf []byte, offset flatbuffers.UOffsetT) *WifiScanStatusMessage { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiScanStatusMessage{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiScanStatusMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiScanStatusMessage(buf []byte, offset flatbuffers.UOffsetT) *WifiScanStatusMessage { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiScanStatusMessage{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiScanStatusMessageBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiScanStatusMessage) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiScanStatusMessage) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiScanStatusMessage) Status() OpenShock__Serialization__Types.WifiScanStatus { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return OpenShock__Serialization__Types.WifiScanStatus(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *WifiScanStatusMessage) MutateStatus(n OpenShock__Serialization__Types.WifiScanStatus) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func WifiScanStatusMessageStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func WifiScanStatusMessageAddStatus(builder *flatbuffers.Builder, status OpenShock__Serialization__Types.WifiScanStatus) { + builder.PrependByteSlot(0, byte(status), 0) +} +func WifiScanStatusMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Types/FirmwareBootType.go b/Serialization/Types/FirmwareBootType.go new file mode 100644 index 0000000..65e8048 --- /dev/null +++ b/Serialization/Types/FirmwareBootType.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type FirmwareBootType byte + +const ( + FirmwareBootTypeNormal FirmwareBootType = 0 + FirmwareBootTypeNewFirmware FirmwareBootType = 1 + FirmwareBootTypeRollback FirmwareBootType = 2 +) + +var EnumNamesFirmwareBootType = map[FirmwareBootType]string{ + FirmwareBootTypeNormal: "Normal", + FirmwareBootTypeNewFirmware: "NewFirmware", + FirmwareBootTypeRollback: "Rollback", +} + +var EnumValuesFirmwareBootType = map[string]FirmwareBootType{ + "Normal": FirmwareBootTypeNormal, + "NewFirmware": FirmwareBootTypeNewFirmware, + "Rollback": FirmwareBootTypeRollback, +} + +func (v FirmwareBootType) String() string { + if s, ok := EnumNamesFirmwareBootType[v]; ok { + return s + } + return "FirmwareBootType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Types/OtaUpdateProgressTask.go b/Serialization/Types/OtaUpdateProgressTask.go new file mode 100644 index 0000000..db6ef04 --- /dev/null +++ b/Serialization/Types/OtaUpdateProgressTask.go @@ -0,0 +1,44 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type OtaUpdateProgressTask byte + +const ( + OtaUpdateProgressTaskFetchingMetadata OtaUpdateProgressTask = 0 + OtaUpdateProgressTaskPreparingForUpdate OtaUpdateProgressTask = 1 + OtaUpdateProgressTaskFlashingFilesystem OtaUpdateProgressTask = 2 + OtaUpdateProgressTaskVerifyingFilesystem OtaUpdateProgressTask = 3 + OtaUpdateProgressTaskFlashingApplication OtaUpdateProgressTask = 4 + OtaUpdateProgressTaskMarkingApplicationBootable OtaUpdateProgressTask = 5 + OtaUpdateProgressTaskRebooting OtaUpdateProgressTask = 6 +) + +var EnumNamesOtaUpdateProgressTask = map[OtaUpdateProgressTask]string{ + OtaUpdateProgressTaskFetchingMetadata: "FetchingMetadata", + OtaUpdateProgressTaskPreparingForUpdate: "PreparingForUpdate", + OtaUpdateProgressTaskFlashingFilesystem: "FlashingFilesystem", + OtaUpdateProgressTaskVerifyingFilesystem: "VerifyingFilesystem", + OtaUpdateProgressTaskFlashingApplication: "FlashingApplication", + OtaUpdateProgressTaskMarkingApplicationBootable: "MarkingApplicationBootable", + OtaUpdateProgressTaskRebooting: "Rebooting", +} + +var EnumValuesOtaUpdateProgressTask = map[string]OtaUpdateProgressTask{ + "FetchingMetadata": OtaUpdateProgressTaskFetchingMetadata, + "PreparingForUpdate": OtaUpdateProgressTaskPreparingForUpdate, + "FlashingFilesystem": OtaUpdateProgressTaskFlashingFilesystem, + "VerifyingFilesystem": OtaUpdateProgressTaskVerifyingFilesystem, + "FlashingApplication": OtaUpdateProgressTaskFlashingApplication, + "MarkingApplicationBootable": OtaUpdateProgressTaskMarkingApplicationBootable, + "Rebooting": OtaUpdateProgressTaskRebooting, +} + +func (v OtaUpdateProgressTask) String() string { + if s, ok := EnumNamesOtaUpdateProgressTask[v]; ok { + return s + } + return "OtaUpdateProgressTask(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Types/SemVer.go b/Serialization/Types/SemVer.go new file mode 100644 index 0000000..f83c32f --- /dev/null +++ b/Serialization/Types/SemVer.go @@ -0,0 +1,116 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SemVer struct { + _tab flatbuffers.Table +} + +func GetRootAsSemVer(buf []byte, offset flatbuffers.UOffsetT) *SemVer { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SemVer{} + x.Init(buf, n+offset) + return x +} + +func FinishSemVerBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSemVer(buf []byte, offset flatbuffers.UOffsetT) *SemVer { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SemVer{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSemVerBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *SemVer) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SemVer) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SemVer) Major() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SemVer) MutateMajor(n uint16) bool { + return rcv._tab.MutateUint16Slot(4, n) +} + +func (rcv *SemVer) Minor() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SemVer) MutateMinor(n uint16) bool { + return rcv._tab.MutateUint16Slot(6, n) +} + +func (rcv *SemVer) Patch() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *SemVer) MutatePatch(n uint16) bool { + return rcv._tab.MutateUint16Slot(8, n) +} + +func (rcv *SemVer) Prerelease() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *SemVer) Build() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func SemVerStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func SemVerAddMajor(builder *flatbuffers.Builder, major uint16) { + builder.PrependUint16Slot(0, major, 0) +} +func SemVerAddMinor(builder *flatbuffers.Builder, minor uint16) { + builder.PrependUint16Slot(1, minor, 0) +} +func SemVerAddPatch(builder *flatbuffers.Builder, patch uint16) { + builder.PrependUint16Slot(2, patch, 0) +} +func SemVerAddPrerelease(builder *flatbuffers.Builder, prerelease flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(prerelease), 0) +} +func SemVerAddBuild(builder *flatbuffers.Builder, build flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(build), 0) +} +func SemVerEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Types/ShockerCommandType.go b/Serialization/Types/ShockerCommandType.go new file mode 100644 index 0000000..52f66b1 --- /dev/null +++ b/Serialization/Types/ShockerCommandType.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type ShockerCommandType byte + +const ( + ShockerCommandTypeStop ShockerCommandType = 0 + ShockerCommandTypeShock ShockerCommandType = 1 + ShockerCommandTypeVibrate ShockerCommandType = 2 + ShockerCommandTypeSound ShockerCommandType = 3 +) + +var EnumNamesShockerCommandType = map[ShockerCommandType]string{ + ShockerCommandTypeStop: "Stop", + ShockerCommandTypeShock: "Shock", + ShockerCommandTypeVibrate: "Vibrate", + ShockerCommandTypeSound: "Sound", +} + +var EnumValuesShockerCommandType = map[string]ShockerCommandType{ + "Stop": ShockerCommandTypeStop, + "Shock": ShockerCommandTypeShock, + "Vibrate": ShockerCommandTypeVibrate, + "Sound": ShockerCommandTypeSound, +} + +func (v ShockerCommandType) String() string { + if s, ok := EnumNamesShockerCommandType[v]; ok { + return s + } + return "ShockerCommandType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Types/ShockerModelType.go b/Serialization/Types/ShockerModelType.go new file mode 100644 index 0000000..8e76e3b --- /dev/null +++ b/Serialization/Types/ShockerModelType.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type ShockerModelType byte + +const ( + ShockerModelTypeCaiXianlin ShockerModelType = 0 + ShockerModelTypePetrainer ShockerModelType = 1 + ShockerModelTypePetrainer998DR ShockerModelType = 2 +) + +var EnumNamesShockerModelType = map[ShockerModelType]string{ + ShockerModelTypeCaiXianlin: "CaiXianlin", + ShockerModelTypePetrainer: "Petrainer", + ShockerModelTypePetrainer998DR: "Petrainer998DR", +} + +var EnumValuesShockerModelType = map[string]ShockerModelType{ + "CaiXianlin": ShockerModelTypeCaiXianlin, + "Petrainer": ShockerModelTypePetrainer, + "Petrainer998DR": ShockerModelTypePetrainer998DR, +} + +func (v ShockerModelType) String() string { + if s, ok := EnumNamesShockerModelType[v]; ok { + return s + } + return "ShockerModelType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Types/WifiAuthMode.go b/Serialization/Types/WifiAuthMode.go new file mode 100644 index 0000000..d05e65d --- /dev/null +++ b/Serialization/Types/WifiAuthMode.go @@ -0,0 +1,53 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type WifiAuthMode byte + +const ( + WifiAuthModeOpen WifiAuthMode = 0 + WifiAuthModeWEP WifiAuthMode = 1 + WifiAuthModeWPA_PSK WifiAuthMode = 2 + WifiAuthModeWPA2_PSK WifiAuthMode = 3 + WifiAuthModeWPA_WPA2_PSK WifiAuthMode = 4 + WifiAuthModeWPA2_ENTERPRISE WifiAuthMode = 5 + WifiAuthModeWPA3_PSK WifiAuthMode = 6 + WifiAuthModeWPA2_WPA3_PSK WifiAuthMode = 7 + WifiAuthModeWAPI_PSK WifiAuthMode = 8 + WifiAuthModeUNKNOWN WifiAuthMode = 9 +) + +var EnumNamesWifiAuthMode = map[WifiAuthMode]string{ + WifiAuthModeOpen: "Open", + WifiAuthModeWEP: "WEP", + WifiAuthModeWPA_PSK: "WPA_PSK", + WifiAuthModeWPA2_PSK: "WPA2_PSK", + WifiAuthModeWPA_WPA2_PSK: "WPA_WPA2_PSK", + WifiAuthModeWPA2_ENTERPRISE: "WPA2_ENTERPRISE", + WifiAuthModeWPA3_PSK: "WPA3_PSK", + WifiAuthModeWPA2_WPA3_PSK: "WPA2_WPA3_PSK", + WifiAuthModeWAPI_PSK: "WAPI_PSK", + WifiAuthModeUNKNOWN: "UNKNOWN", +} + +var EnumValuesWifiAuthMode = map[string]WifiAuthMode{ + "Open": WifiAuthModeOpen, + "WEP": WifiAuthModeWEP, + "WPA_PSK": WifiAuthModeWPA_PSK, + "WPA2_PSK": WifiAuthModeWPA2_PSK, + "WPA_WPA2_PSK": WifiAuthModeWPA_WPA2_PSK, + "WPA2_ENTERPRISE": WifiAuthModeWPA2_ENTERPRISE, + "WPA3_PSK": WifiAuthModeWPA3_PSK, + "WPA2_WPA3_PSK": WifiAuthModeWPA2_WPA3_PSK, + "WAPI_PSK": WifiAuthModeWAPI_PSK, + "UNKNOWN": WifiAuthModeUNKNOWN, +} + +func (v WifiAuthMode) String() string { + if s, ok := EnumNamesWifiAuthMode[v]; ok { + return s + } + return "WifiAuthMode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Types/WifiNetwork.go b/Serialization/Types/WifiNetwork.go new file mode 100644 index 0000000..06c6b9b --- /dev/null +++ b/Serialization/Types/WifiNetwork.go @@ -0,0 +1,131 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type WifiNetwork struct { + _tab flatbuffers.Table +} + +func GetRootAsWifiNetwork(buf []byte, offset flatbuffers.UOffsetT) *WifiNetwork { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &WifiNetwork{} + x.Init(buf, n+offset) + return x +} + +func FinishWifiNetworkBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsWifiNetwork(buf []byte, offset flatbuffers.UOffsetT) *WifiNetwork { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &WifiNetwork{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedWifiNetworkBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *WifiNetwork) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *WifiNetwork) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *WifiNetwork) Ssid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *WifiNetwork) Bssid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *WifiNetwork) Channel() byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetByte(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *WifiNetwork) MutateChannel(n byte) bool { + return rcv._tab.MutateByteSlot(8, n) +} + +func (rcv *WifiNetwork) Rssi() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *WifiNetwork) MutateRssi(n int8) bool { + return rcv._tab.MutateInt8Slot(10, n) +} + +func (rcv *WifiNetwork) AuthMode() WifiAuthMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return WifiAuthMode(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *WifiNetwork) MutateAuthMode(n WifiAuthMode) bool { + return rcv._tab.MutateByteSlot(12, byte(n)) +} + +func (rcv *WifiNetwork) Saved() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *WifiNetwork) MutateSaved(n bool) bool { + return rcv._tab.MutateBoolSlot(14, n) +} + +func WifiNetworkStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func WifiNetworkAddSsid(builder *flatbuffers.Builder, ssid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ssid), 0) +} +func WifiNetworkAddBssid(builder *flatbuffers.Builder, bssid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(bssid), 0) +} +func WifiNetworkAddChannel(builder *flatbuffers.Builder, channel byte) { + builder.PrependByteSlot(2, channel, 0) +} +func WifiNetworkAddRssi(builder *flatbuffers.Builder, rssi int8) { + builder.PrependInt8Slot(3, rssi, 0) +} +func WifiNetworkAddAuthMode(builder *flatbuffers.Builder, authMode WifiAuthMode) { + builder.PrependByteSlot(4, byte(authMode), 0) +} +func WifiNetworkAddSaved(builder *flatbuffers.Builder, saved bool) { + builder.PrependBoolSlot(5, saved, false) +} +func WifiNetworkEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/Serialization/Types/WifiNetworkEventType.go b/Serialization/Types/WifiNetworkEventType.go new file mode 100644 index 0000000..c27b196 --- /dev/null +++ b/Serialization/Types/WifiNetworkEventType.go @@ -0,0 +1,44 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type WifiNetworkEventType byte + +const ( + WifiNetworkEventTypeDiscovered WifiNetworkEventType = 0 + WifiNetworkEventTypeUpdated WifiNetworkEventType = 1 + WifiNetworkEventTypeLost WifiNetworkEventType = 2 + WifiNetworkEventTypeSaved WifiNetworkEventType = 3 + WifiNetworkEventTypeRemoved WifiNetworkEventType = 4 + WifiNetworkEventTypeConnected WifiNetworkEventType = 5 + WifiNetworkEventTypeDisconnected WifiNetworkEventType = 6 +) + +var EnumNamesWifiNetworkEventType = map[WifiNetworkEventType]string{ + WifiNetworkEventTypeDiscovered: "Discovered", + WifiNetworkEventTypeUpdated: "Updated", + WifiNetworkEventTypeLost: "Lost", + WifiNetworkEventTypeSaved: "Saved", + WifiNetworkEventTypeRemoved: "Removed", + WifiNetworkEventTypeConnected: "Connected", + WifiNetworkEventTypeDisconnected: "Disconnected", +} + +var EnumValuesWifiNetworkEventType = map[string]WifiNetworkEventType{ + "Discovered": WifiNetworkEventTypeDiscovered, + "Updated": WifiNetworkEventTypeUpdated, + "Lost": WifiNetworkEventTypeLost, + "Saved": WifiNetworkEventTypeSaved, + "Removed": WifiNetworkEventTypeRemoved, + "Connected": WifiNetworkEventTypeConnected, + "Disconnected": WifiNetworkEventTypeDisconnected, +} + +func (v WifiNetworkEventType) String() string { + if s, ok := EnumNamesWifiNetworkEventType[v]; ok { + return s + } + return "WifiNetworkEventType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/Serialization/Types/WifiScanStatus.go b/Serialization/Types/WifiScanStatus.go new file mode 100644 index 0000000..9fc77ce --- /dev/null +++ b/Serialization/Types/WifiScanStatus.go @@ -0,0 +1,41 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Types + +import "strconv" + +type WifiScanStatus byte + +const ( + WifiScanStatusStarted WifiScanStatus = 0 + WifiScanStatusInProgress WifiScanStatus = 1 + WifiScanStatusCompleted WifiScanStatus = 2 + WifiScanStatusTimedOut WifiScanStatus = 3 + WifiScanStatusAborted WifiScanStatus = 4 + WifiScanStatusError WifiScanStatus = 5 +) + +var EnumNamesWifiScanStatus = map[WifiScanStatus]string{ + WifiScanStatusStarted: "Started", + WifiScanStatusInProgress: "InProgress", + WifiScanStatusCompleted: "Completed", + WifiScanStatusTimedOut: "TimedOut", + WifiScanStatusAborted: "Aborted", + WifiScanStatusError: "Error", +} + +var EnumValuesWifiScanStatus = map[string]WifiScanStatus{ + "Started": WifiScanStatusStarted, + "InProgress": WifiScanStatusInProgress, + "Completed": WifiScanStatusCompleted, + "TimedOut": WifiScanStatusTimedOut, + "Aborted": WifiScanStatusAborted, + "Error": WifiScanStatusError, +} + +func (v WifiScanStatus) String() string { + if s, ok := EnumNamesWifiScanStatus[v]; ok { + return s + } + return "WifiScanStatus(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..cce3814 --- /dev/null +++ b/go.mod @@ -0,0 +1,8 @@ +module OpenShock + +go 1.23.4 + +require ( + github.com/google/flatbuffers v24.12.23+incompatible + github.com/gorilla/websocket v1.5.3 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..ecff778 --- /dev/null +++ b/go.sum @@ -0,0 +1,4 @@ +github.com/google/flatbuffers v24.12.23+incompatible h1:ubBKR94NR4pXUCY/MUsRVzd9umNW7ht7EG9hHfS9FX8= +github.com/google/flatbuffers v24.12.23+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= diff --git a/main.go b/main.go new file mode 100644 index 0000000..286d4dc --- /dev/null +++ b/main.go @@ -0,0 +1,328 @@ +package main + +import ( + "bufio" + "encoding/json" + "fmt" + "log" + "net/http" + "os" + "strings" + "time" + + flatbuffers "github.com/google/flatbuffers/go" + "github.com/gorilla/websocket" + + Gateway "OpenShock/Serialization/Gateway" + Types "OpenShock/Serialization/Types" +) + +// Global variable to track the program's start time +var startTime time.Time + +type Config struct { + AuthToken string `json:"auth_token"` + BaseURL string `json:"base_url"` +} + +const ( + configFile = "config.json" +) + +func initializeUptime() { + startTime = time.Now() +} + +func getUptimeMs() uint64 { + return uint64(time.Since(startTime).Milliseconds()) +} + +func loadConfig() (*Config, error) { + file, err := os.Open(configFile) + if err != nil { + if os.IsNotExist(err) { + return &Config{BaseURL: "https://api.openshock.app"}, nil + } + return nil, err + } + defer file.Close() + + var config Config + decoder := json.NewDecoder(file) + if err := decoder.Decode(&config); err != nil { + return nil, err + } + if config.BaseURL == "" { + config.BaseURL = "https://api.openshock.app" + } + return &config, nil +} + +func saveConfig(config *Config) error { + file, err := os.Create(configFile) + if err != nil { + return err + } + defer file.Close() + + encoder := json.NewEncoder(file) + encoder.SetIndent("", " ") + return encoder.Encode(config) +} + +func getAuthToken(baseURL, pairingCode string) (string, error) { + url := fmt.Sprintf("%s/1/device/pair/%s", baseURL, pairingCode) + req, err := http.NewRequest("GET", url, nil) + if err != nil { + return "", err + } + req.Header.Set("Accept", "application/json") + + client := &http.Client{Timeout: 10 * time.Second} + resp, err := client.Do(req) + if err != nil { + return "", err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return "", fmt.Errorf("failed to retrieve token: %s", resp.Status) + } + + // Try decoding as JSON object first + var jsonResponse struct { + Token string `json:"data"` + } + if err := json.NewDecoder(resp.Body).Decode(&jsonResponse); err == nil && jsonResponse.Token != "" { + return jsonResponse.Token, nil + } + + // If JSON object decoding fails, reset the body and try decoding as plain string + resp.Body.Close() + resp, err = client.Get(url) // Re-fetch the response to reset the body + if err != nil { + return "", err + } + defer resp.Body.Close() + + var token string + if err := json.NewDecoder(resp.Body).Decode(&token); err != nil { + return "", fmt.Errorf("failed to parse response: %w", err) + } + + return token, nil +} + +func getLCGURL(baseURL, authToken string) (string, error) { + url := fmt.Sprintf("%s/1/device/assignLCG", baseURL) + req, err := http.NewRequest("GET", url, nil) + if err != nil { + return "", err + } + req.Header.Set("Accept", "application/json") + req.Header.Set("DeviceToken", authToken) + + client := &http.Client{Timeout: 10 * time.Second} + resp, err := client.Do(req) + if err != nil { + return "", err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return "", fmt.Errorf("failed to retrieve LCG URL: %s", resp.Status) + } + + var response struct { + Data struct { + FQDN string `json:"fqdn"` + Country string `json:"country"` + } `json:"data"` + } + if err := json.NewDecoder(resp.Body).Decode(&response); err != nil { + return "", err + } + return response.Data.FQDN, nil +} + +func buildSemVer(builder *flatbuffers.Builder, major, minor, patch uint16, build, prerelease *string) flatbuffers.UOffsetT { + buildOffset := flatbuffers.UOffsetT(0) + prereleaseOffset := flatbuffers.UOffsetT(0) + + if build != nil { + buildOffset = builder.CreateString(*build) + } + if prerelease != nil { + prereleaseOffset = builder.CreateString(*prerelease) + } + + Types.SemVerStart(builder) + Types.SemVerAddMajor(builder, major) + Types.SemVerAddMinor(builder, minor) + Types.SemVerAddPatch(builder, patch) + if build != nil { + Types.SemVerAddBuild(builder, buildOffset) + } + if prerelease != nil { + Types.SemVerAddPrerelease(builder, prereleaseOffset) + } + return Types.SemVerEnd(builder) +} + +func buildBootStatus(builder *flatbuffers.Builder, bootType Types.FirmwareBootType, firmwareVersion flatbuffers.UOffsetT, otaUpdateID int) flatbuffers.UOffsetT { + Gateway.BootStatusStart(builder) + Gateway.BootStatusAddBootType(builder, bootType) + Gateway.BootStatusAddFirmwareVersion(builder, firmwareVersion) + Gateway.BootStatusAddOtaUpdateId(builder, int32(otaUpdateID)) + return Gateway.BootStatusEnd(builder) +} + +func buildPong(builder *flatbuffers.Builder, uptime uint64, rssi int32) flatbuffers.UOffsetT { + Gateway.PongStart(builder) + Gateway.PongAddUptime(builder, uptime) + Gateway.PongAddRssi(builder, rssi) + return Gateway.PongEnd(builder) +} + +func buildHubToGatewayMessage(builder *flatbuffers.Builder, payloadType Gateway.HubToGatewayMessagePayload, payload flatbuffers.UOffsetT) []byte { + Gateway.HubToGatewayMessageStart(builder) + Gateway.HubToGatewayMessageAddPayloadType(builder, payloadType) + Gateway.HubToGatewayMessageAddPayload(builder, payload) + message := Gateway.HubToGatewayMessageEnd(builder) + builder.Finish(message) + return builder.FinishedBytes() +} + +func sendBootStatus(conn *websocket.Conn) error { + builder := flatbuffers.NewBuilder(1024) + + semver := buildSemVer(builder, 1, 0, 0, nil, nil) // Example: Major=1, Minor=0, Patch=0, no build or prerelease + bootStatus := buildBootStatus(builder, Types.FirmwareBootTypeNormal, semver, 0) + message := buildHubToGatewayMessage(builder, Gateway.HubToGatewayMessagePayloadBootStatus, bootStatus) + + if err := conn.WriteMessage(websocket.BinaryMessage, message); err != nil { + return fmt.Errorf("failed to send boot status message: %w", err) + } + + return nil +} + +func sendPong(conn *websocket.Conn) error { + builder := flatbuffers.NewBuilder(1024) + + pong := buildPong(builder, getUptimeMs(), -65) + message := buildHubToGatewayMessage(builder, Gateway.HubToGatewayMessagePayloadPong, pong) + + if err := conn.WriteMessage(websocket.BinaryMessage, message); err != nil { + return fmt.Errorf("failed to send boot status message: %w", err) + } + + return nil +} + +func connectWebSocket(authToken, lcgURL string) error { + headers := http.Header{} + headers.Add("Firmware-Version", "1.0.0-Dummy") + headers.Add("Device-Token", authToken) + + fullURL := fmt.Sprintf("wss://%s/2/ws/hub", lcgURL) + log.Printf("Connecting to WebSocket at %s", fullURL) + + conn, _, err := websocket.DefaultDialer.Dial(fullURL, headers) + if err != nil { + return fmt.Errorf("failed to connect to WebSocket: %w", err) + } + defer conn.Close() + log.Println("Connected to WebSocket") + + err = sendBootStatus(conn) + if err != nil { + return err + } + + return handleWebSocketMessages(conn) +} + +// Handle Incoming WebSocket Messages +func handleWebSocketMessages(conn *websocket.Conn) error { + for { + _, bytes, err := conn.ReadMessage() + if err != nil { + return fmt.Errorf("WebSocket read error: %w", err) + } + + message := Gateway.GetRootAsGatewayToHubMessage(bytes, 0) + switch message.PayloadType() { + case Gateway.GatewayToHubMessagePayloadPing: + err := sendPong(conn) + if err != nil { + return err + } + case Gateway.GatewayToHubMessagePayloadShockerCommandList: + err := handleCommandList(message) + if err != nil { + return err + } + default: + log.Printf("Unknown message type: %d", message.PayloadType()) + } + } +} + +func handleCommandList(message *Gateway.GatewayToHubMessage) error { + table := flatbuffers.Table{} + if !message.Payload(&table) { + return fmt.Errorf("failed to deserialize commandlist") + } + commandlist := Gateway.ShockerCommandList{} + commandlist.Init(table.Bytes, table.Pos) + + ncommands := commandlist.CommandsLength() + + command := Gateway.ShockerCommand{} + for i := 0; i < ncommands; i++ { + if !commandlist.Commands(&command, i) { + return fmt.Errorf("failed to deserialize command") + } + + fmt.Printf("[COMMAND] %s at %v%% for %v seconds\n", command.Type().String(), command.Intensity(), float32(command.Duration())/1000.0) + } + + return nil +} + +func main() { + initializeUptime() + + config, err := loadConfig() + if err != nil { + log.Fatalf("Failed to load config: %v", err) + } + + if config.AuthToken == "" { + fmt.Print("Enter pairing code: ") + reader := bufio.NewReader(os.Stdin) + pairingCode, _ := reader.ReadString('\n') + pairingCode = strings.TrimSpace(pairingCode) + + config.AuthToken, err = getAuthToken(config.BaseURL, pairingCode) + if err != nil { + log.Fatalf("Failed to get auth token: %v", err) + } + + if err := saveConfig(config); err != nil { + log.Fatalf("Failed to save config: %v", err) + } + } + + lcgURL, err := getLCGURL(config.BaseURL, config.AuthToken) + if err != nil { + log.Fatalf("Failed to get LCG URL: %v", err) + } + + log.Printf("Got lcgURL: %s", lcgURL) + + if err := connectWebSocket(config.AuthToken, lcgURL); err != nil { + log.Fatalf("WebSocket error: %v", err) + } +}