diff --git a/Makefile b/Makefile index c9a48b5..bc4cdcc 100644 --- a/Makefile +++ b/Makefile @@ -49,7 +49,7 @@ help: .PHONY: clean clean: @echo "Cleaning build artifacts..." - @-rm -rf release debug .pio/build updater/.pio/build + @-rm -rf release debug .pio/build updater/.pio/build dependencies.lock updater/dependencies.lock managed_components updater/managed_components # Install dependencies .PHONY: deps diff --git a/resources/espressif__esp_hosted/.component_hash b/resources/espressif__esp_hosted/.component_hash new file mode 100644 index 0000000..a5f848f --- /dev/null +++ b/resources/espressif__esp_hosted/.component_hash @@ -0,0 +1 @@ +ba380b52c57e1adfb384591dd8ad85ebc7fce6f990741c403af2ea06c33f3371 \ No newline at end of file diff --git a/resources/espressif__esp_hosted/.editorconfig b/resources/espressif__esp_hosted/.editorconfig new file mode 100644 index 0000000..d394d9d --- /dev/null +++ b/resources/espressif__esp_hosted/.editorconfig @@ -0,0 +1,19 @@ +# EditorConfig helps developers define and maintain consistent +# coding styles between different editors and IDEs +# http://editorconfig.org + +root = true + +# Default configuration for all files +# - tabs for indentation +[*] +indent_style = tab +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true + +# Some Mermaid diagram commands need to end with a trailing whitespace in Markdown files +[*.md] +trim_trailing_whitespace = false diff --git a/resources/espressif__esp_hosted/.gitignore b/resources/espressif__esp_hosted/.gitignore new file mode 100644 index 0000000..6edbbdf --- /dev/null +++ b/resources/espressif__esp_hosted/.gitignore @@ -0,0 +1,7 @@ +build +dependencies.lock +managed_components +sdkconfig +sdkconfig.old +slave/main/coprocessor_fw_version.h +slave/main/coprocessor_fw_version.txt diff --git a/resources/espressif__esp_hosted/.gitlab-ci-override-idf-component.yml b/resources/espressif__esp_hosted/.gitlab-ci-override-idf-component.yml new file mode 100644 index 0000000..54e7717 --- /dev/null +++ b/resources/espressif__esp_hosted/.gitlab-ci-override-idf-component.yml @@ -0,0 +1,5 @@ + espressif/esp_hosted: + version: ">=1.0" + override_path: "${OVERRIDE_PATH}" + rules: + - if: "target in [esp32p4, esp32h2]" diff --git a/resources/espressif__esp_hosted/.gitmodules b/resources/espressif__esp_hosted/.gitmodules new file mode 100644 index 0000000..542fb1d --- /dev/null +++ b/resources/espressif__esp_hosted/.gitmodules @@ -0,0 +1,3 @@ +[submodule "esp_hosted_fg/common/protobuf-c"] + path = common/protobuf-c + url = https://github.com/protobuf-c/protobuf-c.git diff --git a/resources/espressif__esp_hosted/CMakeLists.txt b/resources/espressif__esp_hosted/CMakeLists.txt new file mode 100644 index 0000000..3f79b2f --- /dev/null +++ b/resources/espressif__esp_hosted/CMakeLists.txt @@ -0,0 +1,94 @@ +if(CONFIG_ESP_HOSTED_ENABLED) + message(STATUS "Using Hosted Wi-Fi") + set(FG_root_dir ".") + set(host_dir "${FG_root_dir}/host") + + set(srcs "${host_dir}/esp_hosted_host_init.c" "${host_dir}/api/src/esp_wifi_weak.c" "${host_dir}/api/src/esp_hosted_api.c" "${host_dir}/drivers/transport/transport_drv.c" "${host_dir}/drivers/serial/serial_ll_if.c" "${host_dir}/utils/common.c" "${host_dir}/utils/util.c" "${host_dir}/utils/stats.c" "${host_dir}/drivers/serial/serial_drv.c") + + # only these directories are public. Others are private + set(pub_include "${host_dir}" "${host_dir}/api/include") + + set(priv_include "${host_dir}/drivers/transport" "${host_dir}/drivers/transport/spi" "${host_dir}/drivers/transport/sdio" "${host_dir}/drivers/serial" "${host_dir}/utils" "${host_dir}/api/priv") + + # rpc files - wrap -> slaveif -> core + set(rpc_dir "${host_dir}/drivers/rpc") + set(rpc_core_dir "${rpc_dir}/core") + set(rpc_slaveif_dir "${rpc_dir}/slaveif") + set(rpc_wrap_dir "${rpc_dir}/wrap") + list(APPEND srcs "${rpc_core_dir}/rpc_core.c" "${rpc_core_dir}/rpc_req.c" "${rpc_core_dir}/rpc_rsp.c" "${rpc_core_dir}/rpc_evt.c" + "${rpc_slaveif_dir}/rpc_slave_if.c" + "${rpc_wrap_dir}/rpc_wrap.c") + list(APPEND priv_include "${rpc_core_dir}" "${rpc_slaveif_dir}" "${rpc_wrap_dir}") + + # virtual serial + set(virt_serial_dir "${host_dir}/drivers/virtual_serial_if") + list(APPEND srcs "${virt_serial_dir}/serial_if.c") + list(APPEND priv_include "${virt_serial_dir}") + + # mempool + list(APPEND srcs "${host_dir}/drivers/mempool/mempool.c") + list(APPEND priv_include "${host_dir}/drivers/mempool" ) + + # slave and host common files + set(common_dir "${FG_root_dir}/common") + list(APPEND srcs "${common_dir}/protobuf-c/protobuf-c/protobuf-c.c" "${common_dir}/proto/esp_hosted_rpc.pb-c.c" ) + list(APPEND priv_include "${common_dir}" "${common_dir}/log" "${common_dir}/rpc" "${common_dir}/transport" "${common_dir}/protobuf-c" "${common_dir}/proto" ) + + # host ESP32 specific files + list(APPEND srcs "${host_dir}/port/esp/freertos/src/esp_hosted_ota.c") + + # bt (NimBLE) + ### TODO config for HCI over UART + list(APPEND priv_include "${host_dir}/drivers/bt") + if(CONFIG_ESP_HOSTED_NIMBLE_HCI_VHCI OR CONFIG_ESP_HOSTED_BLUEDROID_HCI_VHCI) + list(APPEND srcs "${host_dir}/drivers/bt/vhci_drv.c") + else() + list(APPEND srcs "${host_dir}/drivers/bt/hci_stub_drv.c") + endif() + + # transport files + if(CONFIG_ESP_HOSTED_SDIO_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/drivers/transport/sdio/sdio_drv.c") + elseif(CONFIG_ESP_HOSTED_SPI_HD_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/drivers/transport/spi_hd/spi_hd_drv.c") + elseif(CONFIG_ESP_HOSTED_SPI_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/drivers/transport/spi/spi_drv.c") + elseif(CONFIG_ESP_HOSTED_UART_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/drivers/transport/uart/uart_drv.c") + endif() + + # config files + list(APPEND priv_include "${host_dir}/port/esp/freertos/include") + list(APPEND srcs "${host_dir}/port/esp/freertos/src/esp_hosted_config.c" "${host_dir}/port/esp/freertos/src/esp_hosted_transport_config.c") + + # transport port files + list(APPEND srcs "${host_dir}/port/esp/freertos/src/os_wrapper.c") + if(CONFIG_ESP_HOSTED_SDIO_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/port/esp/freertos/src/sdio_wrapper.c") + elseif(CONFIG_ESP_HOSTED_SPI_HD_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/port/esp/freertos/src/spi_hd_wrapper.c") + elseif(CONFIG_ESP_HOSTED_SPI_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/port/esp/freertos/src/spi_wrapper.c") + elseif(CONFIG_ESP_HOSTED_UART_HOST_INTERFACE) + list(APPEND srcs "${host_dir}/port/esp/freertos/src/uart_wrapper.c") + endif() + +endif() + +idf_component_register(SRCS ${srcs} + PRIV_REQUIRES soc esp_event esp_netif esp_timer driver esp_wifi bt esp_http_client + INCLUDE_DIRS ${pub_include} + PRIV_INCLUDE_DIRS ${priv_include}) + +idf_component_set_property(${COMPONENT_NAME} WHOLE_ARCHIVE TRUE) + +if(CONFIG_ESP_HOSTED_SDIO_HOST_INTERFACE) + idf_component_optional_requires(PRIVATE sdmmc) +endif() + +# Required if using ESP-IDF without commit 6b6065de509b5de39e4655fd425bf96f43b365f7: +# fix(driver_spi): fix p4 cache auto writeback during spi(dma) rx +# if(CONFIG_IDF_TARGET_ESP32P4 AND (CONFIG_ESP_HOSTED_SPI_HOST_INTERFACE OR CONFIG_ESP_HOSTED_SPI_HD_HOST_INTERFACE)) +# # used to workaround SPI transfer issue +# idf_component_optional_requires(PRIVATE esp_mm) +# endif() diff --git a/resources/espressif__esp_hosted/Kconfig b/resources/espressif__esp_hosted/Kconfig new file mode 100644 index 0000000..929e356 --- /dev/null +++ b/resources/espressif__esp_hosted/Kconfig @@ -0,0 +1,1356 @@ +config ESP_HOSTED_ENABLED + bool + default y if ESP_WIFI_REMOTE_ENABLED && ESP_WIFI_REMOTE_LIBRARY_HOSTED + default n + +menu "ESP-Hosted config" + depends on ESP_HOSTED_ENABLED + + # Co-processor selection done in Wi-Fi Remote Component + comment "ESP32 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32 + comment "ESP32-S2 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32S2 + comment "ESP32-S3 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32S3 + comment "ESP32-C2 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32C2 + comment "ESP32-C3 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32C3 + comment "ESP32-C6 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32C6 + comment "ESP32-C5 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32C5 + comment "ESP32-C61 is Slave Target from Wi-Fi Remote Component" + depends on SLAVE_IDF_TARGET_ESP32C61 + + # y if SDIO Transport is available, based on host and slave selection + config ESP_HOSTED_PRIV_SDIO_OPTION + bool + default y if (IDF_TARGET_ESP32 || IDF_TARGET_ESP32S3 || IDF_TARGET_ESP32P4) && (SLAVE_IDF_TARGET_ESP32 || SLAVE_IDF_TARGET_ESP32C6 || SLAVE_IDF_TARGET_ESP32C5) + default n + + # y if SPI HD Transport is available, based on host and slave selection + config ESP_HOSTED_PRIV_SPI_HD_OPTION + bool + default n if (IDF_TARGET_ESP32 || SLAVE_IDF_TARGET_ESP32) + default y + + choice ESP_HOSTED_HOST_INTERFACE + bool "Transport layer" + default ESP_HOSTED_SDIO_HOST_INTERFACE if ESP_HOSTED_PRIV_SDIO_OPTION + default ESP_HOSTED_SPI_HOST_INTERFACE + help + Bus interface to be used for communication with the host + + config ESP_HOSTED_SPI_HOST_INTERFACE + bool "SPI Full-duplex" + help + Enable/Disable SPI Full-duplex host interface + + config ESP_HOSTED_SDIO_HOST_INTERFACE + depends on ESP_HOSTED_PRIV_SDIO_OPTION + bool "SDIO" + help + Enable/Disable SDIO host interface + + # SPI Half Duplex is not supported in ESP32 + config ESP_HOSTED_SPI_HD_HOST_INTERFACE + depends on ESP_HOSTED_PRIV_SPI_HD_OPTION + bool "SPI Half-duplex" + help + Enable/Disable SPI Half-duplex host interface + + config ESP_HOSTED_UART_HOST_INTERFACE + bool "UART" + help + Enable/Disable UART host interface + endchoice + + config ESP_HOSTED_IDF_SLAVE_TARGET + string + default "esp32" if SLAVE_IDF_TARGET_ESP32 + default "esp32s2" if SLAVE_IDF_TARGET_ESP32S2 + default "esp32s3" if SLAVE_IDF_TARGET_ESP32S3 + default "esp32c2" if SLAVE_IDF_TARGET_ESP32C2 + default "esp32c3" if SLAVE_IDF_TARGET_ESP32C3 + default "esp32c6" if SLAVE_IDF_TARGET_ESP32C6 + default "esp32c5" if SLAVE_IDF_TARGET_ESP32C5 + default "invalid" + + menu "SPI Configuration" + depends on ESP_HOSTED_SPI_HOST_INTERFACE + + choice ESP_HOSTED_SPI_PRIV_MODE_ESP32 + depends on SLAVE_IDF_TARGET_ESP32 + bool "Host SPI mode" + default ESP_HOSTED_SPI_PRIV_MODE_2_ESP32 + + config ESP_HOSTED_SPI_PRIV_MODE_0_ESP32 + bool "Host SPI mode 0" + + config ESP_HOSTED_SPI_PRIV_MODE_1_ESP32 + bool "Host SPI mode 1" + + config ESP_HOSTED_SPI_PRIV_MODE_2_ESP32 + bool "Host SPI mode 2" + + config ESP_HOSTED_SPI_PRIV_MODE_3_ESP32 + bool "Host SPI mode 3" + endchoice + + choice ESP_HOSTED_SPI_PRIV_MODE_ESP32XX + depends on !SLAVE_IDF_TARGET_ESP32 + bool "Host SPI mode" + default ESP_HOSTED_SPI_PRIV_MODE_3_ESP32XX + + config ESP_HOSTED_SPI_PRIV_MODE_0_ESP32XX + bool "Host SPI mode 0" + + config ESP_HOSTED_SPI_PRIV_MODE_1_ESP32XX + bool "Host SPI mode 1" + + config ESP_HOSTED_SPI_PRIV_MODE_2_ESP32XX + bool "Host SPI mode 2" + + config ESP_HOSTED_SPI_PRIV_MODE_3_ESP32XX + bool "Host SPI mode 3" + endchoice + + config ESP_HOSTED_SPI_MODE + int + default 0 if ESP_HOSTED_SPI_PRIV_MODE_0_ESP32 + default 1 if ESP_HOSTED_SPI_PRIV_MODE_1_ESP32 + default 2 if ESP_HOSTED_SPI_PRIV_MODE_2_ESP32 + default 3 if ESP_HOSTED_SPI_PRIV_MODE_3_ESP32 + default 0 if ESP_HOSTED_SPI_PRIV_MODE_0_ESP32XX + default 1 if ESP_HOSTED_SPI_PRIV_MODE_1_ESP32XX + default 2 if ESP_HOSTED_SPI_PRIV_MODE_2_ESP32XX + default 3 if ESP_HOSTED_SPI_PRIV_MODE_3_ESP32XX + + choice ESP_HOSTED_SPI_CONTROLLER + bool "Host SPI controller to use" + default ESP_HOSTED_SPI_HSPI + + config ESP_HOSTED_SPI_HSPI + bool "HSPI/FSPI" + help + "HSPI/FSPI: SPI_controller_1" + + config ESP_HOSTED_SPI_VSPI + depends on IDF_TARGET_ESP32 + bool "VSPI" + help + "VSPI: SPI_controller_2" + + endchoice + + config ESP_HOSTED_SPI_CONTROLLER + int + default 2 if ESP_HOSTED_SPI_VSPI + default 1 + + menu "Host SPI GPIOs Config" + + choice ESP_HOSTED_SPI_HANDSHAKE_GPIO_CONFIG + bool "Handshake GPIO Config" + default ESP_HOSTED_HS_ACTIVE_HIGH + + config ESP_HOSTED_HS_ACTIVE_HIGH + bool "HS: Active High" + config ESP_HOSTED_HS_ACTIVE_LOW + bool "HS: Active Low" + endchoice + + choice ESP_HOSTED_SPI_DATAREADY__GPIO_CONFIG + bool "DataReady GPIO Config" + default ESP_HOSTED_DR_ACTIVE_HIGH + + config ESP_HOSTED_DR_ACTIVE_HIGH + bool "DR: Active High" + config ESP_HOSTED_DR_ACTIVE_LOW + bool "DR: Active Low" + endchoice + + choice ESP_HOSTED_SPI_RESET_GPIO_CONFIG + bool "Reset GPIO Config" + default ESP_HOSTED_SPI_RESET_ACTIVE_HIGH + help + "If Active High, High->Low->High will trigger reset (Low will trigger reset) + If Active Low, Low->High->Low will trigger reset (High will trigger reset)" + + config ESP_HOSTED_SPI_RESET_ACTIVE_HIGH + bool "RESET: Active High" + config ESP_HOSTED_SPI_RESET_ACTIVE_LOW + bool "RESET: Active Low" + endchoice + + config ESP_HOSTED_SPI_HSPI_GPIO_MOSI + depends on ESP_HOSTED_SPI_HSPI + int "GPIO pin for Host MOSI" + default 14 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 23 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 13 if IDF_TARGET_ESP32 + default 11 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 5 if IDF_TARGET_ESP32H2 + default 7 + help + SPI controller Host MOSI + + config ESP_HOSTED_SPI_HSPI_GPIO_MISO + depends on ESP_HOSTED_SPI_HSPI + int "GPIO pin for Host MISO" + default 15 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 22 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 12 if IDF_TARGET_ESP32 + default 13 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 0 if IDF_TARGET_ESP32H2 + default 2 + help + SPI controller Host MISO + + config ESP_HOSTED_SPI_HSPI_GPIO_CLK + depends on ESP_HOSTED_SPI_HSPI + int "GPIO pin for Host CLK" + default 18 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 33 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 14 if IDF_TARGET_ESP32 + default 12 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 4 if IDF_TARGET_ESP32H2 + default 6 + help + SPI controller Host CLK + + config ESP_HOSTED_SPI_HSPI_GPIO_CS + depends on ESP_HOSTED_SPI_HSPI + int "GPIO pin for Host CS" + default 19 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 4 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 15 if IDF_TARGET_ESP32 + default 10 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 1 if IDF_TARGET_ESP32H2 + default 10 + help + SPI controller Host CS + + config ESP_HOSTED_SPI_VSPI_GPIO_MOSI + depends on ESP_HOSTED_SPI_VSPI + int "GPIO pin for Host MOSI" + default 23 + help + SPI controller Host MOSI + + config ESP_HOSTED_SPI_VSPI_GPIO_MISO + depends on ESP_HOSTED_SPI_VSPI + int "GPIO pin for Host MISO" + default 19 + help + SPI controller Host MISO + + config ESP_HOSTED_SPI_VSPI_GPIO_CLK + depends on ESP_HOSTED_SPI_VSPI + int "GPIO pin for Host CLK" + default 18 + help + SPI controller Host CLK + + config ESP_HOSTED_SPI_VSPI_GPIO_CS + depends on ESP_HOSTED_SPI_VSPI + int "GPIO pin for Host CS" + default 5 + help + SPI controller Host CS + + config ESP_HOSTED_SPI_GPIO_MOSI + int + default ESP_HOSTED_SPI_VSPI_GPIO_MOSI if ESP_HOSTED_SPI_VSPI + default ESP_HOSTED_SPI_HSPI_GPIO_MOSI + + config ESP_HOSTED_SPI_GPIO_MISO + int + default ESP_HOSTED_SPI_VSPI_GPIO_MISO if ESP_HOSTED_SPI_VSPI + default ESP_HOSTED_SPI_HSPI_GPIO_MISO + + config ESP_HOSTED_SPI_GPIO_CLK + int + default ESP_HOSTED_SPI_VSPI_GPIO_CLK if ESP_HOSTED_SPI_VSPI + default ESP_HOSTED_SPI_HSPI_GPIO_CLK + + config ESP_HOSTED_SPI_GPIO_CS + int + default ESP_HOSTED_SPI_VSPI_GPIO_CS if ESP_HOSTED_SPI_VSPI + default ESP_HOSTED_SPI_HSPI_GPIO_CS + + config ESP_HOSTED_SPI_GPIO_HANDSHAKE + int "GPIO pin for handshake" + default 16 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 21 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 3 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32C6 + default 17 if IDF_TARGET_ESP32S3 || IDF_TARGET_ESP32S2 + default 22 if IDF_TARGET_ESP32H2 + default 26 + help + GPIO pin to use for handshake with other spi controller + + config ESP_HOSTED_SPI_GPIO_DATA_READY + int "GPIO pin for data ready interrupt" + default 17 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 32 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 12 if IDF_TARGET_ESP32H2 + default 4 + help + GPIO pin for indicating host that SPI slave has data to be read by host + + config ESP_HOSTED_SPI_GPIO_RESET_SLAVE + int "GPIO pin for Reseting slave ESP" + default 54 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 53 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 10 if IDF_TARGET_ESP32H2 + default 5 + help + GPIO pin for Resetting ESP SPI slave device. Should be connected to RST/EN of ESP SPI slave device. + endmenu + +ESP32XX_SPI_CLK_FREQ_RANGE_MIN := 1 +ESP32_SPI_CLK_FREQ_RANGE_MAX := 10 +ESP32C6_SPI_CLK_FREQ_RANGE_MAX := 40 +ESP32XX_SPI_CLK_FREQ_RANGE_MAX := 40 + + config ESP_HOSTED_SPI_FREQ_ESP32 + depends on SLAVE_IDF_TARGET_ESP32 + int "SPI Clock Freq (MHz)" + default 10 + range $(ESP32XX_SPI_CLK_FREQ_RANGE_MIN) $(ESP32_SPI_CLK_FREQ_RANGE_MAX) + help + "Optimize SPI CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_FREQ_ESP32C6 + depends on SLAVE_IDF_TARGET_ESP32C6 + int "SPI Clock Freq (MHz)" + default 40 if IDF_TARGET_ESP32P4 #config for ESP32-P4 Function_EV_Board + default 26 + range $(ESP32XX_SPI_CLK_FREQ_RANGE_MIN) $(ESP32C6_SPI_CLK_FREQ_RANGE_MAX) + help + "Optimize SPI CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_FREQ_ESP32XX + depends on SLAVE_IDF_TARGET_ESP32C2 || SLAVE_IDF_TARGET_ESP32C3 || SLAVE_IDF_TARGET_ESP32S2 || SLAVE_IDF_TARGET_ESP32S3 || SLAVE_IDF_TARGET_ESP32C5 + int "SPI Clock Freq" + default 40 if SLAVE_IDF_TARGET_ESP32C2 || SLAVE_IDF_TARGET_ESP32C3 || SLAVE_IDF_TARGET_ESP32S2 || SLAVE_IDF_TARGET_ESP32S3 || SLAVE_IDF_TARGET_ESP32C5 + range $(ESP32XX_SPI_CLK_FREQ_RANGE_MIN) $(ESP32XX_SPI_CLK_FREQ_RANGE_MAX) + help + "Optimize SPI CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_CLK_FREQ + int + default ESP_HOSTED_SPI_FREQ_ESP32 if SLAVE_IDF_TARGET_ESP32 + default ESP_HOSTED_SPI_FREQ_ESP32C6 if SLAVE_IDF_TARGET_ESP32C6 + default ESP_HOSTED_SPI_FREQ_ESP32XX if SLAVE_IDF_TARGET_ESP32C2 || SLAVE_IDF_TARGET_ESP32C3 || SLAVE_IDF_TARGET_ESP32S2 || SLAVE_IDF_TARGET_ESP32S3 || SLAVE_IDF_TARGET_ESP32C5 + help + "Optimize SPI CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_TX_Q_SIZE + int "ESP to Host SPI queue size" + default 20 + help + Very small tx queue will lower ESP -- SPI --> Host data rate + + config ESP_HOSTED_SPI_RX_Q_SIZE + int "Host to ESP SPI queue size" + default 20 + help + Very small RX queue will lower ESP <-- SPI -- Host data rate + + endmenu + + menu "Hosted SDIO Configuration" + depends on ESP_HOSTED_SDIO_HOST_INTERFACE + + choice ESP_HOSTED_SDIO_RESET_GPIO_CONFIG + bool "RESET GPIO Config" + default ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH + help + "If Active High, High->Low->High will trigger reset (Low will trigger reset) + If Active Low, Low->High->Low will trigger reset (High will trigger reset)" + + config ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH + bool "RESET: Active High" + config ESP_HOSTED_SDIO_RESET_ACTIVE_LOW + bool "RESET: Active Low" + endchoice + + choice ESP_HOSTED_SDIO_RX_OPTIMIZATION + bool "SDIO Receive Optimization" + default ESP_HOSTED_SDIO_OPTIMIZATION_RX_STREAMING_MODE + + config ESP_HOSTED_SDIO_OPTIMIZATION_RX_NONE + bool "No optimization" + help + Use SDIO as is, with no optimizations. + + config ESP_HOSTED_SDIO_OPTIMIZATION_RX_MAX_SIZE + bool "Always Rx Max Packet size" + help + Always read max Rx Packet Size (512 * 3 bytes). This saves one SDIO + transaction (get Rx Packet Size) when reading data from slave by + always transferring a fixed amount of data. Extra data at end of valid + packet data is discarded. + + config ESP_HOSTED_SDIO_OPTIMIZATION_RX_STREAMING_MODE + bool "Use Streaming Mode" + help + Receive a stream of queued data from the slave, made up of one or more + packets of data. Host extracts packets from the stream. This improves + SDIO read performance by doing one large read transaction instead of + many smaller read transactions for each packet. + (Note: requires slave to support streaming mode.) + + endchoice + + choice + prompt "SDIO Slot To Use" + default ESP_HOSTED_SDIO_SLOT_1 + help + On the ESP32-P4 EV Board: + - Slot 0 connects to the MicroSD Card slot + - Slot 1 connects to the on-board ESP32-C6 + For the ESP32, Slot 0 is usually occupied by SPI Flash and not usable for SDIO. + For the ESP32-P4, Slot 0 is IOMUXed and GPIO values cannot be changed + + config ESP_HOSTED_SDIO_SLOT_0 + depends on IDF_TARGET_ESP32P4 || IDF_TARGET_ESP32S3 + bool "Slot 0" + + config ESP_HOSTED_SDIO_SLOT_1 + bool "Slot 1" + endchoice + + config ESP_HOSTED_SDIO_SLOT + int + default 0 if ESP_HOSTED_SDIO_SLOT_0 + default 1 if ESP_HOSTED_SDIO_SLOT_1 + + config ESP_HOSTED_SD_PWR_CTRL_LDO_INTERNAL_IO + depends on SOC_SDMMC_IO_POWER_EXTERNAL + bool "SDIO power supply comes from internal LDO IO (READ HELP!)" + default n + help + Only needed when the SDIO module is connected to specific IO pins which can be used for high-speed SDIO. + Please read the schematic first and check if the SD VDD is connected to any internal LDO output. + Unselect this option if the SDIO is powered by an external power supply. + For ESP32-P4 EV Board, SDMMC slot 0 may require internal LDO output. + + config ESP_HOSTED_SD_PWR_CTRL_LDO_IO_ID + depends on SOC_SDMMC_IO_POWER_EXTERNAL && ESP_HOSTED_SD_PWR_CTRL_LDO_INTERNAL_IO + int "LDO ID" + default 4 if IDF_TARGET_ESP32P4 + help + Please check your schematic first and input your LDO ID. + + choice + prompt "SDIO Bus Width" + default ESP_HOSTED_SDIO_4_BIT_BUS + help + Select the SDIO Bus Width to use + + config ESP_HOSTED_SDIO_4_BIT_BUS + bool "4 Bits" + + config ESP_HOSTED_SDIO_1_BIT_BUS + bool "1 Bit" + endchoice + + config ESP_HOSTED_SDIO_BUS_WIDTH + int + default 1 if ESP_HOSTED_SDIO_1_BIT_BUS + default 4 + +ESP32_SDIO_CLK_FREQ_KHZ_RANGE_MIN := 400 +ESP32_SDIO_CLK_FREQ_KHZ_RANGE_MAX := 40000 +ESP32XX_SDIO_CLK_FREQ_KHZ_RANGE_MIN := 400 +ESP32XX_SDIO_CLK_FREQ_KHZ_RANGE_MAX := 50000 + + config ESP_HOSTED_SDIO_CLOCK_FREQ_KHZ + int "SDIO Clock Freq (in kHz)" + default 40000 + range $(ESP32_SDIO_CLK_FREQ_KHZ_RANGE_MIN) $(ESP32_SDIO_CLK_FREQ_KHZ_RANGE_MAX) if IDF_TARGET_ESP32 + range $(ESP32XX_SDIO_CLK_FREQ_KHZ_RANGE_MIN) $(ESP32XX_SDIO_CLK_FREQ_KHZ_RANGE_MAX) if IDF_TARGET_ESP32S3 || IDF_TARGET_ESP32P4 + help + "Optimize SDIO CLK by increasing till host practically can support. Clock frequency for ESP32-P4 as host <= 40MHz" + + config ESP_HOSTED_CUSTOM_SDIO_PINS + bool "Use custom SDIO GPIO pins" + default n + help + Enable this to use custom GPIO pins for SDIO on ESP32-P4 and ESP32-S3. + ESP32 has fixed GPIOs for SDIO host (Do not use custom GPIOs) + ESP32-P4 slot 0 is fixed GPIOs for SDIO host (Do not use custom GPIOs) + ESP32-P4 slot 1, ESP32-S3 slot 0/1 is flexible GPIOs for SDIO host (Flexible GPIOs) + + config ESP_HOSTED_SDIO_CMD_GPIO_RANGE_MIN + int + default 4 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 19 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 15 if IDF_TARGET_ESP32 + default 0 + + config ESP_HOSTED_SDIO_CMD_GPIO_RANGE_MAX + int + default 4 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 19 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 15 if IDF_TARGET_ESP32 + default 100 + + config ESP_HOSTED_SDIO_CLK_GPIO_RANGE_MIN + int + default 33 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 18 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 14 if IDF_TARGET_ESP32 + default 0 + + config ESP_HOSTED_SDIO_CLK_GPIO_RANGE_MAX + int + default 33 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 18 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 14 if IDF_TARGET_ESP32 + default 100 + + config ESP_HOSTED_SDIO_D0_GPIO_RANGE_MIN + int + default 20 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 14 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 2 if IDF_TARGET_ESP32 + default 0 + + config ESP_HOSTED_SDIO_D0_GPIO_RANGE_MAX + int + default 20 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 14 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 2 if IDF_TARGET_ESP32 + default 100 + + config ESP_HOSTED_SDIO_D1_GPIO_RANGE_MIN + int + default 23 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 15 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 4 if IDF_TARGET_ESP32 + default 0 + + config ESP_HOSTED_SDIO_D1_GPIO_RANGE_MAX + int + default 23 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 15 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 4 if IDF_TARGET_ESP32 + default 100 + + config ESP_HOSTED_SDIO_D2_GPIO_RANGE_MIN + int + default 21 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 16 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 12 if IDF_TARGET_ESP32 + default 0 + + config ESP_HOSTED_SDIO_D2_GPIO_RANGE_MAX + int + default 21 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 16 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 12 if IDF_TARGET_ESP32 + default 100 + + config ESP_HOSTED_SDIO_D3_GPIO_RANGE_MIN + int + default 22 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 17 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 13 if IDF_TARGET_ESP32 + default 0 + + config ESP_HOSTED_SDIO_D3_GPIO_RANGE_MAX + int + default 22 if !ESP_HOSTED_CUSTOM_SDIO_PINS && SLAVE_IDF_TARGET_ESP32C5 && IDF_TARGET_ESP32P4 + default 17 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 13 if IDF_TARGET_ESP32 + default 100 + + config ESP_HOSTED_SDIO_RESET_SLAVE_GPIO_MIN + int + default 53 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 54 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 42 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32S3 + default 5 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32 + default 0 + help + GPIO pin for Resetting ESP SDIO slave device. Should be connected to RST/EN of ESP SDIO slave device. + + config ESP_HOSTED_SDIO_RESET_SLAVE_GPIO_MAX + int + default 53 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 54 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32P4 + default 42 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32S3 + default 5 if !ESP_HOSTED_CUSTOM_SDIO_PINS && IDF_TARGET_ESP32 + default 100 + +### *START* GPIO SDIO pin configurations for Slot 0 and 1 + config ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "CMD GPIO number" + default 47 if IDF_TARGET_ESP32S3 + range 44 44 if IDF_TARGET_ESP32P4 + range 15 15 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + + config ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "CMD GPIO number" + default 47 if IDF_TARGET_ESP32S3 + default 4 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 19 if IDF_TARGET_ESP32P4 + default 15 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_CMD_GPIO_RANGE_MIN ESP_HOSTED_SDIO_CMD_GPIO_RANGE_MAX + help + CMD GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + + config ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "CLK GPIO number" + default 19 if IDF_TARGET_ESP32S3 + range 43 43 if IDF_TARGET_ESP32P4 + range 14 14 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + + config ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "CLK GPIO number" + default 19 if IDF_TARGET_ESP32S3 + default 33 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 18 if IDF_TARGET_ESP32P4 + default 14 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_CLK_GPIO_RANGE_MIN ESP_HOSTED_SDIO_CLK_GPIO_RANGE_MAX + help + CLK GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + + config ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "D0 GPIO number" + default 13 if IDF_TARGET_ESP32S3 + range 39 39 if IDF_TARGET_ESP32P4 + range 2 2 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + + config ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "D0 GPIO number" + default 13 if IDF_TARGET_ESP32S3 + default 20 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 14 if IDF_TARGET_ESP32P4 + default 2 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_D0_GPIO_RANGE_MIN ESP_HOSTED_SDIO_D0_GPIO_RANGE_MAX + help + D0 GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + + if ESP_HOSTED_SDIO_4_BIT_BUS + config ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "D1 GPIO number" + default 35 if IDF_TARGET_ESP32S3 + range 40 40 if IDF_TARGET_ESP32P4 + range 4 4 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + + config ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "D1 GPIO number" + default 35 if IDF_TARGET_ESP32S3 + default 23 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 15 if IDF_TARGET_ESP32P4 + default 4 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_D1_GPIO_RANGE_MIN ESP_HOSTED_SDIO_D1_GPIO_RANGE_MAX + help + D1 GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + + config ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "D2 GPIO number" + default 20 if IDF_TARGET_ESP32S3 + range 41 41 if IDF_TARGET_ESP32P4 + range 12 12 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + + config ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "D2 GPIO number" + default 20 if IDF_TARGET_ESP32S3 + default 21 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 16 if IDF_TARGET_ESP32P4 + default 12 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_D2_GPIO_RANGE_MIN ESP_HOSTED_SDIO_D2_GPIO_RANGE_MAX + help + D2 GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + + config ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "D3 GPIO number" + default 9 if IDF_TARGET_ESP32S3 + range 42 42 if IDF_TARGET_ESP32P4 + range 13 13 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + + config ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "D3 GPIO number" + default 9 if IDF_TARGET_ESP32S3 + default 22 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 17 if IDF_TARGET_ESP32P4 + default 13 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_D3_GPIO_RANGE_MIN ESP_HOSTED_SDIO_D3_GPIO_RANGE_MAX + help + D3 GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + endif + + if !ESP_HOSTED_SDIO_4_BIT_BUS + config ESP_HOSTED_PRIV_SDIO_PIN_D1_1BIT_BUS_SLOT_0 + depends on ESP_HOSTED_SDIO_SLOT_0 + int "D1 GPIO number (Interrupt Line)" + default 35 if IDF_TARGET_ESP32S3 + range 40 40 if IDF_TARGET_ESP32P4 + range 4 4 if IDF_TARGET_ESP32 + help + "Value can only be configured for some targets. Displayed always for reference." + config ESP_HOSTED_PRIV_SDIO_PIN_D1_1BIT_BUS_SLOT_1 + depends on ESP_HOSTED_SDIO_SLOT_1 + int "D1 GPIO number (Interrupt Line)" + default 35 if IDF_TARGET_ESP32S3 + default 23 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 15 if IDF_TARGET_ESP32P4 + default 4 if IDF_TARGET_ESP32 + range ESP_HOSTED_SDIO_D1_GPIO_RANGE_MIN ESP_HOSTED_SDIO_D1_GPIO_RANGE_MAX + help + D1 GPIO pin for SDIO. Range enforced dynamically based on slave target to ensure IOMUX compliance. + Enable 'Use custom SDIO GPIO pins' to disable range restrictions. + endif + + config ESP_HOSTED_SDIO_GPIO_RESET_SLAVE + int "GPIO pin for Reseting slave ESP" + range ESP_HOSTED_SDIO_RESET_SLAVE_GPIO_MIN ESP_HOSTED_SDIO_RESET_SLAVE_GPIO_MAX + default 53 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 54 if IDF_TARGET_ESP32P4 + default 42 if IDF_TARGET_ESP32S3 + default 5 if IDF_TARGET_ESP32 + help + GPIO pin for Resetting ESP SDIO slave device. Should be connected to RST/EN of ESP SDIO slave device. + +### *END* GPIO SDIO pin configurations for Slot 0 and 1 + + config ESP_HOSTED_SDIO_PIN_CMD + int + default ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + + config ESP_HOSTED_SDIO_PIN_CLK + int + default ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + + config ESP_HOSTED_SDIO_PIN_D0 + int + default ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + + if ESP_HOSTED_SDIO_4_BIT_BUS + config ESP_HOSTED_SDIO_PRIV_PIN_D1_4BIT_BUS + int + default ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + + config ESP_HOSTED_SDIO_PIN_D2 + int + default ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + + config ESP_HOSTED_SDIO_PIN_D3 + int + default ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + endif + + if !ESP_HOSTED_SDIO_4_BIT_BUS + config ESP_HOSTED_SDIO_PRIV_PIN_D1_1BIT_BUS + int + default ESP_HOSTED_PRIV_SDIO_PIN_D1_1BIT_BUS_SLOT_0 if ESP_HOSTED_SDIO_SLOT_0 + default ESP_HOSTED_PRIV_SDIO_PIN_D1_1BIT_BUS_SLOT_1 if ESP_HOSTED_SDIO_SLOT_1 + endif + + config ESP_HOSTED_SDIO_PIN_D1 + int + default ESP_HOSTED_SDIO_PRIV_PIN_D1_4BIT_BUS if ESP_HOSTED_SDIO_4_BIT_BUS + default ESP_HOSTED_SDIO_PRIV_PIN_D1_1BIT_BUS if !ESP_HOSTED_SDIO_4_BIT_BUS + + config ESP_HOSTED_SDIO_TX_Q_SIZE + int "Host SDIO Tx queue size" + default 20 + help + Very small tx queue will lower data rate + + config ESP_HOSTED_SDIO_RX_Q_SIZE + int "Host SDIO Rx queue size" + default 20 + help + Very small RX queue will lower data rate + + config ESP_HOSTED_SDIO_CHECKSUM + bool "SDIO checksum ENABLE/DISABLE" + help + ENABLE/DISABLE software SDIO checksum + endmenu + + menu "SPI Half-duplex Configuration" + depends on ESP_HOSTED_SPI_HD_HOST_INTERFACE + + config ESP_HOSTED_SPI_HD_MODE + int "SPI Mode to use" + default 3 + range 0 3 + help + SPI Mode to use. The same mode must be used on both host and slave. + + choice ESP_HOSTED_SPI_HD_PRIV_INTERFACE_NUM_DATA_LINES + bool "Num Data Lines to use" + default ESP_HOSTED_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + help + Number of Data Lines to use in the SPI HD interface + + config ESP_HOSTED_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + bool "4 data lines" + + config ESP_HOSTED_SPI_HD_PRIV_INTERFACE_2_DATA_LINES + bool "2 data lines" + endchoice + + config ESP_HOSTED_SPI_HD_INTERFACE_NUM_DATA_LINES + int + default 4 if ESP_HOSTED_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + default 2 if ESP_HOSTED_SPI_HD_PRIV_INTERFACE_2_DATA_LINES + + choice ESP_HOSTED_SPI_HD_RESET_GPIO_CONFIG + bool "RESET GPIO Config" + default ESP_HOSTED_SPI_HD_RESET_ACTIVE_HIGH + help + "If Active High, High->Low->High will trigger reset (Low will trigger reset) + If Active Low, Low->High->Low will trigger reset (High will trigger reset)" + + config ESP_HOSTED_SPI_HD_RESET_ACTIVE_HIGH + bool "RESET: Active High" + config ESP_HOSTED_SPI_HD_RESET_ACTIVE_LOW + bool "RESET: Active Low" + endchoice + + choice ESP_HOSTED_SPI_HD_DATAREADY_GPIO_CONFIG + bool "DataReady GPIO Config" + default ESP_HOSTED_SPI_HD_DR_ACTIVE_HIGH + + config ESP_HOSTED_SPI_HD_DR_ACTIVE_HIGH + bool "DR: Active High" + config ESP_HOSTED_SPI_HD_DR_ACTIVE_LOW + bool "DR: Active Low" + endchoice + + menu "Host GPIOs Config" + config ESP_HOSTED_SPI_HD_GPIO_CS + int "GPIO pin for Host CS" + default 10 if IDF_TARGET_ESP32S3 + default 4 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 19 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 1 if IDF_TARGET_ESP32H2 + default 15 + help + SPI Half-duplex controller Host CS + + config ESP_HOSTED_SPI_HD_GPIO_CLK + int "GPIO pin for Host CLK" + default 12 if IDF_TARGET_ESP32S3 + default 33 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 18 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 4 if IDF_TARGET_ESP32H2 + default 18 + help + SPI Half-duplex controller Host CLK + + config ESP_HOSTED_SPI_HD_GPIO_D0 + int "GPIO pin for Host D0" + default 11 if IDF_TARGET_ESP32S3 + default 23 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 14 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 5 if IDF_TARGET_ESP32H2 + default 2 + help + SPI Half-duplex controller Host D0 + + config ESP_HOSTED_SPI_HD_GPIO_D1 + int "GPIO pin for Host D1" + default 13 if IDF_TARGET_ESP32S3 + default 22 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 15 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 0 if IDF_TARGET_ESP32H2 + default 4 + help + SPI Half-duplex controller Host D1 + + config ESP_HOSTED_SPI_HD_GPIO_D2 + depends on ESP_HOSTED_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + int "GPIO pin for Host D2" + default 14 if IDF_TARGET_ESP32S3 + default 20 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 16 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 2 if IDF_TARGET_ESP32H2 + default 12 + help + SPI Half-duplex controller Host D2 + + config ESP_HOSTED_SPI_HD_GPIO_D3 + depends on ESP_HOSTED_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + int "GPIO pin for Host D3" + default 9 if IDF_TARGET_ESP32S3 + default 21 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 17 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 3 if IDF_TARGET_ESP32H2 + default 13 + help + SPI Half-duplex controller Host D3 + + config ESP_HOSTED_SPI_HD_GPIO_DATA_READY + int "GPIO pin for data ready interrupt" + default 4 if IDF_TARGET_ESP32S3 + default 32 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 6 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 12 if IDF_TARGET_ESP32H2 + default 8 + help + GPIO pin for indicating host that slave has data to be read by host + + config ESP_HOSTED_SPI_HD_GPIO_RESET_SLAVE + int "GPIO pin for Reseting slave ESP" + default 5 if IDF_TARGET_ESP32S3 + default 53 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C5 + default 54 if IDF_TARGET_ESP32P4 && SLAVE_IDF_TARGET_ESP32C6 + default 10 if IDF_TARGET_ESP32H2 + default 5 + help + GPIO pin for Resetting ESP slave device. Should be connected to RST/EN of ESP SPI slave device. + endmenu + +ESP32XX_SPI_HD_CLK_FREQ_RANGE_MIN := 1 +ESP32_SPI_HD_CLK_FREQ_RANGE_MAX := 10 +ESP32C6_SPI_HD_CLK_FREQ_RANGE_MAX := 40 +ESP32XX_SPI_HD_CLK_FREQ_RANGE_MAX := 40 + + config ESP_HOSTED_SPI_HD_FREQ_ESP32C6 + depends on SLAVE_IDF_TARGET_ESP32C6 + int "SPI HD Clock Freq (MHz)" + default 40 if IDF_TARGET_ESP32P4 #config for ESP32-P4 Function_EV_Board + default 10 + range $(ESP32XX_SPI_HD_CLK_FREQ_RANGE_MIN) $(ESP32C6_SPI_HD_CLK_FREQ_RANGE_MAX) + help + "Optimize CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_HD_FREQ_ESP32XX + depends on SLAVE_IDF_TARGET_ESP32C2 || SLAVE_IDF_TARGET_ESP32C3 || SLAVE_IDF_TARGET_ESP32S2 || SLAVE_IDF_TARGET_ESP32S3 || SLAVE_IDF_TARGET_ESP32C5 + int "SPI HD Clock Freq (MHz)" + default 40 if SLAVE_IDF_TARGET_ESP32C2 || SLAVE_IDF_TARGET_ESP32C3 || SLAVE_IDF_TARGET_ESP32S2 || SLAVE_IDF_TARGET_ESP32S3 || SLAVE_IDF_TARGET_ESP32C5 + range $(ESP32XX_SPI_HD_CLK_FREQ_RANGE_MIN) $(ESP32XX_SPI_HD_CLK_FREQ_RANGE_MAX) + help + "Optimize CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_HD_CLK_FREQ + int + default ESP_HOSTED_SPI_HD_FREQ_ESP32C6 if SLAVE_IDF_TARGET_ESP32C6 + default ESP_HOSTED_SPI_HD_FREQ_ESP32XX if SLAVE_IDF_TARGET_ESP32C2 || SLAVE_IDF_TARGET_ESP32C3 || SLAVE_IDF_TARGET_ESP32S2 || SLAVE_IDF_TARGET_ESP32S3 || SLAVE_IDF_TARGET_ESP32C5 + help + "Optimize CLK by increasing till host practically can support" + + config ESP_HOSTED_SPI_HD_TX_Q_SIZE + int "ESP to Host queue size" + default 20 + help + Very small tx queue will lower ESP -- SPI Half-duplex --> Host data rate + + config ESP_HOSTED_SPI_HD_RX_Q_SIZE + int "Host to ESP queue size" + default 20 + help + Very small RX queue will lower ESP <-- SPI Half-duplex -- Host data rate + + config ESP_HOSTED_SPI_HD_CHECKSUM + bool "Checksum ENABLE/DISABLE" + default y + help + ENABLE/DISABLE software checksum + endmenu + + menu "UART Configuration" + depends on ESP_HOSTED_UART_HOST_INTERFACE + + choice ESP_HOSTED_UART_RESET_GPIO_CONFIG + bool "RESET GPIO Config" + default ESP_HOSTED_UART_RESET_ACTIVE_HIGH + help + "If Active High, High->Low->High will trigger reset (Low will trigger reset) + If Active Low, Low->High->Low will trigger reset (High will trigger reset)" + + config ESP_HOSTED_UART_RESET_ACTIVE_HIGH + bool "RESET: Active High" + config ESP_HOSTED_UART_RESET_ACTIVE_LOW + bool "RESET: Active Low" + endchoice + + config ESP_HOSTED_UART_PORT + int "UART Port to Use" + default 1 + range 0 2 if IDF_TARGET_ESP32 + range 0 1 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32C5 || IDF_TARGET_ESP32C6 + range 0 2 if IDF_TARGET_ESP32C61 + range 0 1 if IDF_TARGET_ESP32S2 + range 0 2 if IDF_TARGET_ESP32S3 + range 0 4 if IDF_TARGET_ESP32P4 + help + Select UART Port to Use. Do not select the UART Port used for console output (if enabled) + + config ESP_HOSTED_UART_PIN_TX + int "TX GPIO number" + default 13 if IDF_TARGET_ESP32 + default 5 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 + default 14 if IDF_TARGET_ESP32C5 + default 21 if IDF_TARGET_ESP32C6 + default 5 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 14 if IDF_TARGET_ESP32P4 + help + GPIO used for UART TX + + config ESP_HOSTED_UART_PIN_RX + int "RX GPIO number" + default 12 if IDF_TARGET_ESP32 + default 4 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 + default 13 if IDF_TARGET_ESP32C5 + default 20 if IDF_TARGET_ESP32C6 + default 4 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 15 if IDF_TARGET_ESP32P4 + help + GPIO used for UART RX + + config ESP_HOSTED_UART_BAUDRATE + int "Baud Rate" + default 921600 + range 9600 3500000 + help + Baud Rate to Use. Make sure Hardware supports the rate. Standard rates are 9600, 19200, 38400, 57600, 115200, 460800, 921600 + + config ESP_HOSTED_UART_NUM_DATA_BITS + int "Number of Data Bits" + default 8 + range 5 8 + help + Number of Data Bits to use + + choice ESP_HOSTED_UART_PRIV_PARITY + bool "Parity" + + config ESP_HOSTED_UART_PRIV_PARITY_NONE + bool "None" + + config ESP_HOSTED_UART_PRIV_PARITY_EVEN + bool "Even" + + config ESP_HOSTED_UART_PRIV_PARITY_ODD + bool "Odd" + endchoice + + config ESP_HOSTED_UART_PARITY + int + default 0 if ESP_HOSTED_UART_PRIV_PARITY_NONE + default 1 if ESP_HOSTED_UART_PRIV_PARITY_EVEN + default 2 if ESP_HOSTED_UART_PRIV_PARITY_ODD + + choice ESP_HOSTED_UART_PRIV_STOP_BITS + bool "Number of Stop Bits" + + config ESP_HOSTED_UART_PRIV_STOP_BITS_1 + bool "1" + + config ESP_HOSTED_UART_PRIV_STOP_BITS_1_5 + bool "1.5" + + config ESP_HOSTED_UART_PRIV_STOP_BITS_2 + bool "2" + endchoice + + config ESP_HOSTED_UART_STOP_BITS + int + default 0 if ESP_HOSTED_UART_PRIV_STOP_BITS_1 + default 1 if ESP_HOSTED_UART_PRIV_STOP_BITS_1_5 + default 2 if ESP_HOSTED_UART_PRIV_STOP_BITS_2 + + config ESP_HOSTED_UART_GPIO_RESET_SLAVE + int "GPIO pin for Reseting slave ESP" + default 54 if IDF_TARGET_ESP32P4 + default 42 if IDF_TARGET_ESP32S3 + default 5 + help + GPIO pin for Resetting ESP SDIO slave device. Should be connected to RST/EN of ESP SDIO slave device. + + config ESP_HOSTED_UART_TX_Q_SIZE + int "Tx Queue Size" + default 5 + help + UART rates are low, so large queue sizes are not required + + config ESP_HOSTED_UART_RX_Q_SIZE + int "Rx Queue Size" + default 5 + help + UART rates are low, so large queue sizes are not required + + config ESP_HOSTED_UART_CHECKSUM + bool "UART checksum ENABLE/DISABLE" + default y + help + ENABLE/DISABLE software UART checksum + endmenu + + config ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE + int + default ESP_HOSTED_SPI_GPIO_RESET_SLAVE if ESP_HOSTED_SPI_HOST_INTERFACE + default ESP_HOSTED_SDIO_GPIO_RESET_SLAVE if ESP_HOSTED_SDIO_HOST_INTERFACE + default ESP_HOSTED_SPI_HD_GPIO_RESET_SLAVE if ESP_HOSTED_SPI_HD_HOST_INTERFACE + default ESP_HOSTED_UART_GPIO_RESET_SLAVE if ESP_HOSTED_UART_HOST_INTERFACE + + config ESP_HOSTED_RESET_GPIO_ACTIVE_LOW + bool + default n if ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH || ESP_HOSTED_SPI_RESET_ACTIVE_HIGH || ESP_HOSTED_SPI_HD_RESET_ACTIVE_HIGH || ESP_HOSTED_UART_RESET_ACTIVE_HIGH + default y if ESP_HOSTED_SDIO_RESET_ACTIVE_LOW || ESP_HOSTED_SPI_RESET_ACTIVE_LOW || ESP_HOSTED_SPI_HD_RESET_ACTIVE_LOW || ESP_HOSTED_UART_RESET_ACTIVE_LOW + + menu "Bluetooth Support" + + comment "Following options must be set before this option can be enabled" + depends on !BT_ENABLED || BT_CONTROLLER_ONLY || (BT_NIMBLE_ENABLED && (BT_NIMBLE_TRANSPORT_UART || BT_CONTROLLER_ENABLED)) || (BT_BLUEDROID_ENABLED && BT_CONTROLLER_ENABLED) + + comment "'Component config->Bluetooth' must be enabled" + depends on !BT_ENABLED + + comment "'Component config->Bluetooth->Host' must be enabled" + depends on BT_ENABLED && BT_CONTROLLER_ONLY + + comment "'Component config->Bluetooth->Controller' must be disabled" + depends on BT_ENABLED && BT_CONTROLLER_ENABLED + + comment "'Component config->Bluetooth->NimBLE Options->Host-controller Transport->Uart Transport' must be disabled" + depends on BT_NIMBLE_ENABLED && BT_NIMBLE_TRANSPORT_UART + + if BT_ENABLED && BT_BLUEDROID_ENABLED && !BT_CONTROLLER_ENABLED + config ESP_HOSTED_ENABLE_BT_BLUEDROID + bool "Enable Hosted Bluedroid Bluetooth support" + default n + help + Enable Bluetooth Support for Bluedroid via Hosted + + choice ESP_HOSTED_BLUEDROID_HCI_TYPE + bool "BT Bluedroid HCI Type" + default ESP_HOSTED_BLUEDROID_HCI_VHCI + depends on ESP_HOSTED_ENABLE_BT_BLUEDROID + help + Selects the HCI to use + + config ESP_HOSTED_BLUEDROID_HCI_VHCI + bool "VHCI" + help + Bluetooth data is sent through the selected transport layer + endchoice + endif + + if BT_ENABLED && BT_NIMBLE_ENABLED && !BT_CONTROLLER_ENABLED && !BT_NIMBLE_TRANSPORT_UART + config ESP_HOSTED_ENABLE_BT_NIMBLE + bool "Enable Hosted Nimble Bluetooth support" + default n + help + Enable Bluetooth Support via Hosted + + choice ESP_HOSTED_NIMBLE_HCI_TYPE + bool "BT Nimble HCI Type" + default ESP_HOSTED_NIMBLE_HCI_VHCI + depends on ESP_HOSTED_ENABLE_BT_NIMBLE + help + Selects the HCI to use + + config ESP_HOSTED_NIMBLE_HCI_VHCI + bool "VHCI" + help + Bluetooth data is sent through the selected transport layer + endchoice + endif + endmenu + + menu "Task defaults" + config ESP_HOSTED_RPC_TASK_STACK + int "RPC task stack size" + default 4096 + + config ESP_HOSTED_DFLT_TASK_STACK + int "Hosted default task size" + default 3072 + endmenu + + config ESP_HOSTED_USE_MEMPOOL + bool "Cache allocated memory like mempool - helps to reduce malloc calls" + default y + help + Cache allocated memory - reduces number of malloc calls + + config ESP_HOSTED_MAX_SIMULTANEOUS_SYNC_RPC_REQUESTS + int "Maximum number of simultaneous synchronous RPC Request" + default 5 + help + Sets the maximum number of simultaneous synchronous RPC Requests. + (Synchronous RPC Request: each sending task waits for the response.) + Usually, the host application may send up to 3 simultaneous RPC requests to the slave. + Increase this number if you need to send more simultaneous RPC requests. + Note: the slave will only process one RPC request (sync and async) at a time + + config ESP_HOSTED_MAX_SIMULTANEOUS_ASYNC_RPC_REQUESTS + int "Maximum number of simultaneous asynchronous RPC Request" + default 5 + help + Sets the maximum number of simultaneous asynchronous RPC Requests. + (Asynchronous RPC Request: each sending task registers a callback to get the response.) + Usually, the host application may send up to 3 simultaneous RPC requests to the slave. + Increase this number if you need to send more simultaneous RPC requests. + Note: the slave will only process one RPC request (sync and async) at a time + + menu "Debug Settings" + + config ESP_HOSTED_RAW_THROUGHPUT_TRANSPORT + bool "RawTP: Transport level throughput debug test" + default n + help + Find max transport performance which helps to assess stability of porting done + + choice ESP_HOSTED_RAW_THROUGHPUT_DIRECTION + bool "RawTP: Send data from:" + depends on ESP_HOSTED_RAW_THROUGHPUT_TRANSPORT + + config ESP_HOSTED_RAW_THROUGHPUT_TX_TO_SLAVE + bool "Host to Slave" + help + Sends data from Host to Slave + + config ESP_HOSTED_RAW_THROUGHPUT_RX_FROM_SLAVE + bool "Slave to Host" + help + Sends data from Slave to Slave + + config ESP_HOSTED_RAW_THROUGHPUT_BIDIRECTIONAL + bool "Bidirectional" + help + Sends data in both directions + endchoice + + config ESP_HOSTED_RAW_TP_HOST_TO_ESP_PKT_LEN + depends on ESP_HOSTED_RAW_THROUGHPUT_TRANSPORT + int "RawTP: Host to ESP packet size" + range 1 1500 + default 1460 + + config ESP_HOSTED_RAW_TP_REPORT_INTERVAL + depends on ESP_HOSTED_RAW_THROUGHPUT_TRANSPORT + int "RawTP: periodic duration to report stats accumulated" + default 5 + + config ESP_HOSTED_PKT_STATS + bool "Transport level packet stats" + default n + help + On comparing with slave packet stats helps to understand any packet loss at hosted + + endmenu + + menu "Data path options" + config ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE + bool "Report WiFi queue utilization to host" + default y + help + Proactively drop Host->slave Wi-Fi data when Slave Wi-Fi is under load + Slave Wi-Fi may drop ingress bursty or higher than capacity packets. + To have synchronous way of packet dropped for application, + Host will throttle incoming data if the slave datapath Rx load is high + + config ESP_HOSTED_PRIV_WIFI_TX_SPI_HIGH_THRESHOLD + depends on ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE && ESP_HOSTED_SPI_HOST_INTERFACE + int "High threshold to report host to drop data when wifi highly loaded" + range 0 100 + default 90 + help + Host will throttle incoming data if the slave datapath Rx load goes beyond this threshold + 0 value will disable this function + + config ESP_HOSTED_PRIV_WIFI_TX_SDIO_HIGH_THRESHOLD + depends on ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE && ESP_HOSTED_SDIO_HOST_INTERFACE + int "High threshold to report host to drop data when wifi highly loaded" + range 0 100 + default 80 + help + Host will throttle incoming data if the slave datapath Rx load goes beyond this threshold + 0 value will disable this function + + config ESP_HOSTED_PRIV_WIFI_TX_SPI_HD_HIGH_THRESHOLD + depends on ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE && ESP_HOSTED_SPI_HD_HOST_INTERFACE + int "High threshold to report host to drop data when wifi highly loaded" + range 0 100 + default 80 + help + Host will throttle incoming data if the slave datapath Rx load goes beyond this threshold + 0 value will disable this function + + config ESP_HOSTED_PRIV_WIFI_TX_UART_HIGH_THRESHOLD + depends on ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE && ESP_HOSTED_UART_HOST_INTERFACE + int "High threshold to report host to drop data when wifi highly loaded" + range 0 100 + default 80 + help + Host will throttle incoming data if the slave datapath Rx load goes beyond this threshold + 0 value will disable this function + + config ESP_HOSTED_TO_WIFI_DATA_THROTTLE_HIGH_THRESHOLD + depends on ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE + int + default ESP_HOSTED_PRIV_WIFI_TX_SPI_HIGH_THRESHOLD if ESP_HOSTED_SPI_HOST_INTERFACE + default ESP_HOSTED_PRIV_WIFI_TX_SDIO_HIGH_THRESHOLD if ESP_HOSTED_SDIO_HOST_INTERFACE + default ESP_HOSTED_PRIV_WIFI_TX_SPI_HD_HIGH_THRESHOLD if ESP_HOSTED_SPI_HD_HOST_INTERFACE + default ESP_HOSTED_PRIV_WIFI_TX_UART_HIGH_THRESHOLD if ESP_HOSTED_UART_HOST_INTERFACE + + config ESP_HOSTED_TO_WIFI_DATA_THROTTLE_LOW_THRESHOLD + depends on ESP_HOSTED_HOST_TO_ESP_WIFI_DATA_THROTTLE + int "Low threshold to report host to stop dropping data" + range 0 ESP_HOSTED_TO_WIFI_DATA_THROTTLE_HIGH_THRESHOLD + default 60 + help + Once the Wi-Fi is no more stressed, data throttling would be stopped, once slave Wi-Fi load + is lower than this threshold + endmenu + + config ESP_HOSTED_DECODE_WIFI_RESERVED_FIELD + bool "Copy Wi-Fi configuration reserved field values" + default n + help + ESP-IDF Wi-Fi structures contain reserved bitmask values. + Enable this option if you want to copy these values between host and co-processor. + It is usually safe to ignore these reserved values. + +endmenu diff --git a/resources/espressif__esp_hosted/LICENSE b/resources/espressif__esp_hosted/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/resources/espressif__esp_hosted/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/resources/espressif__esp_hosted/README.md b/resources/espressif__esp_hosted/README.md new file mode 100644 index 0000000..72695cd --- /dev/null +++ b/resources/espressif__esp_hosted/README.md @@ -0,0 +1,280 @@ +# ESP-Hosted-MCU: Espressif SoCs as Communication Co-Processors + +[![Component Registry](https://components.espressif.com/components/espressif/esp_hosted/badge.svg)](https://components.espressif.com/components/espressif/esp_hosted) + +## 1 Introduction + +ESP-Hosted-MCU is an open-source solution that allows you to use Espressif Chipsets and modules as a communication co-processor. This solution provides wireless connectivity (Wi-Fi and Bluetooth) to the host microprocessor or microcontroller, enabling it to communicate with other devices. Additionally, the user has complete control over the co-processor's resources. + +This high-level block diagram shows ESP-Hosted's relationship with the host MCU and slave co-processor. + +ESP-Hosted + +For detailed design diagrams in Wi-Fi and Bluetooth, refer to the following design documents: + +- [WiFi Design](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/wifi_design.md) +- [Bluetooth Design](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/bluetooth_design.md) + +`esp-hosted-mcu` is dedicated for any host as MCU support. If you are interested in Linux as host, please refer to the [`esp-hosted`](https://github.com/espressif/esp-hosted) repository. + +## 2 Architecture + +##### Hosted Co-Processor +This is an ESP chip that provides Wi-Fi, Bluetooth, and other capabilities. It is also referred as `hosted-slave` interchangeably. + +##### Host MCU +This can be any generic microcontroller (MCU). We demonstrate any ESP as host. Using port layer, any host can act as host MCU. + +##### Communication +- Host extends the capabilities of the Hosted co-processor through Remote Procedure Calls (RPCs). The Host MCU sends these RPC commands to the Hosted co-processor using a reliable communication bus, like SPI, SDIO, or UART. The Hosted co-processor then handles the RPC and provides the requested functionality to the Host MCU. +- The data (network or Bluetooth) is packaged efficiently at the transport layer to minimize overhead and delays when passing between the Host and co-processor. +- This modular design allows any MCU to be used as the Host, and any ESP chip with Wi-Fi and/or Bluetooth to be used as the Hosted co-processor. The RPC calls can also be extended to provide any function required by the Host, as long as the co-processor can support it. + +## 3 Solution Flexibility + +- **Any MCU can be the host** + - You can evaluate ESP as an example host and then port ESP-Hosted to your desired MCU. +- **Any ESP chip can be the co-processor** + - Any Wi-Fi and/or Bluetooth capable ESP chipset can be chosen as co-processor + - Choose the co-processor device based on your product requirements. The [ESP Product Selector](https://www.espressif.com/en/products/socs) can help in this. +- **Flexible transport layer (SDIO, SPI, UART)** + - ESP-Hosted supports various communication interfaces between the host and the co-processor, allowing you to choose the most suitable one for your application. + - Any other new transport also could be added to the open source code +- **Complete control over co-processor's resources** + - The user is not limited to just using the co-processor for wireless connectivity. They have complete control over the co-processor's resources, allowing for a more flexible and powerful system. +- **Extensible RPC library** + - The Remote Procedure Call (RPC) used by ESP-Hosted can be extended to provide any function required by the Host, as long as the co-processor can support it. Currently, the essential [ESP-IDF](https://github.com/espressif/esp-idf) Wi-Fi functions have been implemented. + +## 4 Quick Demo with ESP32-P4-Function-EV-Board + +Impatient to test? We've got you covered! +The [ESP32-P4-Function-EV-Board](https://www.espressif.com/en/products/socs/esp32-p4) can be used as a host MCU with an on-board [ESP32-C6](https://www.espressif.com/en/products/socs/esp32-c6) as co-processor, already connected via SDIO as transport. +Prerequisite: You need to have an ESP32-P4-Function-EV-Board` + +> [!NOTE] +> If you have already set up ESP-IDF (version 5.3 or later), you can skip to [5 Source Code and Dependencies](#5-source-code-and-dependencies). + +### 4.1 Set-Up ESP-IDF + +- Windows + - Install and setup ESP-IDF on Windows as documented in the [Standard Setup of Toolchain for Windows](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/windows-setup.html). + - Use the ESP-IDF [Powershell Command Prompt](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/windows-setup.html#using-the-command-prompt) to move to expected + +- Linux or MacOS + - bash +```bash +bash docs/setup_esp_idf__latest_stable__linux_macos.sh +``` + - fish +```fish +fish docs/setup_esp_idf__latest_stable__linux_macos.fish +``` + +### 4.2 Set-Up P4 with C6 +The host, ESP32-P4, lacks native Wi-Fi/Bluetooth support. Our [Quick Demo](docs/esp32_p4_function_ev_board.md) will help you run iperf over P4--SDIO--C6. + +### 4.3 Don't Have ESP32-P4-Function-EV-Board? + +No worries if you don't have an ESP32-P4. In fact, most users don't. You can choose and use any two ESP chipsets/SoCs/Modules/DevKits. DevKits are convenient to use as they have GPIO headers already in place. From these two ESP chipsets, one would act as host and another as slave/co-processor. However, as these are not connected directly, you would need to manually connect some transport, which is explained later in the section [`Detailed Setup`](#7-detailed-setup). + +## 5 Source Code and Dependencies + +### 5.1 ESP-Hosted-MCU Source Code + +- ESP-Hosted-MCU code can be found at Espressif Registry Component [`esp_hosted` (ESP-Hosted)](https://components.espressif.com/components/espressif/esp_hosted) or GitHub repo at [`esp-hosted-mcu`](https://github.com/espressif/esp-hosted-mcu/) + +- ESP-Hosted repo clone is **not** required if you have ESP as host. + - Reason: [ESP component manager](https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/tools/idf-component-manager.html) automatically clones esp-hosted component while building. +- However, For non-ESP host development, you can clone the repo using command: +```bash +git clone --recurse-submodules --depth 1 https://github.com/espressif/esp-hosted-mcu.git +``` + +### 5.2 Dependencies + +ESP-Hosted-MCU Solution is dependent on `ESP-IDF`, `esp_wifi_remote` and `protobuf-c` + +###### ESP-IDF + - [`ESP-IDF`](https://github.com/espressif/esp-idf) is the development framework for Espressif SoCs supported on Windows, Linux and macOS + - ESP-Hosted-MCU solution is based on ESP-IDF as base software. ESP chipsets as host and slave always tried to design such a way that ESP-IDF components are re-used. + - Although, We totally understand, host MCUs in case of non-ESP chipset may not desire to be dependent on ESP-IDF. The port layer is written to avoid suc dependencies. Some crucial ESP-IDF components could also be just copy-pasted to fast-track the non-ESP host development. + +###### Wi-Fi Remote + - [`esp_wifi_remote`](https://components.espressif.com/components/espressif/esp_wifi_remote) i.e. 'Wi-Fi Remote' is very thin interface made up of ESP-IDF Wi-Fi APIs with empty weak definitions. Real definitions for these APIs are provided by ESP-Hosted-MCU + - Wi-Fi Remote Code can be found at either [GitHub Repo](https://github.com/espressif/esp-wifi-remote/) or [Espressif Registry Component](https://components.espressif.com/components/espressif/esp_wifi_remote) + +###### Protobuf + - [`protobuf-c`](https://github.com/protobuf-c/protobuf-c) is data serialization framework provided by Google. RPC messages communicated in host and slave are protobuf encoded. + - It helps to avoid manual serialization or endien-ness conversion. + - Provides Flexibility for users to port the ESP-Hosted-MCU RPC framework in any protobuf supported programming language + - Code is checked-out as submodule at `common/protobuf-c` + +##### 5.2.1 How Dependencies Work Together (short explanation) +- RPC Request - Response + - Wi-Fi Remote is an API layer or interface that provides the standard ESP-IDF Wi-Fi calls to the application (`esp_wifi_init()`, etc.) + - Wi-Fi Remote forwards the Wi-Fi calls to ESP-Hosted, as ESP-Hosted 'implements' tha APIs provided by Wi-Fi Remote interface. + - ESP-Hosted host MCU creates RPC requests which are protobuf encoded and sends over the transport (SPI/SDIO etc) to the slave. + - Slave de-serialize the protobuf RPC request and response send back to host over transport, again with protobuf serialised. + - Responses received at transport returned to Wi-Fi Remote, which returns the reponses to the calling app at host + - To the app, it is as if it made a standard ESP-IDF Wi-Fi API call. +- RPC Event + - Asynchronous Wi-Fi events when subscribed, are sent by slave to host. + - These events terminate in standard ESP-IDF event loop on the host +- Please note, Only RPC i.e. control packets are serialised. Data Packets are never serialised as they do not need endien conversion. + +## 6 Decide the communication bus in between host and slave + +The communication bus is required to be setup correctly between host and slave. +We refer this as `transport medium` or simply `transport`. + +ESP-Hosted-MCU supports SPI/SDIO/UART transports. User can choose which transport to use. Choosing specific transport depends on factors: high performance, easy and quick to test, number of GPIOs used, or simply co-processor preference + +Below is chart for the transport medium comparison. + +Legends: + +- `FD` : Full duplex communication +- `HD` : Half duplex communication +- `BT` : Bluetooth +- `+2` in column `Num of GPIOs` + - There are two GPIOs additional applicable for all the transports + - (1) Co-Processor reset: Host needs one additional pin to connect to `RST`/`EN` pin of co-processor, to reset on bootup + - (2) Ground: Grounds of both chipsets need to be connected. + - If you use jumper cable connections, connect as many grounds as possible in between two boards for better noise cancellation. +- `Any_Slave` + - Co-processor suppored: ESP32, ESP32-C2, ESP32-C3, ESP32-C5, ESP32-C6, ESP32-S2, ESP32-S3 + - Classic ESP32 supports 'Classic BT', 'BLE 4.2' & 'BTDM' + - Rest all chipsets support BLE only. BLE version supported is 5.0+. Exact bluetooth versions could be refered from [ESP Product Selector Page](https://products.espressif.com/#/product-selector) +- `Dedicated platforms` + - Bluetooth uses dedicated platform, UART and Wi-Fi uses any other base transport + - In other platforms, Bluetooth and Wi-Fi re-use same platform and hence use less GPIOs and less complicated + - This transport combination allows Bluetooth to use dedicated uart transportt with additional 2 or 4 depending on hardware flow control. +- (S) : Shield box reading +- (O) : Over the air reading +- TBD : To be determined +- iperf : iperf2 with test resukts in mbps + +> [!NOTE] +> +> For the shield box readings maked with (S), full network set up explained in [Shield Box Test Setup](shield-box-test-setup.md) + +**Host can be any ESP chipset or any non-ESP MCU.** + +###### Hosted Transports table + +| Transport | Type | Num of GPIOs | Setup with | Co-processor supported | Host Tx iperf | Host Rx iperf | Remarks | +|:---------------:|:-----:|:------------:|:----------------:|:--------------:|:------------:|:-----------:|:--------------------------:| +| Standard SPI | FD | 6 | jumper or PCB | Any_Slave | udp: 24 tcp: 22 | udp: 25 tcp: 22| Simplest solution for quick test | +| Dual SPI | HD | 5 | jumper or PCB | Any_Slave [1] | udp: 32 tcp: 26 (O) | udp: 33 tcp: 25 (O) | Better throughput, but half duplex | +| Quad SPI | HD | 7 | PCB only | Any_Slave [1] | udp: 41 tcp: 29 (O) | udp: 42 tcp: 28 (O) | Due to signal integrity, PCB is mandatory | +| SDIO 1-Bit | HD | 4 | jumper or PCB | ESP32, ESP32-C6, ESP32-C5 [3] | TBD | TBD | Stepping stone for PCB based SDIO 4-bit | +| SDIO 4-Bit | HD | 6 | PCB only | ESP32, ESP32-C6, ESP32-C5 [3] | udp: 79.5 tcp: 53.4 (S) | udp: 68.1 tcp: 44 (S) | Highest performance | +| Only BT over UART | FD | 2 or 4 | jumper or PCB | Any_Slave | NA | NA | Dedicated Bluetooth over UART pins | +| UART | FD | 2 | jumper or PCB | Any_Slave | udp: 0.68 tcp: 0.67 (O) | udp: 0.68 tcp: 0.60 (O) | UART dedicated for BT & Wi-Fi [2] | +| Dedicated platforms | FD | Extra 2 or 4 | jumper or PCB | Any_Slave | NA | NA | UART dedicated for BT & Wi-Fi on any other transport | + +> [!NOTE] +> - [1] Dual/Quad SPI is not supported on ESP32 +> +> - [2] UART is only suitable for low throughput environments +> +> - [3] Currently in BETA support for ESP32-C5 (`--preview` in ESP-IDF master branch) + +With jumper cables, 'Standard SPI' and 'Dual SPI' solutions are easiest to evaluate, without much of hardware dependencies. SDIO 1-Bit can be tested with jumper cables, but it needs some additional hardware config, such as installation of external pull-up registers. + +In case case of dedicated platforms, Blutooth uses standard HCI over UART. In rest of cases, Bluetooth and Wi-Fi uses same transport and hence less GPIOs and less complicated. In shared mode, bluetooth runs as Hosted HCI (multiplexed mode) + +## 7 ESP-Hosted-MCU Header + +### 7.1 ESP Hosted header + +Host and slave always populate below header at the start of every frame, irrespective of actual or dummy data in payload. + +| Field | Type | Bits | Mandatory? | Description | +|----------------|----------|------|------------|-----------------------------------------------------------------------------| +| if_type | uint8_t | 4 | M | Interface type | +| if_num | uint8_t | 4 | M | Interface number | +| flags | uint8_t | 8 | M | Flags for additional information | +| len | uint16_t | 16 | M | Length of the payload | +| offset | uint16_t | 16 | M | Offset for the payload | +| checksum | uint16_t | 16 | M | Checksum for error detection (0 if checksum disabled) | +| seq_num | uint16_t | 16 | O | Sequence number for tracking packets (Useful in debugging) | +| throttle_cmd | uint8_t | 0 or 2 | O | Flow control command | +| reserved2 | uint8_t | 6 or 8 | M | Reserved bits | +| reserved3 | uint8_t | 8 | M | Reserved byte (union field) | +| hci\_pkt\_type or priv\_pkt\_type | uint8_t | 8 | M | Packet type for HCI interface (union field) | + +### 7.2 Interface Types + +Start of header states which type of frame is being carried. + +| Interface Type | Value | Description | +|----------------------|-------|--------------------------------------------------| +| ESP\_INVALID\_IF | 0 | Invalid interface | +| ESP\_STA\_IF | 1 | Station frame | +| ESP\_AP\_IF | 2 | SoftAP frame | +| ESP\_SERIAL\_IF | 3 | Control frame | +| ESP\_HCI\_IF | 4 | Bluetooth Hosted HCI frame | +| ESP\_PRIV\_IF | 5 | Private communication between slave and host | +| ESP\_TEST\_IF | 6 | Transport throughput test | +| ESP\_ETH\_IF | 7 | Invalid | +| ESP\_MAX\_IF | 8 | type mentioned in dummy or empty frame | + +## 8 Detailed Setup + +Once you decided the transport to use, this section should guide how to set this transport, with hardware connections, configurations and verification. Users can evaluate one transport first and then move to other. + +> [!IMPORTANT] +> +> [Design Considerations](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/design_consideration.md) that could be referred to, before you stick to any transport option. Referring to these consideration would help to get you faster to solution, make your design stable and less error-prone. + + +Irrespective of transport chosen, following steps are needed, which are step-wise explained in each transport. + +1. Set-up the hosted-transport +2. Slave Flashing + - Slave project creation + - Slave configuration + - Slave flashing + - Slave logs +3. Host flashing + - Host project integration with ESP-IDF example + - Host configuration + - Host flashing + - Host logs + +- [**Standard SPI (Full duplex)**](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/spi_full_duplex.md) + +- [**SPI - Dual / Quad Half Duplex**](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/spi_half_duplex.md) + +- [**SDIO (1-Bit / 4-Bit)**](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/sdio.md) + +- [**UART for Wi-Fi and Bluetooth**](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/uart.md) + +## 9 Examples +Check [examples](https://github.com/espressif/esp-hosted-mcu/tree/main/examples) directory for sample applications using ESP-Hosted. + - `examples/host_bluedroid_ble_compatibility_test` + - host BlueDroid Bluetooth example to test the Bluetooth compatibility and mobile phones + - `examples/host_bluedroid_bt_hid_mouse_device` + - host BlueDroid Bluetooth example to show how to implement a Bluetooth HID device using the APIs provided by Classic Bluetooth HID profile + - `examples/host_bluedroid_host_only` + - host BlueDroid Bluetooth example Bluetooth Host using ESP-Hosted as HCI IO to the BT Controller + - `examples/host_nimble_bleprph_host_only_vhci` + - host NimBLE Bluetooth example without needing extra GPIOs for HCI transport + +## 10 Troubleshooting + +If you encounter issues with using ESP-Hosted, see the following guide: + +- [Troubleshooting Guide](https://github.com/espressif/esp-hosted-mcu/blob/main/docs/troubleshooting.md) + +## 11 References + +- [ESP Product Selector Page](https://products.espressif.com) +- [ESP-IDF Get Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started) +- [ESP-IDF Wi-Fi API](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_wifi.html) +- [ESP-IDF Iperf Example](https://github.com/espressif/esp-idf/tree/master/examples/wifi/iperf) +- [ESP-IDF NimBLE](https://github.com/espressif/esp-nimble) +- [ESP Component Registry](https://components.espressif.com) +- [Registry Component: esp\_wifi\_remote](https://components.espressif.com/components/espressif/esp_wifi_remote) +- [Registry Component: esp\_hosted](https://components.espressif.com/components/espressif/esp_hosted) diff --git a/resources/espressif__esp_hosted/common/esp_hosted_header.h b/resources/espressif__esp_hosted/common/esp_hosted_header.h new file mode 100644 index 0000000..be13c3a --- /dev/null +++ b/resources/espressif__esp_hosted/common/esp_hosted_header.h @@ -0,0 +1,32 @@ +// Copyright 2025 Espressif Systems (Shanghai) PTE LTD +/* SPDX-License-Identifier: GPL-2.0-only OR Apache-2.0 */ + +#ifndef __ESP_HOSTED_HEADER__H +#define __ESP_HOSTED_HEADER__H + +struct esp_payload_header { + uint8_t if_type:4; + uint8_t if_num:4; + uint8_t flags; + uint16_t len; + uint16_t offset; + uint16_t checksum; + uint16_t seq_num; + uint8_t throttle_cmd:2; + uint8_t reserved2:6; + /* Position of union field has to always be last, + * this is required for hci_pkt_type */ + union { + uint8_t reserved3; + uint8_t hci_pkt_type; /* Packet type for HCI interface */ + uint8_t priv_pkt_type; /* Packet type for priv interface */ + }; + /* Do no add anything here */ +} __attribute__((packed)); + +/* ESP Payload Header Flags */ +#define MORE_FRAGMENT (1 << 0) + +#define H_ESP_PAYLOAD_HEADER_OFFSET sizeof(struct esp_payload_header) + +#endif diff --git a/resources/espressif__esp_hosted/common/esp_hosted_interface.h b/resources/espressif__esp_hosted/common/esp_hosted_interface.h new file mode 100644 index 0000000..7574a88 --- /dev/null +++ b/resources/espressif__esp_hosted/common/esp_hosted_interface.h @@ -0,0 +1,30 @@ +/* +* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD +* +* SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef __ESP_HOSTED_INTERFACE_H__ +#define __ESP_HOSTED_INTERFACE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + ESP_INVALID_IF, + ESP_STA_IF, + ESP_AP_IF, + ESP_SERIAL_IF, + ESP_HCI_IF, + ESP_PRIV_IF, + ESP_TEST_IF, + ESP_ETH_IF, + ESP_MAX_IF, +} esp_hosted_if_type_t; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/resources/espressif__esp_hosted/common/log/esp_hosted_log.h b/resources/espressif__esp_hosted/common/log/esp_hosted_log.h new file mode 100644 index 0000000..6ddc6cd --- /dev/null +++ b/resources/espressif__esp_hosted/common/log/esp_hosted_log.h @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef __ESP_HOSTED_LOG_H +#define __ESP_HOSTED_LOG_H +#include "esp_log.h" + +#define ESP_PRIV_HEXDUMP(tag1, tag2, buff, len, curr_level) \ + if ( LOG_LOCAL_LEVEL >= curr_level) { \ + ESP_LOG_LEVEL_LOCAL(curr_level, tag1, "%s: len[%d]", tag2, (int)len); \ + ESP_LOG_BUFFER_HEXDUMP(tag2, buff, len, curr_level); \ + } + +#define ESP_HEXLOGE(tag2, buff, len) ESP_PRIV_HEXDUMP(TAG, tag2, buff, len, ESP_LOG_ERROR) +#define ESP_HEXLOGW(tag2, buff, len) ESP_PRIV_HEXDUMP(TAG, tag2, buff, len, ESP_LOG_WARN) +#define ESP_HEXLOGI(tag2, buff, len) ESP_PRIV_HEXDUMP(TAG, tag2, buff, len, ESP_LOG_INFO) +#define ESP_HEXLOGD(tag2, buff, len) ESP_PRIV_HEXDUMP(TAG, tag2, buff, len, ESP_LOG_DEBUG) +#define ESP_HEXLOGV(tag2, buff, len) ESP_PRIV_HEXDUMP(TAG, tag2, buff, len, ESP_LOG_VERBOSE) + +#endif + diff --git a/resources/espressif__esp_hosted/common/proto/README.md b/resources/espressif__esp_hosted/common/proto/README.md new file mode 100644 index 0000000..57c0e94 --- /dev/null +++ b/resources/espressif__esp_hosted/common/proto/README.md @@ -0,0 +1,53 @@ +# About Proto Files + + +## Protobuf Submodule + +[protobuf-c](https://github.com/protobuf-c/protobuf-c) is open source code used as submodule in ESP-Hosted-FG in directory `../protobuf-c/` +If this directory is empty, please run +```sh +$ cd esp-hosted +$ git submodule update --init --recursive +``` + +## Files + +- `esp_hosted_rpc.proto` + - This is Ready-To-Use protobuf file which has messages for Request / Response / Events to communicate between Host and ESP + - User can add his own message field in `.proto` file and generate respective C files using 'protoc' + +- `esp_hosted_rpc.pb-c.c` & `esp_hosted_rpc.pb-c.h` + - Ready-To-Use Source Generated files using `esp_hosted_rpc.proto` + - These files also cached which was generated with current `esp_hosted_rpc.proto` file for easy use (No need to generate again) + - If any addition or modifications `esp_hosted_rpc.proto` done, these files need to be re-generated + + +## Generate esp_hosted_rpc.pb-c.c & esp_hosted_rpc.pb-c.h + +If you want to add or modify existing set of RPC procedures supported, you need to modify `esp_hosted_rpc.proto` as needed and build it to generate new set of `esp_hosted_rpc.pb-c.c` & `esp_hosted_rpc.pb-c.h`. +For this, third party software for protobuf C compiler is needed to be installed +- Debian/Ubuntu + - sudo apt install protobuf-c-compiler +- Mac OS + - brew install protobuf +- Windows + - check https://github.com/protobuf-c/protobuf-c + +`protoc-c` command should be available once installed. + +This software might only be needed on development environment, Once esp_hosted_rpc.pb-c.c & esp_hosted_rpc.pb-c.h files are generated, could also be uninstalled. + +##### Steps to generate +```sh +$ cd /common/proto +$ protoc-c esp_hosted_rpc.proto --c_out=. +``` + +## Add new RPC message +To send an new RPC request/response + +1. Add C function in `host/host_common/commands.c` +2. Create python binding in `host/linux/host_control/python_support/commands_map_py_to_c.py` and its python function in `host/linux/host_control/python_support/commands_lib.py`. +3. Add ESP side C function in `esp/esp_driver/network_adapter/main/slave_commands.c`, respective to python function, to handle added message field. + +User can test added functionality using `host/linux/host_control/python_support/test.py`. diff --git a/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.pb-c.c b/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.pb-c.c new file mode 100644 index 0000000..eb1a1e3 --- /dev/null +++ b/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.pb-c.c @@ -0,0 +1,17767 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: esp_hosted_rpc.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "esp_hosted_rpc.pb-c.h" +void wifi_init_config__init + (WifiInitConfig *message) +{ + static const WifiInitConfig init_value = WIFI_INIT_CONFIG__INIT; + *message = init_value; +} +size_t wifi_init_config__get_packed_size + (const WifiInitConfig *message) +{ + assert(message->base.descriptor == &wifi_init_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_init_config__pack + (const WifiInitConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_init_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_init_config__pack_to_buffer + (const WifiInitConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_init_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiInitConfig * + wifi_init_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiInitConfig *) + protobuf_c_message_unpack (&wifi_init_config__descriptor, + allocator, len, data); +} +void wifi_init_config__free_unpacked + (WifiInitConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_init_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_country__init + (WifiCountry *message) +{ + static const WifiCountry init_value = WIFI_COUNTRY__INIT; + *message = init_value; +} +size_t wifi_country__get_packed_size + (const WifiCountry *message) +{ + assert(message->base.descriptor == &wifi_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_country__pack + (const WifiCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_country__pack_to_buffer + (const WifiCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiCountry * + wifi_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiCountry *) + protobuf_c_message_unpack (&wifi_country__descriptor, + allocator, len, data); +} +void wifi_country__free_unpacked + (WifiCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_active_scan_time__init + (WifiActiveScanTime *message) +{ + static const WifiActiveScanTime init_value = WIFI_ACTIVE_SCAN_TIME__INIT; + *message = init_value; +} +size_t wifi_active_scan_time__get_packed_size + (const WifiActiveScanTime *message) +{ + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_active_scan_time__pack + (const WifiActiveScanTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_active_scan_time__pack_to_buffer + (const WifiActiveScanTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiActiveScanTime * + wifi_active_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiActiveScanTime *) + protobuf_c_message_unpack (&wifi_active_scan_time__descriptor, + allocator, len, data); +} +void wifi_active_scan_time__free_unpacked + (WifiActiveScanTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_time__init + (WifiScanTime *message) +{ + static const WifiScanTime init_value = WIFI_SCAN_TIME__INIT; + *message = init_value; +} +size_t wifi_scan_time__get_packed_size + (const WifiScanTime *message) +{ + assert(message->base.descriptor == &wifi_scan_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_time__pack + (const WifiScanTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_time__pack_to_buffer + (const WifiScanTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanTime * + wifi_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanTime *) + protobuf_c_message_unpack (&wifi_scan_time__descriptor, + allocator, len, data); +} +void wifi_scan_time__free_unpacked + (WifiScanTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_config__init + (WifiScanConfig *message) +{ + static const WifiScanConfig init_value = WIFI_SCAN_CONFIG__INIT; + *message = init_value; +} +size_t wifi_scan_config__get_packed_size + (const WifiScanConfig *message) +{ + assert(message->base.descriptor == &wifi_scan_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_config__pack + (const WifiScanConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_config__pack_to_buffer + (const WifiScanConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanConfig * + wifi_scan_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanConfig *) + protobuf_c_message_unpack (&wifi_scan_config__descriptor, + allocator, len, data); +} +void wifi_scan_config__free_unpacked + (WifiScanConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_he_ap_info__init + (WifiHeApInfo *message) +{ + static const WifiHeApInfo init_value = WIFI_HE_AP_INFO__INIT; + *message = init_value; +} +size_t wifi_he_ap_info__get_packed_size + (const WifiHeApInfo *message) +{ + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_he_ap_info__pack + (const WifiHeApInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_he_ap_info__pack_to_buffer + (const WifiHeApInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiHeApInfo * + wifi_he_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiHeApInfo *) + protobuf_c_message_unpack (&wifi_he_ap_info__descriptor, + allocator, len, data); +} +void wifi_he_ap_info__free_unpacked + (WifiHeApInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ap_record__init + (WifiApRecord *message) +{ + static const WifiApRecord init_value = WIFI_AP_RECORD__INIT; + *message = init_value; +} +size_t wifi_ap_record__get_packed_size + (const WifiApRecord *message) +{ + assert(message->base.descriptor == &wifi_ap_record__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ap_record__pack + (const WifiApRecord *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ap_record__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ap_record__pack_to_buffer + (const WifiApRecord *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ap_record__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiApRecord * + wifi_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiApRecord *) + protobuf_c_message_unpack (&wifi_ap_record__descriptor, + allocator, len, data); +} +void wifi_ap_record__free_unpacked + (WifiApRecord *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ap_record__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_threshold__init + (WifiScanThreshold *message) +{ + static const WifiScanThreshold init_value = WIFI_SCAN_THRESHOLD__INIT; + *message = init_value; +} +size_t wifi_scan_threshold__get_packed_size + (const WifiScanThreshold *message) +{ + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_threshold__pack + (const WifiScanThreshold *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_threshold__pack_to_buffer + (const WifiScanThreshold *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanThreshold * + wifi_scan_threshold__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanThreshold *) + protobuf_c_message_unpack (&wifi_scan_threshold__descriptor, + allocator, len, data); +} +void wifi_scan_threshold__free_unpacked + (WifiScanThreshold *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_pmf_config__init + (WifiPmfConfig *message) +{ + static const WifiPmfConfig init_value = WIFI_PMF_CONFIG__INIT; + *message = init_value; +} +size_t wifi_pmf_config__get_packed_size + (const WifiPmfConfig *message) +{ + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_pmf_config__pack + (const WifiPmfConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_pmf_config__pack_to_buffer + (const WifiPmfConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPmfConfig * + wifi_pmf_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPmfConfig *) + protobuf_c_message_unpack (&wifi_pmf_config__descriptor, + allocator, len, data); +} +void wifi_pmf_config__free_unpacked + (WifiPmfConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ap_config__init + (WifiApConfig *message) +{ + static const WifiApConfig init_value = WIFI_AP_CONFIG__INIT; + *message = init_value; +} +size_t wifi_ap_config__get_packed_size + (const WifiApConfig *message) +{ + assert(message->base.descriptor == &wifi_ap_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ap_config__pack + (const WifiApConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ap_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ap_config__pack_to_buffer + (const WifiApConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ap_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiApConfig * + wifi_ap_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiApConfig *) + protobuf_c_message_unpack (&wifi_ap_config__descriptor, + allocator, len, data); +} +void wifi_ap_config__free_unpacked + (WifiApConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ap_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_sta_config__init + (WifiStaConfig *message) +{ + static const WifiStaConfig init_value = WIFI_STA_CONFIG__INIT; + *message = init_value; +} +size_t wifi_sta_config__get_packed_size + (const WifiStaConfig *message) +{ + assert(message->base.descriptor == &wifi_sta_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_sta_config__pack + (const WifiStaConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_sta_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_sta_config__pack_to_buffer + (const WifiStaConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_sta_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiStaConfig * + wifi_sta_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiStaConfig *) + protobuf_c_message_unpack (&wifi_sta_config__descriptor, + allocator, len, data); +} +void wifi_sta_config__free_unpacked + (WifiStaConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_sta_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_config__init + (WifiConfig *message) +{ + static const WifiConfig init_value = WIFI_CONFIG__INIT; + *message = init_value; +} +size_t wifi_config__get_packed_size + (const WifiConfig *message) +{ + assert(message->base.descriptor == &wifi_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_config__pack + (const WifiConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_config__pack_to_buffer + (const WifiConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiConfig * + wifi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiConfig *) + protobuf_c_message_unpack (&wifi_config__descriptor, + allocator, len, data); +} +void wifi_config__free_unpacked + (WifiConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_sta_info__init + (WifiStaInfo *message) +{ + static const WifiStaInfo init_value = WIFI_STA_INFO__INIT; + *message = init_value; +} +size_t wifi_sta_info__get_packed_size + (const WifiStaInfo *message) +{ + assert(message->base.descriptor == &wifi_sta_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_sta_info__pack + (const WifiStaInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_sta_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_sta_info__pack_to_buffer + (const WifiStaInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_sta_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiStaInfo * + wifi_sta_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiStaInfo *) + protobuf_c_message_unpack (&wifi_sta_info__descriptor, + allocator, len, data); +} +void wifi_sta_info__free_unpacked + (WifiStaInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_sta_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_sta_list__init + (WifiStaList *message) +{ + static const WifiStaList init_value = WIFI_STA_LIST__INIT; + *message = init_value; +} +size_t wifi_sta_list__get_packed_size + (const WifiStaList *message) +{ + assert(message->base.descriptor == &wifi_sta_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_sta_list__pack + (const WifiStaList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_sta_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_sta_list__pack_to_buffer + (const WifiStaList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_sta_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiStaList * + wifi_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiStaList *) + protobuf_c_message_unpack (&wifi_sta_list__descriptor, + allocator, len, data); +} +void wifi_sta_list__free_unpacked + (WifiStaList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_sta_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_pkt_rx_ctrl__init + (WifiPktRxCtrl *message) +{ + static const WifiPktRxCtrl init_value = WIFI_PKT_RX_CTRL__INIT; + *message = init_value; +} +size_t wifi_pkt_rx_ctrl__get_packed_size + (const WifiPktRxCtrl *message) +{ + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_pkt_rx_ctrl__pack + (const WifiPktRxCtrl *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_pkt_rx_ctrl__pack_to_buffer + (const WifiPktRxCtrl *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPktRxCtrl * + wifi_pkt_rx_ctrl__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPktRxCtrl *) + protobuf_c_message_unpack (&wifi_pkt_rx_ctrl__descriptor, + allocator, len, data); +} +void wifi_pkt_rx_ctrl__free_unpacked + (WifiPktRxCtrl *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_promiscuous_pkt__init + (WifiPromiscuousPkt *message) +{ + static const WifiPromiscuousPkt init_value = WIFI_PROMISCUOUS_PKT__INIT; + *message = init_value; +} +size_t wifi_promiscuous_pkt__get_packed_size + (const WifiPromiscuousPkt *message) +{ + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_promiscuous_pkt__pack + (const WifiPromiscuousPkt *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_promiscuous_pkt__pack_to_buffer + (const WifiPromiscuousPkt *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPromiscuousPkt * + wifi_promiscuous_pkt__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPromiscuousPkt *) + protobuf_c_message_unpack (&wifi_promiscuous_pkt__descriptor, + allocator, len, data); +} +void wifi_promiscuous_pkt__free_unpacked + (WifiPromiscuousPkt *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_promiscuous_filter__init + (WifiPromiscuousFilter *message) +{ + static const WifiPromiscuousFilter init_value = WIFI_PROMISCUOUS_FILTER__INIT; + *message = init_value; +} +size_t wifi_promiscuous_filter__get_packed_size + (const WifiPromiscuousFilter *message) +{ + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_promiscuous_filter__pack + (const WifiPromiscuousFilter *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_promiscuous_filter__pack_to_buffer + (const WifiPromiscuousFilter *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPromiscuousFilter * + wifi_promiscuous_filter__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPromiscuousFilter *) + protobuf_c_message_unpack (&wifi_promiscuous_filter__descriptor, + allocator, len, data); +} +void wifi_promiscuous_filter__free_unpacked + (WifiPromiscuousFilter *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_csi_config__init + (WifiCsiConfig *message) +{ + static const WifiCsiConfig init_value = WIFI_CSI_CONFIG__INIT; + *message = init_value; +} +size_t wifi_csi_config__get_packed_size + (const WifiCsiConfig *message) +{ + assert(message->base.descriptor == &wifi_csi_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_csi_config__pack + (const WifiCsiConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_csi_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_csi_config__pack_to_buffer + (const WifiCsiConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_csi_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiCsiConfig * + wifi_csi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiCsiConfig *) + protobuf_c_message_unpack (&wifi_csi_config__descriptor, + allocator, len, data); +} +void wifi_csi_config__free_unpacked + (WifiCsiConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_csi_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_csi_info__init + (WifiCsiInfo *message) +{ + static const WifiCsiInfo init_value = WIFI_CSI_INFO__INIT; + *message = init_value; +} +size_t wifi_csi_info__get_packed_size + (const WifiCsiInfo *message) +{ + assert(message->base.descriptor == &wifi_csi_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_csi_info__pack + (const WifiCsiInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_csi_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_csi_info__pack_to_buffer + (const WifiCsiInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_csi_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiCsiInfo * + wifi_csi_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiCsiInfo *) + protobuf_c_message_unpack (&wifi_csi_info__descriptor, + allocator, len, data); +} +void wifi_csi_info__free_unpacked + (WifiCsiInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_csi_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ant_gpio__init + (WifiAntGpio *message) +{ + static const WifiAntGpio init_value = WIFI_ANT_GPIO__INIT; + *message = init_value; +} +size_t wifi_ant_gpio__get_packed_size + (const WifiAntGpio *message) +{ + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ant_gpio__pack + (const WifiAntGpio *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ant_gpio__pack_to_buffer + (const WifiAntGpio *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiAntGpio * + wifi_ant_gpio__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiAntGpio *) + protobuf_c_message_unpack (&wifi_ant_gpio__descriptor, + allocator, len, data); +} +void wifi_ant_gpio__free_unpacked + (WifiAntGpio *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ant_gpio_config__init + (WifiAntGpioConfig *message) +{ + static const WifiAntGpioConfig init_value = WIFI_ANT_GPIO_CONFIG__INIT; + *message = init_value; +} +size_t wifi_ant_gpio_config__get_packed_size + (const WifiAntGpioConfig *message) +{ + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ant_gpio_config__pack + (const WifiAntGpioConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ant_gpio_config__pack_to_buffer + (const WifiAntGpioConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiAntGpioConfig * + wifi_ant_gpio_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiAntGpioConfig *) + protobuf_c_message_unpack (&wifi_ant_gpio_config__descriptor, + allocator, len, data); +} +void wifi_ant_gpio_config__free_unpacked + (WifiAntGpioConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ant_config__init + (WifiAntConfig *message) +{ + static const WifiAntConfig init_value = WIFI_ANT_CONFIG__INIT; + *message = init_value; +} +size_t wifi_ant_config__get_packed_size + (const WifiAntConfig *message) +{ + assert(message->base.descriptor == &wifi_ant_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ant_config__pack + (const WifiAntConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ant_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ant_config__pack_to_buffer + (const WifiAntConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ant_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiAntConfig * + wifi_ant_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiAntConfig *) + protobuf_c_message_unpack (&wifi_ant_config__descriptor, + allocator, len, data); +} +void wifi_ant_config__free_unpacked + (WifiAntConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ant_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_action_tx_req__init + (WifiActionTxReq *message) +{ + static const WifiActionTxReq init_value = WIFI_ACTION_TX_REQ__INIT; + *message = init_value; +} +size_t wifi_action_tx_req__get_packed_size + (const WifiActionTxReq *message) +{ + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_action_tx_req__pack + (const WifiActionTxReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_action_tx_req__pack_to_buffer + (const WifiActionTxReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiActionTxReq * + wifi_action_tx_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiActionTxReq *) + protobuf_c_message_unpack (&wifi_action_tx_req__descriptor, + allocator, len, data); +} +void wifi_action_tx_req__free_unpacked + (WifiActionTxReq *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ftm_initiator_cfg__init + (WifiFtmInitiatorCfg *message) +{ + static const WifiFtmInitiatorCfg init_value = WIFI_FTM_INITIATOR_CFG__INIT; + *message = init_value; +} +size_t wifi_ftm_initiator_cfg__get_packed_size + (const WifiFtmInitiatorCfg *message) +{ + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ftm_initiator_cfg__pack + (const WifiFtmInitiatorCfg *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ftm_initiator_cfg__pack_to_buffer + (const WifiFtmInitiatorCfg *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiFtmInitiatorCfg * + wifi_ftm_initiator_cfg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiFtmInitiatorCfg *) + protobuf_c_message_unpack (&wifi_ftm_initiator_cfg__descriptor, + allocator, len, data); +} +void wifi_ftm_initiator_cfg__free_unpacked + (WifiFtmInitiatorCfg *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_scan_done__init + (WifiEventStaScanDone *message) +{ + static const WifiEventStaScanDone init_value = WIFI_EVENT_STA_SCAN_DONE__INIT; + *message = init_value; +} +size_t wifi_event_sta_scan_done__get_packed_size + (const WifiEventStaScanDone *message) +{ + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_scan_done__pack + (const WifiEventStaScanDone *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_scan_done__pack_to_buffer + (const WifiEventStaScanDone *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaScanDone * + wifi_event_sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaScanDone *) + protobuf_c_message_unpack (&wifi_event_sta_scan_done__descriptor, + allocator, len, data); +} +void wifi_event_sta_scan_done__free_unpacked + (WifiEventStaScanDone *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_connected__init + (WifiEventStaConnected *message) +{ + static const WifiEventStaConnected init_value = WIFI_EVENT_STA_CONNECTED__INIT; + *message = init_value; +} +size_t wifi_event_sta_connected__get_packed_size + (const WifiEventStaConnected *message) +{ + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_connected__pack + (const WifiEventStaConnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_connected__pack_to_buffer + (const WifiEventStaConnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaConnected * + wifi_event_sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaConnected *) + protobuf_c_message_unpack (&wifi_event_sta_connected__descriptor, + allocator, len, data); +} +void wifi_event_sta_connected__free_unpacked + (WifiEventStaConnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_disconnected__init + (WifiEventStaDisconnected *message) +{ + static const WifiEventStaDisconnected init_value = WIFI_EVENT_STA_DISCONNECTED__INIT; + *message = init_value; +} +size_t wifi_event_sta_disconnected__get_packed_size + (const WifiEventStaDisconnected *message) +{ + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_disconnected__pack + (const WifiEventStaDisconnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_disconnected__pack_to_buffer + (const WifiEventStaDisconnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaDisconnected * + wifi_event_sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaDisconnected *) + protobuf_c_message_unpack (&wifi_event_sta_disconnected__descriptor, + allocator, len, data); +} +void wifi_event_sta_disconnected__free_unpacked + (WifiEventStaDisconnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_authmode_change__init + (WifiEventStaAuthmodeChange *message) +{ + static const WifiEventStaAuthmodeChange init_value = WIFI_EVENT_STA_AUTHMODE_CHANGE__INIT; + *message = init_value; +} +size_t wifi_event_sta_authmode_change__get_packed_size + (const WifiEventStaAuthmodeChange *message) +{ + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_authmode_change__pack + (const WifiEventStaAuthmodeChange *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_authmode_change__pack_to_buffer + (const WifiEventStaAuthmodeChange *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaAuthmodeChange * + wifi_event_sta_authmode_change__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaAuthmodeChange *) + protobuf_c_message_unpack (&wifi_event_sta_authmode_change__descriptor, + allocator, len, data); +} +void wifi_event_sta_authmode_change__free_unpacked + (WifiEventStaAuthmodeChange *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_wps_er_pin__init + (WifiEventStaWpsErPin *message) +{ + static const WifiEventStaWpsErPin init_value = WIFI_EVENT_STA_WPS_ER_PIN__INIT; + *message = init_value; +} +size_t wifi_event_sta_wps_er_pin__get_packed_size + (const WifiEventStaWpsErPin *message) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_wps_er_pin__pack + (const WifiEventStaWpsErPin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_wps_er_pin__pack_to_buffer + (const WifiEventStaWpsErPin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaWpsErPin * + wifi_event_sta_wps_er_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaWpsErPin *) + protobuf_c_message_unpack (&wifi_event_sta_wps_er_pin__descriptor, + allocator, len, data); +} +void wifi_event_sta_wps_er_pin__free_unpacked + (WifiEventStaWpsErPin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void ap_cred__init + (ApCred *message) +{ + static const ApCred init_value = AP_CRED__INIT; + *message = init_value; +} +size_t ap_cred__get_packed_size + (const ApCred *message) +{ + assert(message->base.descriptor == &ap_cred__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ap_cred__pack + (const ApCred *message, + uint8_t *out) +{ + assert(message->base.descriptor == &ap_cred__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ap_cred__pack_to_buffer + (const ApCred *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &ap_cred__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ApCred * + ap_cred__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ApCred *) + protobuf_c_message_unpack (&ap_cred__descriptor, + allocator, len, data); +} +void ap_cred__free_unpacked + (ApCred *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &ap_cred__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_wps_er_success__init + (WifiEventStaWpsErSuccess *message) +{ + static const WifiEventStaWpsErSuccess init_value = WIFI_EVENT_STA_WPS_ER_SUCCESS__INIT; + *message = init_value; +} +size_t wifi_event_sta_wps_er_success__get_packed_size + (const WifiEventStaWpsErSuccess *message) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_wps_er_success__pack + (const WifiEventStaWpsErSuccess *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_wps_er_success__pack_to_buffer + (const WifiEventStaWpsErSuccess *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaWpsErSuccess * + wifi_event_sta_wps_er_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaWpsErSuccess *) + protobuf_c_message_unpack (&wifi_event_sta_wps_er_success__descriptor, + allocator, len, data); +} +void wifi_event_sta_wps_er_success__free_unpacked + (WifiEventStaWpsErSuccess *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_probe_req_rx__init + (WifiEventApProbeReqRx *message) +{ + static const WifiEventApProbeReqRx init_value = WIFI_EVENT_AP_PROBE_REQ_RX__INIT; + *message = init_value; +} +size_t wifi_event_ap_probe_req_rx__get_packed_size + (const WifiEventApProbeReqRx *message) +{ + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_probe_req_rx__pack + (const WifiEventApProbeReqRx *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_probe_req_rx__pack_to_buffer + (const WifiEventApProbeReqRx *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApProbeReqRx * + wifi_event_ap_probe_req_rx__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApProbeReqRx *) + protobuf_c_message_unpack (&wifi_event_ap_probe_req_rx__descriptor, + allocator, len, data); +} +void wifi_event_ap_probe_req_rx__free_unpacked + (WifiEventApProbeReqRx *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_bss_rssi_low__init + (WifiEventBssRssiLow *message) +{ + static const WifiEventBssRssiLow init_value = WIFI_EVENT_BSS_RSSI_LOW__INIT; + *message = init_value; +} +size_t wifi_event_bss_rssi_low__get_packed_size + (const WifiEventBssRssiLow *message) +{ + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_bss_rssi_low__pack + (const WifiEventBssRssiLow *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_bss_rssi_low__pack_to_buffer + (const WifiEventBssRssiLow *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventBssRssiLow * + wifi_event_bss_rssi_low__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventBssRssiLow *) + protobuf_c_message_unpack (&wifi_event_bss_rssi_low__descriptor, + allocator, len, data); +} +void wifi_event_bss_rssi_low__free_unpacked + (WifiEventBssRssiLow *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ftm_report_entry__init + (WifiFtmReportEntry *message) +{ + static const WifiFtmReportEntry init_value = WIFI_FTM_REPORT_ENTRY__INIT; + *message = init_value; +} +size_t wifi_ftm_report_entry__get_packed_size + (const WifiFtmReportEntry *message) +{ + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ftm_report_entry__pack + (const WifiFtmReportEntry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ftm_report_entry__pack_to_buffer + (const WifiFtmReportEntry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiFtmReportEntry * + wifi_ftm_report_entry__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiFtmReportEntry *) + protobuf_c_message_unpack (&wifi_ftm_report_entry__descriptor, + allocator, len, data); +} +void wifi_ftm_report_entry__free_unpacked + (WifiFtmReportEntry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ftm_report__init + (WifiEventFtmReport *message) +{ + static const WifiEventFtmReport init_value = WIFI_EVENT_FTM_REPORT__INIT; + *message = init_value; +} +size_t wifi_event_ftm_report__get_packed_size + (const WifiEventFtmReport *message) +{ + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ftm_report__pack + (const WifiEventFtmReport *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ftm_report__pack_to_buffer + (const WifiEventFtmReport *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventFtmReport * + wifi_event_ftm_report__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventFtmReport *) + protobuf_c_message_unpack (&wifi_event_ftm_report__descriptor, + allocator, len, data); +} +void wifi_event_ftm_report__free_unpacked + (WifiEventFtmReport *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_action_tx_status__init + (WifiEventActionTxStatus *message) +{ + static const WifiEventActionTxStatus init_value = WIFI_EVENT_ACTION_TX_STATUS__INIT; + *message = init_value; +} +size_t wifi_event_action_tx_status__get_packed_size + (const WifiEventActionTxStatus *message) +{ + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_action_tx_status__pack + (const WifiEventActionTxStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_action_tx_status__pack_to_buffer + (const WifiEventActionTxStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventActionTxStatus * + wifi_event_action_tx_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventActionTxStatus *) + protobuf_c_message_unpack (&wifi_event_action_tx_status__descriptor, + allocator, len, data); +} +void wifi_event_action_tx_status__free_unpacked + (WifiEventActionTxStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_roc_done__init + (WifiEventRocDone *message) +{ + static const WifiEventRocDone init_value = WIFI_EVENT_ROC_DONE__INIT; + *message = init_value; +} +size_t wifi_event_roc_done__get_packed_size + (const WifiEventRocDone *message) +{ + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_roc_done__pack + (const WifiEventRocDone *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_roc_done__pack_to_buffer + (const WifiEventRocDone *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventRocDone * + wifi_event_roc_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventRocDone *) + protobuf_c_message_unpack (&wifi_event_roc_done__descriptor, + allocator, len, data); +} +void wifi_event_roc_done__free_unpacked + (WifiEventRocDone *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_wps_rg_pin__init + (WifiEventApWpsRgPin *message) +{ + static const WifiEventApWpsRgPin init_value = WIFI_EVENT_AP_WPS_RG_PIN__INIT; + *message = init_value; +} +size_t wifi_event_ap_wps_rg_pin__get_packed_size + (const WifiEventApWpsRgPin *message) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_wps_rg_pin__pack + (const WifiEventApWpsRgPin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_wps_rg_pin__pack_to_buffer + (const WifiEventApWpsRgPin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApWpsRgPin * + wifi_event_ap_wps_rg_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApWpsRgPin *) + protobuf_c_message_unpack (&wifi_event_ap_wps_rg_pin__descriptor, + allocator, len, data); +} +void wifi_event_ap_wps_rg_pin__free_unpacked + (WifiEventApWpsRgPin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_wps_rg_fail_reason__init + (WifiEventApWpsRgFailReason *message) +{ + static const WifiEventApWpsRgFailReason init_value = WIFI_EVENT_AP_WPS_RG_FAIL_REASON__INIT; + *message = init_value; +} +size_t wifi_event_ap_wps_rg_fail_reason__get_packed_size + (const WifiEventApWpsRgFailReason *message) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_wps_rg_fail_reason__pack + (const WifiEventApWpsRgFailReason *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_wps_rg_fail_reason__pack_to_buffer + (const WifiEventApWpsRgFailReason *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApWpsRgFailReason * + wifi_event_ap_wps_rg_fail_reason__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApWpsRgFailReason *) + protobuf_c_message_unpack (&wifi_event_ap_wps_rg_fail_reason__descriptor, + allocator, len, data); +} +void wifi_event_ap_wps_rg_fail_reason__free_unpacked + (WifiEventApWpsRgFailReason *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_wps_rg_success__init + (WifiEventApWpsRgSuccess *message) +{ + static const WifiEventApWpsRgSuccess init_value = WIFI_EVENT_AP_WPS_RG_SUCCESS__INIT; + *message = init_value; +} +size_t wifi_event_ap_wps_rg_success__get_packed_size + (const WifiEventApWpsRgSuccess *message) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_wps_rg_success__pack + (const WifiEventApWpsRgSuccess *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_wps_rg_success__pack_to_buffer + (const WifiEventApWpsRgSuccess *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApWpsRgSuccess * + wifi_event_ap_wps_rg_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApWpsRgSuccess *) + protobuf_c_message_unpack (&wifi_event_ap_wps_rg_success__descriptor, + allocator, len, data); +} +void wifi_event_ap_wps_rg_success__free_unpacked + (WifiEventApWpsRgSuccess *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_protocols__init + (WifiProtocols *message) +{ + static const WifiProtocols init_value = WIFI_PROTOCOLS__INIT; + *message = init_value; +} +size_t wifi_protocols__get_packed_size + (const WifiProtocols *message) +{ + assert(message->base.descriptor == &wifi_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_protocols__pack + (const WifiProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_protocols__pack_to_buffer + (const WifiProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiProtocols * + wifi_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiProtocols *) + protobuf_c_message_unpack (&wifi_protocols__descriptor, + allocator, len, data); +} +void wifi_protocols__free_unpacked + (WifiProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_bandwidths__init + (WifiBandwidths *message) +{ + static const WifiBandwidths init_value = WIFI_BANDWIDTHS__INIT; + *message = init_value; +} +size_t wifi_bandwidths__get_packed_size + (const WifiBandwidths *message) +{ + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_bandwidths__pack + (const WifiBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_bandwidths__pack_to_buffer + (const WifiBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiBandwidths * + wifi_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiBandwidths *) + protobuf_c_message_unpack (&wifi_bandwidths__descriptor, + allocator, len, data); +} +void wifi_bandwidths__free_unpacked + (WifiBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void connected_stalist__init + (ConnectedSTAList *message) +{ + static const ConnectedSTAList init_value = CONNECTED_STALIST__INIT; + *message = init_value; +} +size_t connected_stalist__get_packed_size + (const ConnectedSTAList *message) +{ + assert(message->base.descriptor == &connected_stalist__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t connected_stalist__pack + (const ConnectedSTAList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &connected_stalist__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t connected_stalist__pack_to_buffer + (const ConnectedSTAList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &connected_stalist__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ConnectedSTAList * + connected_stalist__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ConnectedSTAList *) + protobuf_c_message_unpack (&connected_stalist__descriptor, + allocator, len, data); +} +void connected_stalist__free_unpacked + (ConnectedSTAList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &connected_stalist__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_mac_address__init + (RpcReqGetMacAddress *message) +{ + static const RpcReqGetMacAddress init_value = RPC__REQ__GET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__req__get_mac_address__get_packed_size + (const RpcReqGetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_mac_address__pack + (const RpcReqGetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_mac_address__pack_to_buffer + (const RpcReqGetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetMacAddress * + rpc__req__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetMacAddress *) + protobuf_c_message_unpack (&rpc__req__get_mac_address__descriptor, + allocator, len, data); +} +void rpc__req__get_mac_address__free_unpacked + (RpcReqGetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_mac_address__init + (RpcRespGetMacAddress *message) +{ + static const RpcRespGetMacAddress init_value = RPC__RESP__GET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__resp__get_mac_address__get_packed_size + (const RpcRespGetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_mac_address__pack + (const RpcRespGetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_mac_address__pack_to_buffer + (const RpcRespGetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetMacAddress * + rpc__resp__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetMacAddress *) + protobuf_c_message_unpack (&rpc__resp__get_mac_address__descriptor, + allocator, len, data); +} +void rpc__resp__get_mac_address__free_unpacked + (RpcRespGetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_mode__init + (RpcReqGetMode *message) +{ + static const RpcReqGetMode init_value = RPC__REQ__GET_MODE__INIT; + *message = init_value; +} +size_t rpc__req__get_mode__get_packed_size + (const RpcReqGetMode *message) +{ + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_mode__pack + (const RpcReqGetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_mode__pack_to_buffer + (const RpcReqGetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetMode * + rpc__req__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetMode *) + protobuf_c_message_unpack (&rpc__req__get_mode__descriptor, + allocator, len, data); +} +void rpc__req__get_mode__free_unpacked + (RpcReqGetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_mode__init + (RpcRespGetMode *message) +{ + static const RpcRespGetMode init_value = RPC__RESP__GET_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__get_mode__get_packed_size + (const RpcRespGetMode *message) +{ + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_mode__pack + (const RpcRespGetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_mode__pack_to_buffer + (const RpcRespGetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetMode * + rpc__resp__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetMode *) + protobuf_c_message_unpack (&rpc__resp__get_mode__descriptor, + allocator, len, data); +} +void rpc__resp__get_mode__free_unpacked + (RpcRespGetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_mode__init + (RpcReqSetMode *message) +{ + static const RpcReqSetMode init_value = RPC__REQ__SET_MODE__INIT; + *message = init_value; +} +size_t rpc__req__set_mode__get_packed_size + (const RpcReqSetMode *message) +{ + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_mode__pack + (const RpcReqSetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_mode__pack_to_buffer + (const RpcReqSetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetMode * + rpc__req__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetMode *) + protobuf_c_message_unpack (&rpc__req__set_mode__descriptor, + allocator, len, data); +} +void rpc__req__set_mode__free_unpacked + (RpcReqSetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_mode__init + (RpcRespSetMode *message) +{ + static const RpcRespSetMode init_value = RPC__RESP__SET_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__set_mode__get_packed_size + (const RpcRespSetMode *message) +{ + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_mode__pack + (const RpcRespSetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_mode__pack_to_buffer + (const RpcRespSetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetMode * + rpc__resp__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetMode *) + protobuf_c_message_unpack (&rpc__resp__set_mode__descriptor, + allocator, len, data); +} +void rpc__resp__set_mode__free_unpacked + (RpcRespSetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_ps__init + (RpcReqGetPs *message) +{ + static const RpcReqGetPs init_value = RPC__REQ__GET_PS__INIT; + *message = init_value; +} +size_t rpc__req__get_ps__get_packed_size + (const RpcReqGetPs *message) +{ + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_ps__pack + (const RpcReqGetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_ps__pack_to_buffer + (const RpcReqGetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetPs * + rpc__req__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetPs *) + protobuf_c_message_unpack (&rpc__req__get_ps__descriptor, + allocator, len, data); +} +void rpc__req__get_ps__free_unpacked + (RpcReqGetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_ps__init + (RpcRespGetPs *message) +{ + static const RpcRespGetPs init_value = RPC__RESP__GET_PS__INIT; + *message = init_value; +} +size_t rpc__resp__get_ps__get_packed_size + (const RpcRespGetPs *message) +{ + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_ps__pack + (const RpcRespGetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_ps__pack_to_buffer + (const RpcRespGetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetPs * + rpc__resp__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetPs *) + protobuf_c_message_unpack (&rpc__resp__get_ps__descriptor, + allocator, len, data); +} +void rpc__resp__get_ps__free_unpacked + (RpcRespGetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_ps__init + (RpcReqSetPs *message) +{ + static const RpcReqSetPs init_value = RPC__REQ__SET_PS__INIT; + *message = init_value; +} +size_t rpc__req__set_ps__get_packed_size + (const RpcReqSetPs *message) +{ + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_ps__pack + (const RpcReqSetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_ps__pack_to_buffer + (const RpcReqSetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetPs * + rpc__req__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetPs *) + protobuf_c_message_unpack (&rpc__req__set_ps__descriptor, + allocator, len, data); +} +void rpc__req__set_ps__free_unpacked + (RpcReqSetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_ps__init + (RpcRespSetPs *message) +{ + static const RpcRespSetPs init_value = RPC__RESP__SET_PS__INIT; + *message = init_value; +} +size_t rpc__resp__set_ps__get_packed_size + (const RpcRespSetPs *message) +{ + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_ps__pack + (const RpcRespSetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_ps__pack_to_buffer + (const RpcRespSetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetPs * + rpc__resp__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetPs *) + protobuf_c_message_unpack (&rpc__resp__set_ps__descriptor, + allocator, len, data); +} +void rpc__resp__set_ps__free_unpacked + (RpcRespSetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_mac_address__init + (RpcReqSetMacAddress *message) +{ + static const RpcReqSetMacAddress init_value = RPC__REQ__SET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__req__set_mac_address__get_packed_size + (const RpcReqSetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_mac_address__pack + (const RpcReqSetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_mac_address__pack_to_buffer + (const RpcReqSetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetMacAddress * + rpc__req__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetMacAddress *) + protobuf_c_message_unpack (&rpc__req__set_mac_address__descriptor, + allocator, len, data); +} +void rpc__req__set_mac_address__free_unpacked + (RpcReqSetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_mac_address__init + (RpcRespSetMacAddress *message) +{ + static const RpcRespSetMacAddress init_value = RPC__RESP__SET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__resp__set_mac_address__get_packed_size + (const RpcRespSetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_mac_address__pack + (const RpcRespSetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_mac_address__pack_to_buffer + (const RpcRespSetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetMacAddress * + rpc__resp__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetMacAddress *) + protobuf_c_message_unpack (&rpc__resp__set_mac_address__descriptor, + allocator, len, data); +} +void rpc__resp__set_mac_address__free_unpacked + (RpcRespSetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__otabegin__init + (RpcReqOTABegin *message) +{ + static const RpcReqOTABegin init_value = RPC__REQ__OTABEGIN__INIT; + *message = init_value; +} +size_t rpc__req__otabegin__get_packed_size + (const RpcReqOTABegin *message) +{ + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__otabegin__pack + (const RpcReqOTABegin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__otabegin__pack_to_buffer + (const RpcReqOTABegin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqOTABegin * + rpc__req__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqOTABegin *) + protobuf_c_message_unpack (&rpc__req__otabegin__descriptor, + allocator, len, data); +} +void rpc__req__otabegin__free_unpacked + (RpcReqOTABegin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__otabegin__init + (RpcRespOTABegin *message) +{ + static const RpcRespOTABegin init_value = RPC__RESP__OTABEGIN__INIT; + *message = init_value; +} +size_t rpc__resp__otabegin__get_packed_size + (const RpcRespOTABegin *message) +{ + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__otabegin__pack + (const RpcRespOTABegin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__otabegin__pack_to_buffer + (const RpcRespOTABegin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespOTABegin * + rpc__resp__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespOTABegin *) + protobuf_c_message_unpack (&rpc__resp__otabegin__descriptor, + allocator, len, data); +} +void rpc__resp__otabegin__free_unpacked + (RpcRespOTABegin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__otawrite__init + (RpcReqOTAWrite *message) +{ + static const RpcReqOTAWrite init_value = RPC__REQ__OTAWRITE__INIT; + *message = init_value; +} +size_t rpc__req__otawrite__get_packed_size + (const RpcReqOTAWrite *message) +{ + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__otawrite__pack + (const RpcReqOTAWrite *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__otawrite__pack_to_buffer + (const RpcReqOTAWrite *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqOTAWrite * + rpc__req__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqOTAWrite *) + protobuf_c_message_unpack (&rpc__req__otawrite__descriptor, + allocator, len, data); +} +void rpc__req__otawrite__free_unpacked + (RpcReqOTAWrite *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__otawrite__init + (RpcRespOTAWrite *message) +{ + static const RpcRespOTAWrite init_value = RPC__RESP__OTAWRITE__INIT; + *message = init_value; +} +size_t rpc__resp__otawrite__get_packed_size + (const RpcRespOTAWrite *message) +{ + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__otawrite__pack + (const RpcRespOTAWrite *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__otawrite__pack_to_buffer + (const RpcRespOTAWrite *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespOTAWrite * + rpc__resp__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespOTAWrite *) + protobuf_c_message_unpack (&rpc__resp__otawrite__descriptor, + allocator, len, data); +} +void rpc__resp__otawrite__free_unpacked + (RpcRespOTAWrite *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__otaend__init + (RpcReqOTAEnd *message) +{ + static const RpcReqOTAEnd init_value = RPC__REQ__OTAEND__INIT; + *message = init_value; +} +size_t rpc__req__otaend__get_packed_size + (const RpcReqOTAEnd *message) +{ + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__otaend__pack + (const RpcReqOTAEnd *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__otaend__pack_to_buffer + (const RpcReqOTAEnd *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqOTAEnd * + rpc__req__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqOTAEnd *) + protobuf_c_message_unpack (&rpc__req__otaend__descriptor, + allocator, len, data); +} +void rpc__req__otaend__free_unpacked + (RpcReqOTAEnd *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__otaend__init + (RpcRespOTAEnd *message) +{ + static const RpcRespOTAEnd init_value = RPC__RESP__OTAEND__INIT; + *message = init_value; +} +size_t rpc__resp__otaend__get_packed_size + (const RpcRespOTAEnd *message) +{ + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__otaend__pack + (const RpcRespOTAEnd *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__otaend__pack_to_buffer + (const RpcRespOTAEnd *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespOTAEnd * + rpc__resp__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespOTAEnd *) + protobuf_c_message_unpack (&rpc__resp__otaend__descriptor, + allocator, len, data); +} +void rpc__resp__otaend__free_unpacked + (RpcRespOTAEnd *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_max_tx_power__init + (RpcReqWifiSetMaxTxPower *message) +{ + static const RpcReqWifiSetMaxTxPower init_value = RPC__REQ__WIFI_SET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_max_tx_power__get_packed_size + (const RpcReqWifiSetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_max_tx_power__pack + (const RpcReqWifiSetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_max_tx_power__pack_to_buffer + (const RpcReqWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetMaxTxPower * + rpc__req__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetMaxTxPower *) + protobuf_c_message_unpack (&rpc__req__wifi_set_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_max_tx_power__free_unpacked + (RpcReqWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_max_tx_power__init + (RpcRespWifiSetMaxTxPower *message) +{ + static const RpcRespWifiSetMaxTxPower init_value = RPC__RESP__WIFI_SET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_max_tx_power__get_packed_size + (const RpcRespWifiSetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_max_tx_power__pack + (const RpcRespWifiSetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_max_tx_power__pack_to_buffer + (const RpcRespWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetMaxTxPower * + rpc__resp__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetMaxTxPower *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_max_tx_power__free_unpacked + (RpcRespWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_max_tx_power__init + (RpcReqWifiGetMaxTxPower *message) +{ + static const RpcReqWifiGetMaxTxPower init_value = RPC__REQ__WIFI_GET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_max_tx_power__get_packed_size + (const RpcReqWifiGetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_max_tx_power__pack + (const RpcReqWifiGetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_max_tx_power__pack_to_buffer + (const RpcReqWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetMaxTxPower * + rpc__req__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetMaxTxPower *) + protobuf_c_message_unpack (&rpc__req__wifi_get_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_max_tx_power__free_unpacked + (RpcReqWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_max_tx_power__init + (RpcRespWifiGetMaxTxPower *message) +{ + static const RpcRespWifiGetMaxTxPower init_value = RPC__RESP__WIFI_GET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_max_tx_power__get_packed_size + (const RpcRespWifiGetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_max_tx_power__pack + (const RpcRespWifiGetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_max_tx_power__pack_to_buffer + (const RpcRespWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetMaxTxPower * + rpc__resp__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetMaxTxPower *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_max_tx_power__free_unpacked + (RpcRespWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__config_heartbeat__init + (RpcReqConfigHeartbeat *message) +{ + static const RpcReqConfigHeartbeat init_value = RPC__REQ__CONFIG_HEARTBEAT__INIT; + *message = init_value; +} +size_t rpc__req__config_heartbeat__get_packed_size + (const RpcReqConfigHeartbeat *message) +{ + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__config_heartbeat__pack + (const RpcReqConfigHeartbeat *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__config_heartbeat__pack_to_buffer + (const RpcReqConfigHeartbeat *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqConfigHeartbeat * + rpc__req__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqConfigHeartbeat *) + protobuf_c_message_unpack (&rpc__req__config_heartbeat__descriptor, + allocator, len, data); +} +void rpc__req__config_heartbeat__free_unpacked + (RpcReqConfigHeartbeat *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__config_heartbeat__init + (RpcRespConfigHeartbeat *message) +{ + static const RpcRespConfigHeartbeat init_value = RPC__RESP__CONFIG_HEARTBEAT__INIT; + *message = init_value; +} +size_t rpc__resp__config_heartbeat__get_packed_size + (const RpcRespConfigHeartbeat *message) +{ + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__config_heartbeat__pack + (const RpcRespConfigHeartbeat *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__config_heartbeat__pack_to_buffer + (const RpcRespConfigHeartbeat *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespConfigHeartbeat * + rpc__resp__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespConfigHeartbeat *) + protobuf_c_message_unpack (&rpc__resp__config_heartbeat__descriptor, + allocator, len, data); +} +void rpc__resp__config_heartbeat__free_unpacked + (RpcRespConfigHeartbeat *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_init__init + (RpcReqWifiInit *message) +{ + static const RpcReqWifiInit init_value = RPC__REQ__WIFI_INIT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_init__get_packed_size + (const RpcReqWifiInit *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_init__pack + (const RpcReqWifiInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_init__pack_to_buffer + (const RpcReqWifiInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiInit * + rpc__req__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiInit *) + protobuf_c_message_unpack (&rpc__req__wifi_init__descriptor, + allocator, len, data); +} +void rpc__req__wifi_init__free_unpacked + (RpcReqWifiInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_init__init + (RpcRespWifiInit *message) +{ + static const RpcRespWifiInit init_value = RPC__RESP__WIFI_INIT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_init__get_packed_size + (const RpcRespWifiInit *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_init__pack + (const RpcRespWifiInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_init__pack_to_buffer + (const RpcRespWifiInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiInit * + rpc__resp__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiInit *) + protobuf_c_message_unpack (&rpc__resp__wifi_init__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_init__free_unpacked + (RpcRespWifiInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_deinit__init + (RpcReqWifiDeinit *message) +{ + static const RpcReqWifiDeinit init_value = RPC__REQ__WIFI_DEINIT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_deinit__get_packed_size + (const RpcReqWifiDeinit *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_deinit__pack + (const RpcReqWifiDeinit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_deinit__pack_to_buffer + (const RpcReqWifiDeinit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiDeinit * + rpc__req__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiDeinit *) + protobuf_c_message_unpack (&rpc__req__wifi_deinit__descriptor, + allocator, len, data); +} +void rpc__req__wifi_deinit__free_unpacked + (RpcReqWifiDeinit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_deinit__init + (RpcRespWifiDeinit *message) +{ + static const RpcRespWifiDeinit init_value = RPC__RESP__WIFI_DEINIT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_deinit__get_packed_size + (const RpcRespWifiDeinit *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_deinit__pack + (const RpcRespWifiDeinit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_deinit__pack_to_buffer + (const RpcRespWifiDeinit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiDeinit * + rpc__resp__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiDeinit *) + protobuf_c_message_unpack (&rpc__resp__wifi_deinit__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_deinit__free_unpacked + (RpcRespWifiDeinit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_config__init + (RpcReqWifiSetConfig *message) +{ + static const RpcReqWifiSetConfig init_value = RPC__REQ__WIFI_SET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_config__get_packed_size + (const RpcReqWifiSetConfig *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_config__pack + (const RpcReqWifiSetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_config__pack_to_buffer + (const RpcReqWifiSetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetConfig * + rpc__req__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetConfig *) + protobuf_c_message_unpack (&rpc__req__wifi_set_config__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_config__free_unpacked + (RpcReqWifiSetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_config__init + (RpcRespWifiSetConfig *message) +{ + static const RpcRespWifiSetConfig init_value = RPC__RESP__WIFI_SET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_config__get_packed_size + (const RpcRespWifiSetConfig *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_config__pack + (const RpcRespWifiSetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_config__pack_to_buffer + (const RpcRespWifiSetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetConfig * + rpc__resp__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetConfig *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_config__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_config__free_unpacked + (RpcRespWifiSetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_config__init + (RpcReqWifiGetConfig *message) +{ + static const RpcReqWifiGetConfig init_value = RPC__REQ__WIFI_GET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_config__get_packed_size + (const RpcReqWifiGetConfig *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_config__pack + (const RpcReqWifiGetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_config__pack_to_buffer + (const RpcReqWifiGetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetConfig * + rpc__req__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetConfig *) + protobuf_c_message_unpack (&rpc__req__wifi_get_config__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_config__free_unpacked + (RpcReqWifiGetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_config__init + (RpcRespWifiGetConfig *message) +{ + static const RpcRespWifiGetConfig init_value = RPC__RESP__WIFI_GET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_config__get_packed_size + (const RpcRespWifiGetConfig *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_config__pack + (const RpcRespWifiGetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_config__pack_to_buffer + (const RpcRespWifiGetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetConfig * + rpc__resp__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetConfig *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_config__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_config__free_unpacked + (RpcRespWifiGetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_connect__init + (RpcReqWifiConnect *message) +{ + static const RpcReqWifiConnect init_value = RPC__REQ__WIFI_CONNECT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_connect__get_packed_size + (const RpcReqWifiConnect *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_connect__pack + (const RpcReqWifiConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_connect__pack_to_buffer + (const RpcReqWifiConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiConnect * + rpc__req__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiConnect *) + protobuf_c_message_unpack (&rpc__req__wifi_connect__descriptor, + allocator, len, data); +} +void rpc__req__wifi_connect__free_unpacked + (RpcReqWifiConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_connect__init + (RpcRespWifiConnect *message) +{ + static const RpcRespWifiConnect init_value = RPC__RESP__WIFI_CONNECT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_connect__get_packed_size + (const RpcRespWifiConnect *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_connect__pack + (const RpcRespWifiConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_connect__pack_to_buffer + (const RpcRespWifiConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiConnect * + rpc__resp__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiConnect *) + protobuf_c_message_unpack (&rpc__resp__wifi_connect__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_connect__free_unpacked + (RpcRespWifiConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_disconnect__init + (RpcReqWifiDisconnect *message) +{ + static const RpcReqWifiDisconnect init_value = RPC__REQ__WIFI_DISCONNECT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_disconnect__get_packed_size + (const RpcReqWifiDisconnect *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_disconnect__pack + (const RpcReqWifiDisconnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_disconnect__pack_to_buffer + (const RpcReqWifiDisconnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiDisconnect * + rpc__req__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiDisconnect *) + protobuf_c_message_unpack (&rpc__req__wifi_disconnect__descriptor, + allocator, len, data); +} +void rpc__req__wifi_disconnect__free_unpacked + (RpcReqWifiDisconnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_disconnect__init + (RpcRespWifiDisconnect *message) +{ + static const RpcRespWifiDisconnect init_value = RPC__RESP__WIFI_DISCONNECT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_disconnect__get_packed_size + (const RpcRespWifiDisconnect *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_disconnect__pack + (const RpcRespWifiDisconnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_disconnect__pack_to_buffer + (const RpcRespWifiDisconnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiDisconnect * + rpc__resp__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiDisconnect *) + protobuf_c_message_unpack (&rpc__resp__wifi_disconnect__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_disconnect__free_unpacked + (RpcRespWifiDisconnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_start__init + (RpcReqWifiStart *message) +{ + static const RpcReqWifiStart init_value = RPC__REQ__WIFI_START__INIT; + *message = init_value; +} +size_t rpc__req__wifi_start__get_packed_size + (const RpcReqWifiStart *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_start__pack + (const RpcReqWifiStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_start__pack_to_buffer + (const RpcReqWifiStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStart * + rpc__req__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStart *) + protobuf_c_message_unpack (&rpc__req__wifi_start__descriptor, + allocator, len, data); +} +void rpc__req__wifi_start__free_unpacked + (RpcReqWifiStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_start__init + (RpcRespWifiStart *message) +{ + static const RpcRespWifiStart init_value = RPC__RESP__WIFI_START__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_start__get_packed_size + (const RpcRespWifiStart *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_start__pack + (const RpcRespWifiStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_start__pack_to_buffer + (const RpcRespWifiStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStart * + rpc__resp__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStart *) + protobuf_c_message_unpack (&rpc__resp__wifi_start__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_start__free_unpacked + (RpcRespWifiStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_stop__init + (RpcReqWifiStop *message) +{ + static const RpcReqWifiStop init_value = RPC__REQ__WIFI_STOP__INIT; + *message = init_value; +} +size_t rpc__req__wifi_stop__get_packed_size + (const RpcReqWifiStop *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_stop__pack + (const RpcReqWifiStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_stop__pack_to_buffer + (const RpcReqWifiStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStop * + rpc__req__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStop *) + protobuf_c_message_unpack (&rpc__req__wifi_stop__descriptor, + allocator, len, data); +} +void rpc__req__wifi_stop__free_unpacked + (RpcReqWifiStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_stop__init + (RpcRespWifiStop *message) +{ + static const RpcRespWifiStop init_value = RPC__RESP__WIFI_STOP__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_stop__get_packed_size + (const RpcRespWifiStop *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_stop__pack + (const RpcRespWifiStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_stop__pack_to_buffer + (const RpcRespWifiStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStop * + rpc__resp__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStop *) + protobuf_c_message_unpack (&rpc__resp__wifi_stop__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_stop__free_unpacked + (RpcRespWifiStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_start__init + (RpcReqWifiScanStart *message) +{ + static const RpcReqWifiScanStart init_value = RPC__REQ__WIFI_SCAN_START__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_start__get_packed_size + (const RpcReqWifiScanStart *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_start__pack + (const RpcReqWifiScanStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_start__pack_to_buffer + (const RpcReqWifiScanStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanStart * + rpc__req__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanStart *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_start__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_start__free_unpacked + (RpcReqWifiScanStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_start__init + (RpcRespWifiScanStart *message) +{ + static const RpcRespWifiScanStart init_value = RPC__RESP__WIFI_SCAN_START__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_start__get_packed_size + (const RpcRespWifiScanStart *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_start__pack + (const RpcRespWifiScanStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_start__pack_to_buffer + (const RpcRespWifiScanStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanStart * + rpc__resp__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanStart *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_start__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_start__free_unpacked + (RpcRespWifiScanStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_stop__init + (RpcReqWifiScanStop *message) +{ + static const RpcReqWifiScanStop init_value = RPC__REQ__WIFI_SCAN_STOP__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_stop__get_packed_size + (const RpcReqWifiScanStop *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_stop__pack + (const RpcReqWifiScanStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_stop__pack_to_buffer + (const RpcReqWifiScanStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanStop * + rpc__req__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanStop *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_stop__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_stop__free_unpacked + (RpcReqWifiScanStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_stop__init + (RpcRespWifiScanStop *message) +{ + static const RpcRespWifiScanStop init_value = RPC__RESP__WIFI_SCAN_STOP__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_stop__get_packed_size + (const RpcRespWifiScanStop *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_stop__pack + (const RpcRespWifiScanStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_stop__pack_to_buffer + (const RpcRespWifiScanStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanStop * + rpc__resp__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanStop *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_stop__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_stop__free_unpacked + (RpcRespWifiScanStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_get_ap_num__init + (RpcReqWifiScanGetApNum *message) +{ + static const RpcReqWifiScanGetApNum init_value = RPC__REQ__WIFI_SCAN_GET_AP_NUM__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_get_ap_num__get_packed_size + (const RpcReqWifiScanGetApNum *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_get_ap_num__pack + (const RpcReqWifiScanGetApNum *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_get_ap_num__pack_to_buffer + (const RpcReqWifiScanGetApNum *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanGetApNum * + rpc__req__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanGetApNum *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_get_ap_num__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_get_ap_num__free_unpacked + (RpcReqWifiScanGetApNum *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_get_ap_num__init + (RpcRespWifiScanGetApNum *message) +{ + static const RpcRespWifiScanGetApNum init_value = RPC__RESP__WIFI_SCAN_GET_AP_NUM__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_get_ap_num__get_packed_size + (const RpcRespWifiScanGetApNum *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_get_ap_num__pack + (const RpcRespWifiScanGetApNum *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_get_ap_num__pack_to_buffer + (const RpcRespWifiScanGetApNum *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanGetApNum * + rpc__resp__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanGetApNum *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_get_ap_num__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_get_ap_num__free_unpacked + (RpcRespWifiScanGetApNum *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_get_ap_records__init + (RpcReqWifiScanGetApRecords *message) +{ + static const RpcReqWifiScanGetApRecords init_value = RPC__REQ__WIFI_SCAN_GET_AP_RECORDS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_get_ap_records__get_packed_size + (const RpcReqWifiScanGetApRecords *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_get_ap_records__pack + (const RpcReqWifiScanGetApRecords *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_get_ap_records__pack_to_buffer + (const RpcReqWifiScanGetApRecords *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanGetApRecords * + rpc__req__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanGetApRecords *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_get_ap_records__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_get_ap_records__free_unpacked + (RpcReqWifiScanGetApRecords *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_get_ap_records__init + (RpcRespWifiScanGetApRecords *message) +{ + static const RpcRespWifiScanGetApRecords init_value = RPC__RESP__WIFI_SCAN_GET_AP_RECORDS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_get_ap_records__get_packed_size + (const RpcRespWifiScanGetApRecords *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_get_ap_records__pack + (const RpcRespWifiScanGetApRecords *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_get_ap_records__pack_to_buffer + (const RpcRespWifiScanGetApRecords *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanGetApRecords * + rpc__resp__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanGetApRecords *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_get_ap_records__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_get_ap_records__free_unpacked + (RpcRespWifiScanGetApRecords *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_get_ap_record__init + (RpcReqWifiScanGetApRecord *message) +{ + static const RpcReqWifiScanGetApRecord init_value = RPC__REQ__WIFI_SCAN_GET_AP_RECORD__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_get_ap_record__get_packed_size + (const RpcReqWifiScanGetApRecord *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_get_ap_record__pack + (const RpcReqWifiScanGetApRecord *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_get_ap_record__pack_to_buffer + (const RpcReqWifiScanGetApRecord *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanGetApRecord * + rpc__req__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanGetApRecord *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_get_ap_record__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_get_ap_record__free_unpacked + (RpcReqWifiScanGetApRecord *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_get_ap_record__init + (RpcRespWifiScanGetApRecord *message) +{ + static const RpcRespWifiScanGetApRecord init_value = RPC__RESP__WIFI_SCAN_GET_AP_RECORD__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_get_ap_record__get_packed_size + (const RpcRespWifiScanGetApRecord *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_get_ap_record__pack + (const RpcRespWifiScanGetApRecord *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_get_ap_record__pack_to_buffer + (const RpcRespWifiScanGetApRecord *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanGetApRecord * + rpc__resp__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanGetApRecord *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_get_ap_record__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_get_ap_record__free_unpacked + (RpcRespWifiScanGetApRecord *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_clear_ap_list__init + (RpcReqWifiClearApList *message) +{ + static const RpcReqWifiClearApList init_value = RPC__REQ__WIFI_CLEAR_AP_LIST__INIT; + *message = init_value; +} +size_t rpc__req__wifi_clear_ap_list__get_packed_size + (const RpcReqWifiClearApList *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_clear_ap_list__pack + (const RpcReqWifiClearApList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_clear_ap_list__pack_to_buffer + (const RpcReqWifiClearApList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiClearApList * + rpc__req__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiClearApList *) + protobuf_c_message_unpack (&rpc__req__wifi_clear_ap_list__descriptor, + allocator, len, data); +} +void rpc__req__wifi_clear_ap_list__free_unpacked + (RpcReqWifiClearApList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_clear_ap_list__init + (RpcRespWifiClearApList *message) +{ + static const RpcRespWifiClearApList init_value = RPC__RESP__WIFI_CLEAR_AP_LIST__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_clear_ap_list__get_packed_size + (const RpcRespWifiClearApList *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_clear_ap_list__pack + (const RpcRespWifiClearApList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_clear_ap_list__pack_to_buffer + (const RpcRespWifiClearApList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiClearApList * + rpc__resp__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiClearApList *) + protobuf_c_message_unpack (&rpc__resp__wifi_clear_ap_list__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_clear_ap_list__free_unpacked + (RpcRespWifiClearApList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_restore__init + (RpcReqWifiRestore *message) +{ + static const RpcReqWifiRestore init_value = RPC__REQ__WIFI_RESTORE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_restore__get_packed_size + (const RpcReqWifiRestore *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_restore__pack + (const RpcReqWifiRestore *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_restore__pack_to_buffer + (const RpcReqWifiRestore *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiRestore * + rpc__req__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiRestore *) + protobuf_c_message_unpack (&rpc__req__wifi_restore__descriptor, + allocator, len, data); +} +void rpc__req__wifi_restore__free_unpacked + (RpcReqWifiRestore *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_restore__init + (RpcRespWifiRestore *message) +{ + static const RpcRespWifiRestore init_value = RPC__RESP__WIFI_RESTORE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_restore__get_packed_size + (const RpcRespWifiRestore *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_restore__pack + (const RpcRespWifiRestore *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_restore__pack_to_buffer + (const RpcRespWifiRestore *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiRestore * + rpc__resp__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiRestore *) + protobuf_c_message_unpack (&rpc__resp__wifi_restore__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_restore__free_unpacked + (RpcRespWifiRestore *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_clear_fast_connect__init + (RpcReqWifiClearFastConnect *message) +{ + static const RpcReqWifiClearFastConnect init_value = RPC__REQ__WIFI_CLEAR_FAST_CONNECT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_clear_fast_connect__get_packed_size + (const RpcReqWifiClearFastConnect *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_clear_fast_connect__pack + (const RpcReqWifiClearFastConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_clear_fast_connect__pack_to_buffer + (const RpcReqWifiClearFastConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiClearFastConnect * + rpc__req__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiClearFastConnect *) + protobuf_c_message_unpack (&rpc__req__wifi_clear_fast_connect__descriptor, + allocator, len, data); +} +void rpc__req__wifi_clear_fast_connect__free_unpacked + (RpcReqWifiClearFastConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_clear_fast_connect__init + (RpcRespWifiClearFastConnect *message) +{ + static const RpcRespWifiClearFastConnect init_value = RPC__RESP__WIFI_CLEAR_FAST_CONNECT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_clear_fast_connect__get_packed_size + (const RpcRespWifiClearFastConnect *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_clear_fast_connect__pack + (const RpcRespWifiClearFastConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_clear_fast_connect__pack_to_buffer + (const RpcRespWifiClearFastConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiClearFastConnect * + rpc__resp__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiClearFastConnect *) + protobuf_c_message_unpack (&rpc__resp__wifi_clear_fast_connect__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_clear_fast_connect__free_unpacked + (RpcRespWifiClearFastConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_deauth_sta__init + (RpcReqWifiDeauthSta *message) +{ + static const RpcReqWifiDeauthSta init_value = RPC__REQ__WIFI_DEAUTH_STA__INIT; + *message = init_value; +} +size_t rpc__req__wifi_deauth_sta__get_packed_size + (const RpcReqWifiDeauthSta *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_deauth_sta__pack + (const RpcReqWifiDeauthSta *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_deauth_sta__pack_to_buffer + (const RpcReqWifiDeauthSta *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiDeauthSta * + rpc__req__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiDeauthSta *) + protobuf_c_message_unpack (&rpc__req__wifi_deauth_sta__descriptor, + allocator, len, data); +} +void rpc__req__wifi_deauth_sta__free_unpacked + (RpcReqWifiDeauthSta *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_deauth_sta__init + (RpcRespWifiDeauthSta *message) +{ + static const RpcRespWifiDeauthSta init_value = RPC__RESP__WIFI_DEAUTH_STA__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_deauth_sta__get_packed_size + (const RpcRespWifiDeauthSta *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_deauth_sta__pack + (const RpcRespWifiDeauthSta *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_deauth_sta__pack_to_buffer + (const RpcRespWifiDeauthSta *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiDeauthSta * + rpc__resp__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiDeauthSta *) + protobuf_c_message_unpack (&rpc__resp__wifi_deauth_sta__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_deauth_sta__free_unpacked + (RpcRespWifiDeauthSta *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_ap_info__init + (RpcReqWifiStaGetApInfo *message) +{ + static const RpcReqWifiStaGetApInfo init_value = RPC__REQ__WIFI_STA_GET_AP_INFO__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_ap_info__get_packed_size + (const RpcReqWifiStaGetApInfo *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_ap_info__pack + (const RpcReqWifiStaGetApInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_ap_info__pack_to_buffer + (const RpcReqWifiStaGetApInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetApInfo * + rpc__req__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetApInfo *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_ap_info__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_ap_info__free_unpacked + (RpcReqWifiStaGetApInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_ap_info__init + (RpcRespWifiStaGetApInfo *message) +{ + static const RpcRespWifiStaGetApInfo init_value = RPC__RESP__WIFI_STA_GET_AP_INFO__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_ap_info__get_packed_size + (const RpcRespWifiStaGetApInfo *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_ap_info__pack + (const RpcRespWifiStaGetApInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_ap_info__pack_to_buffer + (const RpcRespWifiStaGetApInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetApInfo * + rpc__resp__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetApInfo *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_ap_info__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_ap_info__free_unpacked + (RpcRespWifiStaGetApInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_protocol__init + (RpcReqWifiSetProtocol *message) +{ + static const RpcReqWifiSetProtocol init_value = RPC__REQ__WIFI_SET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_protocol__get_packed_size + (const RpcReqWifiSetProtocol *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_protocol__pack + (const RpcReqWifiSetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_protocol__pack_to_buffer + (const RpcReqWifiSetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetProtocol * + rpc__req__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetProtocol *) + protobuf_c_message_unpack (&rpc__req__wifi_set_protocol__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_protocol__free_unpacked + (RpcReqWifiSetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_protocol__init + (RpcRespWifiSetProtocol *message) +{ + static const RpcRespWifiSetProtocol init_value = RPC__RESP__WIFI_SET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_protocol__get_packed_size + (const RpcRespWifiSetProtocol *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_protocol__pack + (const RpcRespWifiSetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_protocol__pack_to_buffer + (const RpcRespWifiSetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetProtocol * + rpc__resp__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetProtocol *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_protocol__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_protocol__free_unpacked + (RpcRespWifiSetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_protocol__init + (RpcReqWifiGetProtocol *message) +{ + static const RpcReqWifiGetProtocol init_value = RPC__REQ__WIFI_GET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_protocol__get_packed_size + (const RpcReqWifiGetProtocol *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_protocol__pack + (const RpcReqWifiGetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_protocol__pack_to_buffer + (const RpcReqWifiGetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetProtocol * + rpc__req__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetProtocol *) + protobuf_c_message_unpack (&rpc__req__wifi_get_protocol__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_protocol__free_unpacked + (RpcReqWifiGetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_protocol__init + (RpcRespWifiGetProtocol *message) +{ + static const RpcRespWifiGetProtocol init_value = RPC__RESP__WIFI_GET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_protocol__get_packed_size + (const RpcRespWifiGetProtocol *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_protocol__pack + (const RpcRespWifiGetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_protocol__pack_to_buffer + (const RpcRespWifiGetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetProtocol * + rpc__resp__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetProtocol *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_protocol__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_protocol__free_unpacked + (RpcRespWifiGetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_bandwidth__init + (RpcReqWifiSetBandwidth *message) +{ + static const RpcReqWifiSetBandwidth init_value = RPC__REQ__WIFI_SET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_bandwidth__get_packed_size + (const RpcReqWifiSetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_bandwidth__pack + (const RpcReqWifiSetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_bandwidth__pack_to_buffer + (const RpcReqWifiSetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBandwidth * + rpc__req__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBandwidth *) + protobuf_c_message_unpack (&rpc__req__wifi_set_bandwidth__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_bandwidth__free_unpacked + (RpcReqWifiSetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_bandwidth__init + (RpcRespWifiSetBandwidth *message) +{ + static const RpcRespWifiSetBandwidth init_value = RPC__RESP__WIFI_SET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_bandwidth__get_packed_size + (const RpcRespWifiSetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_bandwidth__pack + (const RpcRespWifiSetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_bandwidth__pack_to_buffer + (const RpcRespWifiSetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBandwidth * + rpc__resp__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBandwidth *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_bandwidth__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_bandwidth__free_unpacked + (RpcRespWifiSetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_bandwidth__init + (RpcReqWifiGetBandwidth *message) +{ + static const RpcReqWifiGetBandwidth init_value = RPC__REQ__WIFI_GET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_bandwidth__get_packed_size + (const RpcReqWifiGetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_bandwidth__pack + (const RpcReqWifiGetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_bandwidth__pack_to_buffer + (const RpcReqWifiGetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBandwidth * + rpc__req__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBandwidth *) + protobuf_c_message_unpack (&rpc__req__wifi_get_bandwidth__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_bandwidth__free_unpacked + (RpcReqWifiGetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_bandwidth__init + (RpcRespWifiGetBandwidth *message) +{ + static const RpcRespWifiGetBandwidth init_value = RPC__RESP__WIFI_GET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_bandwidth__get_packed_size + (const RpcRespWifiGetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_bandwidth__pack + (const RpcRespWifiGetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_bandwidth__pack_to_buffer + (const RpcRespWifiGetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBandwidth * + rpc__resp__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBandwidth *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_bandwidth__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_bandwidth__free_unpacked + (RpcRespWifiGetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_channel__init + (RpcReqWifiSetChannel *message) +{ + static const RpcReqWifiSetChannel init_value = RPC__REQ__WIFI_SET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_channel__get_packed_size + (const RpcReqWifiSetChannel *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_channel__pack + (const RpcReqWifiSetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_channel__pack_to_buffer + (const RpcReqWifiSetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetChannel * + rpc__req__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetChannel *) + protobuf_c_message_unpack (&rpc__req__wifi_set_channel__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_channel__free_unpacked + (RpcReqWifiSetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_channel__init + (RpcRespWifiSetChannel *message) +{ + static const RpcRespWifiSetChannel init_value = RPC__RESP__WIFI_SET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_channel__get_packed_size + (const RpcRespWifiSetChannel *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_channel__pack + (const RpcRespWifiSetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_channel__pack_to_buffer + (const RpcRespWifiSetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetChannel * + rpc__resp__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetChannel *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_channel__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_channel__free_unpacked + (RpcRespWifiSetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_channel__init + (RpcReqWifiGetChannel *message) +{ + static const RpcReqWifiGetChannel init_value = RPC__REQ__WIFI_GET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_channel__get_packed_size + (const RpcReqWifiGetChannel *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_channel__pack + (const RpcReqWifiGetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_channel__pack_to_buffer + (const RpcReqWifiGetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetChannel * + rpc__req__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetChannel *) + protobuf_c_message_unpack (&rpc__req__wifi_get_channel__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_channel__free_unpacked + (RpcReqWifiGetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_channel__init + (RpcRespWifiGetChannel *message) +{ + static const RpcRespWifiGetChannel init_value = RPC__RESP__WIFI_GET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_channel__get_packed_size + (const RpcRespWifiGetChannel *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_channel__pack + (const RpcRespWifiGetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_channel__pack_to_buffer + (const RpcRespWifiGetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetChannel * + rpc__resp__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetChannel *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_channel__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_channel__free_unpacked + (RpcRespWifiGetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_storage__init + (RpcReqWifiSetStorage *message) +{ + static const RpcReqWifiSetStorage init_value = RPC__REQ__WIFI_SET_STORAGE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_storage__get_packed_size + (const RpcReqWifiSetStorage *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_storage__pack + (const RpcReqWifiSetStorage *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_storage__pack_to_buffer + (const RpcReqWifiSetStorage *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetStorage * + rpc__req__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetStorage *) + protobuf_c_message_unpack (&rpc__req__wifi_set_storage__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_storage__free_unpacked + (RpcReqWifiSetStorage *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_storage__init + (RpcRespWifiSetStorage *message) +{ + static const RpcRespWifiSetStorage init_value = RPC__RESP__WIFI_SET_STORAGE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_storage__get_packed_size + (const RpcRespWifiSetStorage *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_storage__pack + (const RpcRespWifiSetStorage *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_storage__pack_to_buffer + (const RpcRespWifiSetStorage *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetStorage * + rpc__resp__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetStorage *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_storage__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_storage__free_unpacked + (RpcRespWifiSetStorage *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_country_code__init + (RpcReqWifiSetCountryCode *message) +{ + static const RpcReqWifiSetCountryCode init_value = RPC__REQ__WIFI_SET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_country_code__get_packed_size + (const RpcReqWifiSetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_country_code__pack + (const RpcReqWifiSetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_country_code__pack_to_buffer + (const RpcReqWifiSetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetCountryCode * + rpc__req__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetCountryCode *) + protobuf_c_message_unpack (&rpc__req__wifi_set_country_code__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_country_code__free_unpacked + (RpcReqWifiSetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_country_code__init + (RpcRespWifiSetCountryCode *message) +{ + static const RpcRespWifiSetCountryCode init_value = RPC__RESP__WIFI_SET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_country_code__get_packed_size + (const RpcRespWifiSetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_country_code__pack + (const RpcRespWifiSetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_country_code__pack_to_buffer + (const RpcRespWifiSetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetCountryCode * + rpc__resp__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetCountryCode *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_country_code__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_country_code__free_unpacked + (RpcRespWifiSetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_country_code__init + (RpcReqWifiGetCountryCode *message) +{ + static const RpcReqWifiGetCountryCode init_value = RPC__REQ__WIFI_GET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_country_code__get_packed_size + (const RpcReqWifiGetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_country_code__pack + (const RpcReqWifiGetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_country_code__pack_to_buffer + (const RpcReqWifiGetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetCountryCode * + rpc__req__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetCountryCode *) + protobuf_c_message_unpack (&rpc__req__wifi_get_country_code__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_country_code__free_unpacked + (RpcReqWifiGetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_country_code__init + (RpcRespWifiGetCountryCode *message) +{ + static const RpcRespWifiGetCountryCode init_value = RPC__RESP__WIFI_GET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_country_code__get_packed_size + (const RpcRespWifiGetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_country_code__pack + (const RpcRespWifiGetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_country_code__pack_to_buffer + (const RpcRespWifiGetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetCountryCode * + rpc__resp__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetCountryCode *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_country_code__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_country_code__free_unpacked + (RpcRespWifiGetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_country__init + (RpcReqWifiSetCountry *message) +{ + static const RpcReqWifiSetCountry init_value = RPC__REQ__WIFI_SET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_country__get_packed_size + (const RpcReqWifiSetCountry *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_country__pack + (const RpcReqWifiSetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_country__pack_to_buffer + (const RpcReqWifiSetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetCountry * + rpc__req__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetCountry *) + protobuf_c_message_unpack (&rpc__req__wifi_set_country__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_country__free_unpacked + (RpcReqWifiSetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_country__init + (RpcRespWifiSetCountry *message) +{ + static const RpcRespWifiSetCountry init_value = RPC__RESP__WIFI_SET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_country__get_packed_size + (const RpcRespWifiSetCountry *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_country__pack + (const RpcRespWifiSetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_country__pack_to_buffer + (const RpcRespWifiSetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetCountry * + rpc__resp__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetCountry *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_country__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_country__free_unpacked + (RpcRespWifiSetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_country__init + (RpcReqWifiGetCountry *message) +{ + static const RpcReqWifiGetCountry init_value = RPC__REQ__WIFI_GET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_country__get_packed_size + (const RpcReqWifiGetCountry *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_country__pack + (const RpcReqWifiGetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_country__pack_to_buffer + (const RpcReqWifiGetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetCountry * + rpc__req__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetCountry *) + protobuf_c_message_unpack (&rpc__req__wifi_get_country__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_country__free_unpacked + (RpcReqWifiGetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_country__init + (RpcRespWifiGetCountry *message) +{ + static const RpcRespWifiGetCountry init_value = RPC__RESP__WIFI_GET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_country__get_packed_size + (const RpcRespWifiGetCountry *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_country__pack + (const RpcRespWifiGetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_country__pack_to_buffer + (const RpcRespWifiGetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetCountry * + rpc__resp__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetCountry *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_country__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_country__free_unpacked + (RpcRespWifiGetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_ap_get_sta_list__init + (RpcReqWifiApGetStaList *message) +{ + static const RpcReqWifiApGetStaList init_value = RPC__REQ__WIFI_AP_GET_STA_LIST__INIT; + *message = init_value; +} +size_t rpc__req__wifi_ap_get_sta_list__get_packed_size + (const RpcReqWifiApGetStaList *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_ap_get_sta_list__pack + (const RpcReqWifiApGetStaList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_ap_get_sta_list__pack_to_buffer + (const RpcReqWifiApGetStaList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiApGetStaList * + rpc__req__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiApGetStaList *) + protobuf_c_message_unpack (&rpc__req__wifi_ap_get_sta_list__descriptor, + allocator, len, data); +} +void rpc__req__wifi_ap_get_sta_list__free_unpacked + (RpcReqWifiApGetStaList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_ap_get_sta_list__init + (RpcRespWifiApGetStaList *message) +{ + static const RpcRespWifiApGetStaList init_value = RPC__RESP__WIFI_AP_GET_STA_LIST__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_ap_get_sta_list__get_packed_size + (const RpcRespWifiApGetStaList *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_ap_get_sta_list__pack + (const RpcRespWifiApGetStaList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_ap_get_sta_list__pack_to_buffer + (const RpcRespWifiApGetStaList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiApGetStaList * + rpc__resp__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiApGetStaList *) + protobuf_c_message_unpack (&rpc__resp__wifi_ap_get_sta_list__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_ap_get_sta_list__free_unpacked + (RpcRespWifiApGetStaList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_ap_get_sta_aid__init + (RpcReqWifiApGetStaAid *message) +{ + static const RpcReqWifiApGetStaAid init_value = RPC__REQ__WIFI_AP_GET_STA_AID__INIT; + *message = init_value; +} +size_t rpc__req__wifi_ap_get_sta_aid__get_packed_size + (const RpcReqWifiApGetStaAid *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_ap_get_sta_aid__pack + (const RpcReqWifiApGetStaAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcReqWifiApGetStaAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiApGetStaAid * + rpc__req__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiApGetStaAid *) + protobuf_c_message_unpack (&rpc__req__wifi_ap_get_sta_aid__descriptor, + allocator, len, data); +} +void rpc__req__wifi_ap_get_sta_aid__free_unpacked + (RpcReqWifiApGetStaAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_negotiated_phymode__init + (RpcReqWifiStaGetNegotiatedPhymode *message) +{ + static const RpcReqWifiStaGetNegotiatedPhymode init_value = RPC__REQ__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcReqWifiStaGetNegotiatedPhymode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack + (const RpcReqWifiStaGetNegotiatedPhymode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetNegotiatedPhymode * + rpc__req__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetNegotiatedPhymode *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_negotiated_phymode__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_negotiated_phymode__init + (RpcRespWifiStaGetNegotiatedPhymode *message) +{ + static const RpcRespWifiStaGetNegotiatedPhymode init_value = RPC__RESP__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcRespWifiStaGetNegotiatedPhymode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack + (const RpcRespWifiStaGetNegotiatedPhymode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetNegotiatedPhymode * + rpc__resp__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetNegotiatedPhymode *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_negotiated_phymode__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_ap_get_sta_aid__init + (RpcRespWifiApGetStaAid *message) +{ + static const RpcRespWifiApGetStaAid init_value = RPC__RESP__WIFI_AP_GET_STA_AID__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_ap_get_sta_aid__get_packed_size + (const RpcRespWifiApGetStaAid *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_ap_get_sta_aid__pack + (const RpcRespWifiApGetStaAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcRespWifiApGetStaAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiApGetStaAid * + rpc__resp__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiApGetStaAid *) + protobuf_c_message_unpack (&rpc__resp__wifi_ap_get_sta_aid__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_ap_get_sta_aid__free_unpacked + (RpcRespWifiApGetStaAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_rssi__init + (RpcReqWifiStaGetRssi *message) +{ + static const RpcReqWifiStaGetRssi init_value = RPC__REQ__WIFI_STA_GET_RSSI__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_rssi__get_packed_size + (const RpcReqWifiStaGetRssi *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_rssi__pack + (const RpcReqWifiStaGetRssi *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_rssi__pack_to_buffer + (const RpcReqWifiStaGetRssi *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetRssi * + rpc__req__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetRssi *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_rssi__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_rssi__free_unpacked + (RpcReqWifiStaGetRssi *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_rssi__init + (RpcRespWifiStaGetRssi *message) +{ + static const RpcRespWifiStaGetRssi init_value = RPC__RESP__WIFI_STA_GET_RSSI__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_rssi__get_packed_size + (const RpcRespWifiStaGetRssi *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_rssi__pack + (const RpcRespWifiStaGetRssi *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_rssi__pack_to_buffer + (const RpcRespWifiStaGetRssi *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetRssi * + rpc__resp__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetRssi *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_rssi__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_rssi__free_unpacked + (RpcRespWifiStaGetRssi *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_aid__init + (RpcReqWifiStaGetAid *message) +{ + static const RpcReqWifiStaGetAid init_value = RPC__REQ__WIFI_STA_GET_AID__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_aid__get_packed_size + (const RpcReqWifiStaGetAid *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_aid__pack + (const RpcReqWifiStaGetAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_aid__pack_to_buffer + (const RpcReqWifiStaGetAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetAid * + rpc__req__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetAid *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_aid__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_aid__free_unpacked + (RpcReqWifiStaGetAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_aid__init + (RpcRespWifiStaGetAid *message) +{ + static const RpcRespWifiStaGetAid init_value = RPC__RESP__WIFI_STA_GET_AID__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_aid__get_packed_size + (const RpcRespWifiStaGetAid *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_aid__pack + (const RpcRespWifiStaGetAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_aid__pack_to_buffer + (const RpcRespWifiStaGetAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetAid * + rpc__resp__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetAid *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_aid__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_aid__free_unpacked + (RpcRespWifiStaGetAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_protocols__init + (RpcReqWifiSetProtocols *message) +{ + static const RpcReqWifiSetProtocols init_value = RPC__REQ__WIFI_SET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_protocols__get_packed_size + (const RpcReqWifiSetProtocols *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_protocols__pack + (const RpcReqWifiSetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_protocols__pack_to_buffer + (const RpcReqWifiSetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetProtocols * + rpc__req__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetProtocols *) + protobuf_c_message_unpack (&rpc__req__wifi_set_protocols__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_protocols__free_unpacked + (RpcReqWifiSetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_protocols__init + (RpcRespWifiSetProtocols *message) +{ + static const RpcRespWifiSetProtocols init_value = RPC__RESP__WIFI_SET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_protocols__get_packed_size + (const RpcRespWifiSetProtocols *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_protocols__pack + (const RpcRespWifiSetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_protocols__pack_to_buffer + (const RpcRespWifiSetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetProtocols * + rpc__resp__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetProtocols *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_protocols__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_protocols__free_unpacked + (RpcRespWifiSetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_protocols__init + (RpcReqWifiGetProtocols *message) +{ + static const RpcReqWifiGetProtocols init_value = RPC__REQ__WIFI_GET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_protocols__get_packed_size + (const RpcReqWifiGetProtocols *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_protocols__pack + (const RpcReqWifiGetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_protocols__pack_to_buffer + (const RpcReqWifiGetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetProtocols * + rpc__req__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetProtocols *) + protobuf_c_message_unpack (&rpc__req__wifi_get_protocols__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_protocols__free_unpacked + (RpcReqWifiGetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_protocols__init + (RpcRespWifiGetProtocols *message) +{ + static const RpcRespWifiGetProtocols init_value = RPC__RESP__WIFI_GET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_protocols__get_packed_size + (const RpcRespWifiGetProtocols *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_protocols__pack + (const RpcRespWifiGetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_protocols__pack_to_buffer + (const RpcRespWifiGetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetProtocols * + rpc__resp__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetProtocols *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_protocols__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_protocols__free_unpacked + (RpcRespWifiGetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_bandwidths__init + (RpcReqWifiSetBandwidths *message) +{ + static const RpcReqWifiSetBandwidths init_value = RPC__REQ__WIFI_SET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_bandwidths__get_packed_size + (const RpcReqWifiSetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_bandwidths__pack + (const RpcReqWifiSetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_bandwidths__pack_to_buffer + (const RpcReqWifiSetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBandwidths * + rpc__req__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBandwidths *) + protobuf_c_message_unpack (&rpc__req__wifi_set_bandwidths__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_bandwidths__free_unpacked + (RpcReqWifiSetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_bandwidths__init + (RpcRespWifiSetBandwidths *message) +{ + static const RpcRespWifiSetBandwidths init_value = RPC__RESP__WIFI_SET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_bandwidths__get_packed_size + (const RpcRespWifiSetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_bandwidths__pack + (const RpcRespWifiSetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_bandwidths__pack_to_buffer + (const RpcRespWifiSetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBandwidths * + rpc__resp__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBandwidths *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_bandwidths__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_bandwidths__free_unpacked + (RpcRespWifiSetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_bandwidths__init + (RpcReqWifiGetBandwidths *message) +{ + static const RpcReqWifiGetBandwidths init_value = RPC__REQ__WIFI_GET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_bandwidths__get_packed_size + (const RpcReqWifiGetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_bandwidths__pack + (const RpcReqWifiGetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_bandwidths__pack_to_buffer + (const RpcReqWifiGetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBandwidths * + rpc__req__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBandwidths *) + protobuf_c_message_unpack (&rpc__req__wifi_get_bandwidths__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_bandwidths__free_unpacked + (RpcReqWifiGetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_bandwidths__init + (RpcRespWifiGetBandwidths *message) +{ + static const RpcRespWifiGetBandwidths init_value = RPC__RESP__WIFI_GET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_bandwidths__get_packed_size + (const RpcRespWifiGetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_bandwidths__pack + (const RpcRespWifiGetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_bandwidths__pack_to_buffer + (const RpcRespWifiGetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBandwidths * + rpc__resp__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBandwidths *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_bandwidths__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_bandwidths__free_unpacked + (RpcRespWifiGetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_band__init + (RpcReqWifiSetBand *message) +{ + static const RpcReqWifiSetBand init_value = RPC__REQ__WIFI_SET_BAND__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_band__get_packed_size + (const RpcReqWifiSetBand *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_band__pack + (const RpcReqWifiSetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_band__pack_to_buffer + (const RpcReqWifiSetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBand * + rpc__req__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBand *) + protobuf_c_message_unpack (&rpc__req__wifi_set_band__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_band__free_unpacked + (RpcReqWifiSetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_band__init + (RpcRespWifiSetBand *message) +{ + static const RpcRespWifiSetBand init_value = RPC__RESP__WIFI_SET_BAND__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_band__get_packed_size + (const RpcRespWifiSetBand *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_band__pack + (const RpcRespWifiSetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_band__pack_to_buffer + (const RpcRespWifiSetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBand * + rpc__resp__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBand *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_band__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_band__free_unpacked + (RpcRespWifiSetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_band__init + (RpcReqWifiGetBand *message) +{ + static const RpcReqWifiGetBand init_value = RPC__REQ__WIFI_GET_BAND__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_band__get_packed_size + (const RpcReqWifiGetBand *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_band__pack + (const RpcReqWifiGetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_band__pack_to_buffer + (const RpcReqWifiGetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBand * + rpc__req__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBand *) + protobuf_c_message_unpack (&rpc__req__wifi_get_band__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_band__free_unpacked + (RpcReqWifiGetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_band__init + (RpcRespWifiGetBand *message) +{ + static const RpcRespWifiGetBand init_value = RPC__RESP__WIFI_GET_BAND__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_band__get_packed_size + (const RpcRespWifiGetBand *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_band__pack + (const RpcRespWifiGetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_band__pack_to_buffer + (const RpcRespWifiGetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBand * + rpc__resp__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBand *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_band__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_band__free_unpacked + (RpcRespWifiGetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_band_mode__init + (RpcReqWifiSetBandMode *message) +{ + static const RpcReqWifiSetBandMode init_value = RPC__REQ__WIFI_SET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_band_mode__get_packed_size + (const RpcReqWifiSetBandMode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_band_mode__pack + (const RpcReqWifiSetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_band_mode__pack_to_buffer + (const RpcReqWifiSetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBandMode * + rpc__req__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBandMode *) + protobuf_c_message_unpack (&rpc__req__wifi_set_band_mode__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_band_mode__free_unpacked + (RpcReqWifiSetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_band_mode__init + (RpcRespWifiSetBandMode *message) +{ + static const RpcRespWifiSetBandMode init_value = RPC__RESP__WIFI_SET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_band_mode__get_packed_size + (const RpcRespWifiSetBandMode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_band_mode__pack + (const RpcRespWifiSetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_band_mode__pack_to_buffer + (const RpcRespWifiSetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBandMode * + rpc__resp__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBandMode *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_band_mode__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_band_mode__free_unpacked + (RpcRespWifiSetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_band_mode__init + (RpcReqWifiGetBandMode *message) +{ + static const RpcReqWifiGetBandMode init_value = RPC__REQ__WIFI_GET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_band_mode__get_packed_size + (const RpcReqWifiGetBandMode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_band_mode__pack + (const RpcReqWifiGetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_band_mode__pack_to_buffer + (const RpcReqWifiGetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBandMode * + rpc__req__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBandMode *) + protobuf_c_message_unpack (&rpc__req__wifi_get_band_mode__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_band_mode__free_unpacked + (RpcReqWifiGetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_band_mode__init + (RpcRespWifiGetBandMode *message) +{ + static const RpcRespWifiGetBandMode init_value = RPC__RESP__WIFI_GET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_band_mode__get_packed_size + (const RpcRespWifiGetBandMode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_band_mode__pack + (const RpcRespWifiGetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_band_mode__pack_to_buffer + (const RpcRespWifiGetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBandMode * + rpc__resp__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBandMode *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_band_mode__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_band_mode__free_unpacked + (RpcRespWifiGetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_coprocessor_fw_version__init + (RpcReqGetCoprocessorFwVersion *message) +{ + static const RpcReqGetCoprocessorFwVersion init_value = RPC__REQ__GET_COPROCESSOR_FW_VERSION__INIT; + *message = init_value; +} +size_t rpc__req__get_coprocessor_fw_version__get_packed_size + (const RpcReqGetCoprocessorFwVersion *message) +{ + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_coprocessor_fw_version__pack + (const RpcReqGetCoprocessorFwVersion *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_coprocessor_fw_version__pack_to_buffer + (const RpcReqGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetCoprocessorFwVersion * + rpc__req__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetCoprocessorFwVersion *) + protobuf_c_message_unpack (&rpc__req__get_coprocessor_fw_version__descriptor, + allocator, len, data); +} +void rpc__req__get_coprocessor_fw_version__free_unpacked + (RpcReqGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_coprocessor_fw_version__init + (RpcRespGetCoprocessorFwVersion *message) +{ + static const RpcRespGetCoprocessorFwVersion init_value = RPC__RESP__GET_COPROCESSOR_FW_VERSION__INIT; + *message = init_value; +} +size_t rpc__resp__get_coprocessor_fw_version__get_packed_size + (const RpcRespGetCoprocessorFwVersion *message) +{ + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_coprocessor_fw_version__pack + (const RpcRespGetCoprocessorFwVersion *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_coprocessor_fw_version__pack_to_buffer + (const RpcRespGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetCoprocessorFwVersion * + rpc__resp__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetCoprocessorFwVersion *) + protobuf_c_message_unpack (&rpc__resp__get_coprocessor_fw_version__descriptor, + allocator, len, data); +} +void rpc__resp__get_coprocessor_fw_version__free_unpacked + (RpcRespGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__wifi_event_no_args__init + (RpcEventWifiEventNoArgs *message) +{ + static const RpcEventWifiEventNoArgs init_value = RPC__EVENT__WIFI_EVENT_NO_ARGS__INIT; + *message = init_value; +} +size_t rpc__event__wifi_event_no_args__get_packed_size + (const RpcEventWifiEventNoArgs *message) +{ + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__wifi_event_no_args__pack + (const RpcEventWifiEventNoArgs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__wifi_event_no_args__pack_to_buffer + (const RpcEventWifiEventNoArgs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventWifiEventNoArgs * + rpc__event__wifi_event_no_args__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventWifiEventNoArgs *) + protobuf_c_message_unpack (&rpc__event__wifi_event_no_args__descriptor, + allocator, len, data); +} +void rpc__event__wifi_event_no_args__free_unpacked + (RpcEventWifiEventNoArgs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__espinit__init + (RpcEventESPInit *message) +{ + static const RpcEventESPInit init_value = RPC__EVENT__ESPINIT__INIT; + *message = init_value; +} +size_t rpc__event__espinit__get_packed_size + (const RpcEventESPInit *message) +{ + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__espinit__pack + (const RpcEventESPInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__espinit__pack_to_buffer + (const RpcEventESPInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventESPInit * + rpc__event__espinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventESPInit *) + protobuf_c_message_unpack (&rpc__event__espinit__descriptor, + allocator, len, data); +} +void rpc__event__espinit__free_unpacked + (RpcEventESPInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__heartbeat__init + (RpcEventHeartbeat *message) +{ + static const RpcEventHeartbeat init_value = RPC__EVENT__HEARTBEAT__INIT; + *message = init_value; +} +size_t rpc__event__heartbeat__get_packed_size + (const RpcEventHeartbeat *message) +{ + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__heartbeat__pack + (const RpcEventHeartbeat *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__heartbeat__pack_to_buffer + (const RpcEventHeartbeat *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventHeartbeat * + rpc__event__heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventHeartbeat *) + protobuf_c_message_unpack (&rpc__event__heartbeat__descriptor, + allocator, len, data); +} +void rpc__event__heartbeat__free_unpacked + (RpcEventHeartbeat *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__ap__sta_disconnected__init + (RpcEventAPStaDisconnected *message) +{ + static const RpcEventAPStaDisconnected init_value = RPC__EVENT__AP__STA_DISCONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__ap__sta_disconnected__get_packed_size + (const RpcEventAPStaDisconnected *message) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__ap__sta_disconnected__pack + (const RpcEventAPStaDisconnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__ap__sta_disconnected__pack_to_buffer + (const RpcEventAPStaDisconnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventAPStaDisconnected * + rpc__event__ap__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventAPStaDisconnected *) + protobuf_c_message_unpack (&rpc__event__ap__sta_disconnected__descriptor, + allocator, len, data); +} +void rpc__event__ap__sta_disconnected__free_unpacked + (RpcEventAPStaDisconnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__ap__sta_connected__init + (RpcEventAPStaConnected *message) +{ + static const RpcEventAPStaConnected init_value = RPC__EVENT__AP__STA_CONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__ap__sta_connected__get_packed_size + (const RpcEventAPStaConnected *message) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__ap__sta_connected__pack + (const RpcEventAPStaConnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__ap__sta_connected__pack_to_buffer + (const RpcEventAPStaConnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventAPStaConnected * + rpc__event__ap__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventAPStaConnected *) + protobuf_c_message_unpack (&rpc__event__ap__sta_connected__descriptor, + allocator, len, data); +} +void rpc__event__ap__sta_connected__free_unpacked + (RpcEventAPStaConnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_scan_done__init + (RpcEventStaScanDone *message) +{ + static const RpcEventStaScanDone init_value = RPC__EVENT__STA_SCAN_DONE__INIT; + *message = init_value; +} +size_t rpc__event__sta_scan_done__get_packed_size + (const RpcEventStaScanDone *message) +{ + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_scan_done__pack + (const RpcEventStaScanDone *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_scan_done__pack_to_buffer + (const RpcEventStaScanDone *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaScanDone * + rpc__event__sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaScanDone *) + protobuf_c_message_unpack (&rpc__event__sta_scan_done__descriptor, + allocator, len, data); +} +void rpc__event__sta_scan_done__free_unpacked + (RpcEventStaScanDone *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_connected__init + (RpcEventStaConnected *message) +{ + static const RpcEventStaConnected init_value = RPC__EVENT__STA_CONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__sta_connected__get_packed_size + (const RpcEventStaConnected *message) +{ + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_connected__pack + (const RpcEventStaConnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_connected__pack_to_buffer + (const RpcEventStaConnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaConnected * + rpc__event__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaConnected *) + protobuf_c_message_unpack (&rpc__event__sta_connected__descriptor, + allocator, len, data); +} +void rpc__event__sta_connected__free_unpacked + (RpcEventStaConnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_disconnected__init + (RpcEventStaDisconnected *message) +{ + static const RpcEventStaDisconnected init_value = RPC__EVENT__STA_DISCONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__sta_disconnected__get_packed_size + (const RpcEventStaDisconnected *message) +{ + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_disconnected__pack + (const RpcEventStaDisconnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_disconnected__pack_to_buffer + (const RpcEventStaDisconnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaDisconnected * + rpc__event__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaDisconnected *) + protobuf_c_message_unpack (&rpc__event__sta_disconnected__descriptor, + allocator, len, data); +} +void rpc__event__sta_disconnected__free_unpacked + (RpcEventStaDisconnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__init + (Rpc *message) +{ + static const Rpc init_value = RPC__INIT; + *message = init_value; +} +size_t rpc__get_packed_size + (const Rpc *message) +{ + assert(message->base.descriptor == &rpc__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__pack + (const Rpc *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__pack_to_buffer + (const Rpc *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Rpc * + rpc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Rpc *) + protobuf_c_message_unpack (&rpc__descriptor, + allocator, len, data); +} +void rpc__free_unpacked + (Rpc *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor wifi_init_config__field_descriptors[20] = +{ + { + "static_rx_buf_num", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, static_rx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dynamic_rx_buf_num", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, dynamic_rx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tx_buf_type", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, tx_buf_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "static_tx_buf_num", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, static_tx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dynamic_tx_buf_num", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, dynamic_tx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cache_tx_buf_num", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, cache_tx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "csi_enable", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, csi_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ampdu_rx_enable", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, ampdu_rx_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ampdu_tx_enable", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, ampdu_tx_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "amsdu_tx_enable", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, amsdu_tx_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nvs_enable", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, nvs_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nano_enable", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, nano_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_ba_win", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, rx_ba_win), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "wifi_task_core_id", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, wifi_task_core_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "beacon_max_len", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, beacon_max_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mgmt_sbuf_num", + 16, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, mgmt_sbuf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_caps", + 17, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, feature_caps), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_disconnected_pm", + 18, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, sta_disconnected_pm), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "espnow_max_encrypt_num", + 19, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, espnow_max_encrypt_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "magic", + 20, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, magic), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_init_config__field_indices_by_name[] = { + 7, /* field[7] = ampdu_rx_enable */ + 8, /* field[8] = ampdu_tx_enable */ + 9, /* field[9] = amsdu_tx_enable */ + 14, /* field[14] = beacon_max_len */ + 5, /* field[5] = cache_tx_buf_num */ + 6, /* field[6] = csi_enable */ + 1, /* field[1] = dynamic_rx_buf_num */ + 4, /* field[4] = dynamic_tx_buf_num */ + 18, /* field[18] = espnow_max_encrypt_num */ + 16, /* field[16] = feature_caps */ + 19, /* field[19] = magic */ + 15, /* field[15] = mgmt_sbuf_num */ + 11, /* field[11] = nano_enable */ + 10, /* field[10] = nvs_enable */ + 12, /* field[12] = rx_ba_win */ + 17, /* field[17] = sta_disconnected_pm */ + 0, /* field[0] = static_rx_buf_num */ + 3, /* field[3] = static_tx_buf_num */ + 2, /* field[2] = tx_buf_type */ + 13, /* field[13] = wifi_task_core_id */ +}; +static const ProtobufCIntRange wifi_init_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 20 } +}; +const ProtobufCMessageDescriptor wifi_init_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_init_config", + "WifiInitConfig", + "WifiInitConfig", + "", + sizeof(WifiInitConfig), + 20, + wifi_init_config__field_descriptors, + wifi_init_config__field_indices_by_name, + 1, wifi_init_config__number_ranges, + (ProtobufCMessageInit) wifi_init_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_country__field_descriptors[5] = +{ + { + "cc", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCountry, cc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "schan", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, schan), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nchan", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, nchan), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "max_tx_power", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, max_tx_power), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "policy", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, policy), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_country__field_indices_by_name[] = { + 0, /* field[0] = cc */ + 3, /* field[3] = max_tx_power */ + 2, /* field[2] = nchan */ + 4, /* field[4] = policy */ + 1, /* field[1] = schan */ +}; +static const ProtobufCIntRange wifi_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_country", + "WifiCountry", + "WifiCountry", + "", + sizeof(WifiCountry), + 5, + wifi_country__field_descriptors, + wifi_country__field_indices_by_name, + 1, wifi_country__number_ranges, + (ProtobufCMessageInit) wifi_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_active_scan_time__field_descriptors[2] = +{ + { + "min", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiActiveScanTime, min), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "max", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiActiveScanTime, max), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_active_scan_time__field_indices_by_name[] = { + 1, /* field[1] = max */ + 0, /* field[0] = min */ +}; +static const ProtobufCIntRange wifi_active_scan_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_active_scan_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_active_scan_time", + "WifiActiveScanTime", + "WifiActiveScanTime", + "", + sizeof(WifiActiveScanTime), + 2, + wifi_active_scan_time__field_descriptors, + wifi_active_scan_time__field_indices_by_name, + 1, wifi_active_scan_time__number_ranges, + (ProtobufCMessageInit) wifi_active_scan_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_time__field_descriptors[2] = +{ + { + "active", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiScanTime, active), + &wifi_active_scan_time__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "passive", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanTime, passive), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_time__field_indices_by_name[] = { + 0, /* field[0] = active */ + 1, /* field[1] = passive */ +}; +static const ProtobufCIntRange wifi_scan_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_scan_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_time", + "WifiScanTime", + "WifiScanTime", + "", + sizeof(WifiScanTime), + 2, + wifi_scan_time__field_descriptors, + wifi_scan_time__field_indices_by_name, + 1, wifi_scan_time__number_ranges, + (ProtobufCMessageInit) wifi_scan_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_config__field_descriptors[7] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "show_hidden", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, show_hidden), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_type", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, scan_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_time", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, scan_time), + &wifi_scan_time__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "home_chan_dwell_time", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, home_chan_dwell_time), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_config__field_indices_by_name[] = { + 1, /* field[1] = bssid */ + 2, /* field[2] = channel */ + 6, /* field[6] = home_chan_dwell_time */ + 5, /* field[5] = scan_time */ + 4, /* field[4] = scan_type */ + 3, /* field[3] = show_hidden */ + 0, /* field[0] = ssid */ +}; +static const ProtobufCIntRange wifi_scan_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_scan_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_config", + "WifiScanConfig", + "WifiScanConfig", + "", + sizeof(WifiScanConfig), + 7, + wifi_scan_config__field_descriptors, + wifi_scan_config__field_indices_by_name, + 1, wifi_scan_config__number_ranges, + (ProtobufCMessageInit) wifi_scan_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_he_ap_info__field_descriptors[2] = +{ + { + "bitmask", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiHeApInfo, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid_index", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiHeApInfo, bssid_index), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_he_ap_info__field_indices_by_name[] = { + 0, /* field[0] = bitmask */ + 1, /* field[1] = bssid_index */ +}; +static const ProtobufCIntRange wifi_he_ap_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_he_ap_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_he_ap_info", + "WifiHeApInfo", + "WifiHeApInfo", + "", + sizeof(WifiHeApInfo), + 2, + wifi_he_ap_info__field_descriptors, + wifi_he_ap_info__field_indices_by_name, + 1, wifi_he_ap_info__number_ranges, + (ProtobufCMessageInit) wifi_he_ap_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ap_record__field_descriptors[15] = +{ + { + "bssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "primary", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, primary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "second", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, second), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pairwise_cipher", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, pairwise_cipher), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "group_cipher", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, group_cipher), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ant", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, ant), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "country", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, country), + &wifi_country__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "he_ap", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, he_ap), + &wifi_he_ap_info__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidth", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, bandwidth), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "vht_ch_freq1", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, vht_ch_freq1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "vht_ch_freq2", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, vht_ch_freq2), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ap_record__field_indices_by_name[] = { + 8, /* field[8] = ant */ + 5, /* field[5] = authmode */ + 12, /* field[12] = bandwidth */ + 9, /* field[9] = bitmask */ + 0, /* field[0] = bssid */ + 10, /* field[10] = country */ + 7, /* field[7] = group_cipher */ + 11, /* field[11] = he_ap */ + 6, /* field[6] = pairwise_cipher */ + 2, /* field[2] = primary */ + 4, /* field[4] = rssi */ + 3, /* field[3] = second */ + 1, /* field[1] = ssid */ + 13, /* field[13] = vht_ch_freq1 */ + 14, /* field[14] = vht_ch_freq2 */ +}; +static const ProtobufCIntRange wifi_ap_record__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 15 } +}; +const ProtobufCMessageDescriptor wifi_ap_record__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ap_record", + "WifiApRecord", + "WifiApRecord", + "", + sizeof(WifiApRecord), + 15, + wifi_ap_record__field_descriptors, + wifi_ap_record__field_indices_by_name, + 1, wifi_ap_record__number_ranges, + (ProtobufCMessageInit) wifi_ap_record__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_threshold__field_descriptors[2] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiScanThreshold, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiScanThreshold, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_threshold__field_indices_by_name[] = { + 1, /* field[1] = authmode */ + 0, /* field[0] = rssi */ +}; +static const ProtobufCIntRange wifi_scan_threshold__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_scan_threshold__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_threshold", + "WifiScanThreshold", + "WifiScanThreshold", + "", + sizeof(WifiScanThreshold), + 2, + wifi_scan_threshold__field_descriptors, + wifi_scan_threshold__field_indices_by_name, + 1, wifi_scan_threshold__number_ranges, + (ProtobufCMessageInit) wifi_scan_threshold__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_pmf_config__field_descriptors[2] = +{ + { + "capable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiPmfConfig, capable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "required", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiPmfConfig, required), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_pmf_config__field_indices_by_name[] = { + 0, /* field[0] = capable */ + 1, /* field[1] = required */ +}; +static const ProtobufCIntRange wifi_pmf_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_pmf_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_pmf_config", + "WifiPmfConfig", + "WifiPmfConfig", + "", + sizeof(WifiPmfConfig), + 2, + wifi_pmf_config__field_descriptors, + wifi_pmf_config__field_indices_by_name, + 1, wifi_pmf_config__number_ranges, + (ProtobufCMessageInit) wifi_pmf_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ap_config__field_descriptors[12] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "password", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_len", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ssid_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_hidden", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ssid_hidden), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "max_connection", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, max_connection), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "beacon_interval", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, beacon_interval), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pairwise_cipher", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, pairwise_cipher), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ftm_responder", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ftm_responder), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pmf_cfg", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, pmf_cfg), + &wifi_pmf_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_pwe_h2e", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, sae_pwe_h2e), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ap_config__field_indices_by_name[] = { + 4, /* field[4] = authmode */ + 7, /* field[7] = beacon_interval */ + 3, /* field[3] = channel */ + 9, /* field[9] = ftm_responder */ + 6, /* field[6] = max_connection */ + 8, /* field[8] = pairwise_cipher */ + 1, /* field[1] = password */ + 10, /* field[10] = pmf_cfg */ + 11, /* field[11] = sae_pwe_h2e */ + 0, /* field[0] = ssid */ + 5, /* field[5] = ssid_hidden */ + 2, /* field[2] = ssid_len */ +}; +static const ProtobufCIntRange wifi_ap_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 12 } +}; +const ProtobufCMessageDescriptor wifi_ap_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ap_config", + "WifiApConfig", + "WifiApConfig", + "", + sizeof(WifiApConfig), + 12, + wifi_ap_config__field_descriptors, + wifi_ap_config__field_indices_by_name, + 1, wifi_ap_config__number_ranges, + (ProtobufCMessageInit) wifi_ap_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_sta_config__field_descriptors[15] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "password", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_method", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, scan_method), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid_set", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, bssid_set), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "listen_interval", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, listen_interval), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sort_method", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sort_method), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "threshold", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, threshold), + &wifi_scan_threshold__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pmf_cfg", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, pmf_cfg), + &wifi_pmf_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_pwe_h2e", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sae_pwe_h2e), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "failure_retry_cnt", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, failure_retry_cnt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "he_bitmask", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, he_bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_h2e_identifier", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sae_h2e_identifier), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_sta_config__field_indices_by_name[] = { + 10, /* field[10] = bitmask */ + 4, /* field[4] = bssid */ + 3, /* field[3] = bssid_set */ + 5, /* field[5] = channel */ + 12, /* field[12] = failure_retry_cnt */ + 13, /* field[13] = he_bitmask */ + 6, /* field[6] = listen_interval */ + 1, /* field[1] = password */ + 9, /* field[9] = pmf_cfg */ + 14, /* field[14] = sae_h2e_identifier */ + 11, /* field[11] = sae_pwe_h2e */ + 2, /* field[2] = scan_method */ + 7, /* field[7] = sort_method */ + 0, /* field[0] = ssid */ + 8, /* field[8] = threshold */ +}; +static const ProtobufCIntRange wifi_sta_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 15 } +}; +const ProtobufCMessageDescriptor wifi_sta_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_sta_config", + "WifiStaConfig", + "WifiStaConfig", + "", + sizeof(WifiStaConfig), + 15, + wifi_sta_config__field_descriptors, + wifi_sta_config__field_indices_by_name, + 1, wifi_sta_config__number_ranges, + (ProtobufCMessageInit) wifi_sta_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_config__field_descriptors[2] = +{ + { + "ap", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiConfig, u_case), + offsetof(WifiConfig, ap), + &wifi_ap_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiConfig, u_case), + offsetof(WifiConfig, sta), + &wifi_sta_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_config__field_indices_by_name[] = { + 0, /* field[0] = ap */ + 1, /* field[1] = sta */ +}; +static const ProtobufCIntRange wifi_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_config", + "WifiConfig", + "WifiConfig", + "", + sizeof(WifiConfig), + 2, + wifi_config__field_descriptors, + wifi_config__field_indices_by_name, + 1, wifi_config__number_ranges, + (ProtobufCMessageInit) wifi_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_sta_info__field_descriptors[3] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaInfo, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaInfo, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaInfo, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_sta_info__field_indices_by_name[] = { + 2, /* field[2] = bitmask */ + 0, /* field[0] = mac */ + 1, /* field[1] = rssi */ +}; +static const ProtobufCIntRange wifi_sta_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor wifi_sta_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_sta_info", + "WifiStaInfo", + "WifiStaInfo", + "", + sizeof(WifiStaInfo), + 3, + wifi_sta_info__field_descriptors, + wifi_sta_info__field_indices_by_name, + 1, wifi_sta_info__number_ranges, + (ProtobufCMessageInit) wifi_sta_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_sta_list__field_descriptors[2] = +{ + { + "sta", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiStaList, n_sta), + offsetof(WifiStaList, sta), + &wifi_sta_info__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "num", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaList, num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_sta_list__field_indices_by_name[] = { + 1, /* field[1] = num */ + 0, /* field[0] = sta */ +}; +static const ProtobufCIntRange wifi_sta_list__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_sta_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_sta_list", + "WifiStaList", + "WifiStaList", + "", + sizeof(WifiStaList), + 2, + wifi_sta_list__field_descriptors, + wifi_sta_list__field_indices_by_name, + 1, wifi_sta_list__number_ranges, + (ProtobufCMessageInit) wifi_sta_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_pkt_rx_ctrl__field_descriptors[19] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rate", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, rate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sig_mode", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, sig_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mcs", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, mcs), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cwb", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, cwb), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "smoothing", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, smoothing), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "not_sounding", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, not_sounding), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aggregation", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, aggregation), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "stbc", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, stbc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "fec_coding", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, fec_coding), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sgi", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, sgi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "noise_floor", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, noise_floor), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ampdu_cnt", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, ampdu_cnt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "secondary_channel", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, secondary_channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "timestamp", + 16, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, timestamp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ant", + 17, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, ant), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sig_len", + 18, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, sig_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_state", + 19, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, rx_state), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_pkt_rx_ctrl__field_indices_by_name[] = { + 7, /* field[7] = aggregation */ + 12, /* field[12] = ampdu_cnt */ + 16, /* field[16] = ant */ + 13, /* field[13] = channel */ + 4, /* field[4] = cwb */ + 9, /* field[9] = fec_coding */ + 3, /* field[3] = mcs */ + 11, /* field[11] = noise_floor */ + 6, /* field[6] = not_sounding */ + 1, /* field[1] = rate */ + 0, /* field[0] = rssi */ + 18, /* field[18] = rx_state */ + 14, /* field[14] = secondary_channel */ + 10, /* field[10] = sgi */ + 17, /* field[17] = sig_len */ + 2, /* field[2] = sig_mode */ + 5, /* field[5] = smoothing */ + 8, /* field[8] = stbc */ + 15, /* field[15] = timestamp */ +}; +static const ProtobufCIntRange wifi_pkt_rx_ctrl__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 19 } +}; +const ProtobufCMessageDescriptor wifi_pkt_rx_ctrl__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_pkt_rx_ctrl", + "WifiPktRxCtrl", + "WifiPktRxCtrl", + "", + sizeof(WifiPktRxCtrl), + 19, + wifi_pkt_rx_ctrl__field_descriptors, + wifi_pkt_rx_ctrl__field_indices_by_name, + 1, wifi_pkt_rx_ctrl__number_ranges, + (ProtobufCMessageInit) wifi_pkt_rx_ctrl__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_promiscuous_pkt__field_descriptors[2] = +{ + { + "rx_ctrl", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiPromiscuousPkt, rx_ctrl), + &wifi_pkt_rx_ctrl__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "payload", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiPromiscuousPkt, payload), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_promiscuous_pkt__field_indices_by_name[] = { + 1, /* field[1] = payload */ + 0, /* field[0] = rx_ctrl */ +}; +static const ProtobufCIntRange wifi_promiscuous_pkt__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_promiscuous_pkt__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_promiscuous_pkt", + "WifiPromiscuousPkt", + "WifiPromiscuousPkt", + "", + sizeof(WifiPromiscuousPkt), + 2, + wifi_promiscuous_pkt__field_descriptors, + wifi_promiscuous_pkt__field_indices_by_name, + 1, wifi_promiscuous_pkt__number_ranges, + (ProtobufCMessageInit) wifi_promiscuous_pkt__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_promiscuous_filter__field_descriptors[1] = +{ + { + "filter_mask", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPromiscuousFilter, filter_mask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_promiscuous_filter__field_indices_by_name[] = { + 0, /* field[0] = filter_mask */ +}; +static const ProtobufCIntRange wifi_promiscuous_filter__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_promiscuous_filter__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_promiscuous_filter", + "WifiPromiscuousFilter", + "WifiPromiscuousFilter", + "", + sizeof(WifiPromiscuousFilter), + 1, + wifi_promiscuous_filter__field_descriptors, + wifi_promiscuous_filter__field_indices_by_name, + 1, wifi_promiscuous_filter__number_ranges, + (ProtobufCMessageInit) wifi_promiscuous_filter__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_csi_config__field_descriptors[7] = +{ + { + "lltf_en", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, lltf_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "htltf_en", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, htltf_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "stbc_htltf2_en", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, stbc_htltf2_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ltf_merge_en", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, ltf_merge_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel_filter_en", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, channel_filter_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "manu_scale", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, manu_scale), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "shift", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, shift), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_csi_config__field_indices_by_name[] = { + 4, /* field[4] = channel_filter_en */ + 1, /* field[1] = htltf_en */ + 0, /* field[0] = lltf_en */ + 3, /* field[3] = ltf_merge_en */ + 5, /* field[5] = manu_scale */ + 6, /* field[6] = shift */ + 2, /* field[2] = stbc_htltf2_en */ +}; +static const ProtobufCIntRange wifi_csi_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_csi_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_csi_config", + "WifiCsiConfig", + "WifiCsiConfig", + "", + sizeof(WifiCsiConfig), + 7, + wifi_csi_config__field_descriptors, + wifi_csi_config__field_indices_by_name, + 1, wifi_csi_config__number_ranges, + (ProtobufCMessageInit) wifi_csi_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_csi_info__field_descriptors[6] = +{ + { + "rx_ctrl", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, rx_ctrl), + &wifi_pkt_rx_ctrl__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dmac", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, dmac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "first_word_invalid", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, first_word_invalid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "buf", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, buf), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_csi_info__field_indices_by_name[] = { + 4, /* field[4] = buf */ + 2, /* field[2] = dmac */ + 3, /* field[3] = first_word_invalid */ + 5, /* field[5] = len */ + 1, /* field[1] = mac */ + 0, /* field[0] = rx_ctrl */ +}; +static const ProtobufCIntRange wifi_csi_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor wifi_csi_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_csi_info", + "WifiCsiInfo", + "WifiCsiInfo", + "", + sizeof(WifiCsiInfo), + 6, + wifi_csi_info__field_descriptors, + wifi_csi_info__field_indices_by_name, + 1, wifi_csi_info__number_ranges, + (ProtobufCMessageInit) wifi_csi_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ant_gpio__field_descriptors[2] = +{ + { + "gpio_select", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntGpio, gpio_select), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "gpio_num", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntGpio, gpio_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ant_gpio__field_indices_by_name[] = { + 1, /* field[1] = gpio_num */ + 0, /* field[0] = gpio_select */ +}; +static const ProtobufCIntRange wifi_ant_gpio__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_ant_gpio__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ant_gpio", + "WifiAntGpio", + "WifiAntGpio", + "", + sizeof(WifiAntGpio), + 2, + wifi_ant_gpio__field_descriptors, + wifi_ant_gpio__field_indices_by_name, + 1, wifi_ant_gpio__number_ranges, + (ProtobufCMessageInit) wifi_ant_gpio__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ant_gpio_config__field_descriptors[1] = +{ + { + "gpio_cfgs", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiAntGpioConfig, n_gpio_cfgs), + offsetof(WifiAntGpioConfig, gpio_cfgs), + &wifi_ant_gpio__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ant_gpio_config__field_indices_by_name[] = { + 0, /* field[0] = gpio_cfgs */ +}; +static const ProtobufCIntRange wifi_ant_gpio_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_ant_gpio_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ant_gpio_config", + "WifiAntGpioConfig", + "WifiAntGpioConfig", + "", + sizeof(WifiAntGpioConfig), + 1, + wifi_ant_gpio_config__field_descriptors, + wifi_ant_gpio_config__field_indices_by_name, + 1, wifi_ant_gpio_config__number_ranges, + (ProtobufCMessageInit) wifi_ant_gpio_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ant_config__field_descriptors[5] = +{ + { + "rx_ant_mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, rx_ant_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_ant_default", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, rx_ant_default), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tx_ant_mode", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, tx_ant_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled_ant0", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, enabled_ant0), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled_ant1", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, enabled_ant1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ant_config__field_indices_by_name[] = { + 3, /* field[3] = enabled_ant0 */ + 4, /* field[4] = enabled_ant1 */ + 1, /* field[1] = rx_ant_default */ + 0, /* field[0] = rx_ant_mode */ + 2, /* field[2] = tx_ant_mode */ +}; +static const ProtobufCIntRange wifi_ant_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_ant_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ant_config", + "WifiAntConfig", + "WifiAntConfig", + "", + sizeof(WifiAntConfig), + 5, + wifi_ant_config__field_descriptors, + wifi_ant_config__field_indices_by_name, + 1, wifi_ant_config__number_ranges, + (ProtobufCMessageInit) wifi_ant_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_action_tx_req__field_descriptors[5] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dest_mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, dest_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "no_ack", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, no_ack), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data_len", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, data_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, data), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_action_tx_req__field_indices_by_name[] = { + 4, /* field[4] = data */ + 3, /* field[3] = data_len */ + 1, /* field[1] = dest_mac */ + 0, /* field[0] = ifx */ + 2, /* field[2] = no_ack */ +}; +static const ProtobufCIntRange wifi_action_tx_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_action_tx_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_action_tx_req", + "WifiActionTxReq", + "WifiActionTxReq", + "", + sizeof(WifiActionTxReq), + 5, + wifi_action_tx_req__field_descriptors, + wifi_action_tx_req__field_indices_by_name, + 1, wifi_action_tx_req__number_ranges, + (ProtobufCMessageInit) wifi_action_tx_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ftm_initiator_cfg__field_descriptors[4] = +{ + { + "resp_mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, resp_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "frm_count", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, frm_count), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "burst_period", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, burst_period), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ftm_initiator_cfg__field_indices_by_name[] = { + 3, /* field[3] = burst_period */ + 1, /* field[1] = channel */ + 2, /* field[2] = frm_count */ + 0, /* field[0] = resp_mac */ +}; +static const ProtobufCIntRange wifi_ftm_initiator_cfg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor wifi_ftm_initiator_cfg__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ftm_initiator_cfg", + "WifiFtmInitiatorCfg", + "WifiFtmInitiatorCfg", + "", + sizeof(WifiFtmInitiatorCfg), + 4, + wifi_ftm_initiator_cfg__field_descriptors, + wifi_ftm_initiator_cfg__field_indices_by_name, + 1, wifi_ftm_initiator_cfg__number_ranges, + (ProtobufCMessageInit) wifi_ftm_initiator_cfg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_scan_done__field_descriptors[3] = +{ + { + "status", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaScanDone, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "number", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaScanDone, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_id", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaScanDone, scan_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_scan_done__field_indices_by_name[] = { + 1, /* field[1] = number */ + 2, /* field[2] = scan_id */ + 0, /* field[0] = status */ +}; +static const ProtobufCIntRange wifi_event_sta_scan_done__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_scan_done__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_scan_done", + "WifiEventStaScanDone", + "WifiEventStaScanDone", + "", + sizeof(WifiEventStaScanDone), + 3, + wifi_event_sta_scan_done__field_descriptors, + wifi_event_sta_scan_done__field_indices_by_name, + 1, wifi_event_sta_scan_done__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_scan_done__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_connected__field_descriptors[6] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, ssid_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_connected__field_indices_by_name[] = { + 5, /* field[5] = aid */ + 4, /* field[4] = authmode */ + 2, /* field[2] = bssid */ + 3, /* field[3] = channel */ + 0, /* field[0] = ssid */ + 1, /* field[1] = ssid_len */ +}; +static const ProtobufCIntRange wifi_event_sta_connected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_connected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_connected", + "WifiEventStaConnected", + "WifiEventStaConnected", + "", + sizeof(WifiEventStaConnected), + 6, + wifi_event_sta_connected__field_descriptors, + wifi_event_sta_connected__field_indices_by_name, + 1, wifi_event_sta_connected__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_connected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_disconnected__field_descriptors[5] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, ssid_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_disconnected__field_indices_by_name[] = { + 2, /* field[2] = bssid */ + 3, /* field[3] = reason */ + 4, /* field[4] = rssi */ + 0, /* field[0] = ssid */ + 1, /* field[1] = ssid_len */ +}; +static const ProtobufCIntRange wifi_event_sta_disconnected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_disconnected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_disconnected", + "WifiEventStaDisconnected", + "WifiEventStaDisconnected", + "", + sizeof(WifiEventStaDisconnected), + 5, + wifi_event_sta_disconnected__field_descriptors, + wifi_event_sta_disconnected__field_indices_by_name, + 1, wifi_event_sta_disconnected__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_disconnected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_authmode_change__field_descriptors[2] = +{ + { + "old_mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaAuthmodeChange, old_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "new_mode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaAuthmodeChange, new_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_authmode_change__field_indices_by_name[] = { + 1, /* field[1] = new_mode */ + 0, /* field[0] = old_mode */ +}; +static const ProtobufCIntRange wifi_event_sta_authmode_change__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_authmode_change__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_authmode_change", + "WifiEventStaAuthmodeChange", + "WifiEventStaAuthmodeChange", + "", + sizeof(WifiEventStaAuthmodeChange), + 2, + wifi_event_sta_authmode_change__field_descriptors, + wifi_event_sta_authmode_change__field_indices_by_name, + 1, wifi_event_sta_authmode_change__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_authmode_change__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_wps_er_pin__field_descriptors[1] = +{ + { + "pin_code", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaWpsErPin, pin_code), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_wps_er_pin__field_indices_by_name[] = { + 0, /* field[0] = pin_code */ +}; +static const ProtobufCIntRange wifi_event_sta_wps_er_pin__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_wps_er_pin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_wps_er_pin", + "WifiEventStaWpsErPin", + "WifiEventStaWpsErPin", + "", + sizeof(WifiEventStaWpsErPin), + 1, + wifi_event_sta_wps_er_pin__field_descriptors, + wifi_event_sta_wps_er_pin__field_indices_by_name, + 1, wifi_event_sta_wps_er_pin__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_wps_er_pin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor ap_cred__field_descriptors[2] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(ApCred, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "passphrase", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(ApCred, passphrase), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ap_cred__field_indices_by_name[] = { + 1, /* field[1] = passphrase */ + 0, /* field[0] = ssid */ +}; +static const ProtobufCIntRange ap_cred__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor ap_cred__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ap_cred", + "ApCred", + "ApCred", + "", + sizeof(ApCred), + 2, + ap_cred__field_descriptors, + ap_cred__field_indices_by_name, + 1, ap_cred__number_ranges, + (ProtobufCMessageInit) ap_cred__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_wps_er_success__field_descriptors[2] = +{ + { + "ap_cred_cnt", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaWpsErSuccess, ap_cred_cnt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_creds", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiEventStaWpsErSuccess, n_ap_creds), + offsetof(WifiEventStaWpsErSuccess, ap_creds), + &ap_cred__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_wps_er_success__field_indices_by_name[] = { + 0, /* field[0] = ap_cred_cnt */ + 1, /* field[1] = ap_creds */ +}; +static const ProtobufCIntRange wifi_event_sta_wps_er_success__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_wps_er_success__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_wps_er_success", + "WifiEventStaWpsErSuccess", + "WifiEventStaWpsErSuccess", + "", + sizeof(WifiEventStaWpsErSuccess), + 2, + wifi_event_sta_wps_er_success__field_descriptors, + wifi_event_sta_wps_er_success__field_indices_by_name, + 1, wifi_event_sta_wps_er_success__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_wps_er_success__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_probe_req_rx__field_descriptors[2] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventApProbeReqRx, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventApProbeReqRx, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_probe_req_rx__field_indices_by_name[] = { + 1, /* field[1] = mac */ + 0, /* field[0] = rssi */ +}; +static const ProtobufCIntRange wifi_event_ap_probe_req_rx__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_probe_req_rx__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_probe_req_rx", + "WifiEventApProbeReqRx", + "WifiEventApProbeReqRx", + "", + sizeof(WifiEventApProbeReqRx), + 2, + wifi_event_ap_probe_req_rx__field_descriptors, + wifi_event_ap_probe_req_rx__field_indices_by_name, + 1, wifi_event_ap_probe_req_rx__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_probe_req_rx__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_bss_rssi_low__field_descriptors[1] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventBssRssiLow, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_bss_rssi_low__field_indices_by_name[] = { + 0, /* field[0] = rssi */ +}; +static const ProtobufCIntRange wifi_event_bss_rssi_low__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_bss_rssi_low__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_bss_rssi_low", + "WifiEventBssRssiLow", + "WifiEventBssRssiLow", + "", + sizeof(WifiEventBssRssiLow), + 1, + wifi_event_bss_rssi_low__field_descriptors, + wifi_event_bss_rssi_low__field_indices_by_name, + 1, wifi_event_bss_rssi_low__number_ranges, + (ProtobufCMessageInit) wifi_event_bss_rssi_low__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ftm_report_entry__field_descriptors[7] = +{ + { + "dlog_token", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, dlog_token), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rtt", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, rtt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t1", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t2", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t2), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t3", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t3), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t4", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t4), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ftm_report_entry__field_indices_by_name[] = { + 0, /* field[0] = dlog_token */ + 1, /* field[1] = rssi */ + 2, /* field[2] = rtt */ + 3, /* field[3] = t1 */ + 4, /* field[4] = t2 */ + 5, /* field[5] = t3 */ + 6, /* field[6] = t4 */ +}; +static const ProtobufCIntRange wifi_ftm_report_entry__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_ftm_report_entry__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ftm_report_entry", + "WifiFtmReportEntry", + "WifiFtmReportEntry", + "", + sizeof(WifiFtmReportEntry), + 7, + wifi_ftm_report_entry__field_descriptors, + wifi_ftm_report_entry__field_indices_by_name, + 1, wifi_ftm_report_entry__number_ranges, + (ProtobufCMessageInit) wifi_ftm_report_entry__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ftm_report__field_descriptors[7] = +{ + { + "peer_mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, peer_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rtt_raw", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, rtt_raw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rtt_est", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, rtt_est), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dist_est", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, dist_est), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ftm_report_data", + 6, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiEventFtmReport, n_ftm_report_data), + offsetof(WifiEventFtmReport, ftm_report_data), + &wifi_ftm_report_entry__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ftm_report_num_entries", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, ftm_report_num_entries), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ftm_report__field_indices_by_name[] = { + 4, /* field[4] = dist_est */ + 5, /* field[5] = ftm_report_data */ + 6, /* field[6] = ftm_report_num_entries */ + 0, /* field[0] = peer_mac */ + 3, /* field[3] = rtt_est */ + 2, /* field[2] = rtt_raw */ + 1, /* field[1] = status */ +}; +static const ProtobufCIntRange wifi_event_ftm_report__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_event_ftm_report__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ftm_report", + "WifiEventFtmReport", + "WifiEventFtmReport", + "", + sizeof(WifiEventFtmReport), + 7, + wifi_event_ftm_report__field_descriptors, + wifi_event_ftm_report__field_indices_by_name, + 1, wifi_event_ftm_report__number_ranges, + (ProtobufCMessageInit) wifi_event_ftm_report__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_action_tx_status__field_descriptors[4] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "context", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, context), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "da", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, da), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_action_tx_status__field_indices_by_name[] = { + 1, /* field[1] = context */ + 2, /* field[2] = da */ + 0, /* field[0] = ifx */ + 3, /* field[3] = status */ +}; +static const ProtobufCIntRange wifi_event_action_tx_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor wifi_event_action_tx_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_action_tx_status", + "WifiEventActionTxStatus", + "WifiEventActionTxStatus", + "", + sizeof(WifiEventActionTxStatus), + 4, + wifi_event_action_tx_status__field_descriptors, + wifi_event_action_tx_status__field_indices_by_name, + 1, wifi_event_action_tx_status__number_ranges, + (ProtobufCMessageInit) wifi_event_action_tx_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_roc_done__field_descriptors[1] = +{ + { + "context", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventRocDone, context), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_roc_done__field_indices_by_name[] = { + 0, /* field[0] = context */ +}; +static const ProtobufCIntRange wifi_event_roc_done__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_roc_done__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_roc_done", + "WifiEventRocDone", + "WifiEventRocDone", + "", + sizeof(WifiEventRocDone), + 1, + wifi_event_roc_done__field_descriptors, + wifi_event_roc_done__field_indices_by_name, + 1, wifi_event_roc_done__number_ranges, + (ProtobufCMessageInit) wifi_event_roc_done__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_wps_rg_pin__field_descriptors[1] = +{ + { + "pin_code", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgPin, pin_code), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_wps_rg_pin__field_indices_by_name[] = { + 0, /* field[0] = pin_code */ +}; +static const ProtobufCIntRange wifi_event_ap_wps_rg_pin__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_pin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_wps_rg_pin", + "WifiEventApWpsRgPin", + "WifiEventApWpsRgPin", + "", + sizeof(WifiEventApWpsRgPin), + 1, + wifi_event_ap_wps_rg_pin__field_descriptors, + wifi_event_ap_wps_rg_pin__field_indices_by_name, + 1, wifi_event_ap_wps_rg_pin__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_wps_rg_pin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_wps_rg_fail_reason__field_descriptors[2] = +{ + { + "reason", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgFailReason, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "peer_macaddr", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgFailReason, peer_macaddr), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_wps_rg_fail_reason__field_indices_by_name[] = { + 1, /* field[1] = peer_macaddr */ + 0, /* field[0] = reason */ +}; +static const ProtobufCIntRange wifi_event_ap_wps_rg_fail_reason__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_fail_reason__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_wps_rg_fail_reason", + "WifiEventApWpsRgFailReason", + "WifiEventApWpsRgFailReason", + "", + sizeof(WifiEventApWpsRgFailReason), + 2, + wifi_event_ap_wps_rg_fail_reason__field_descriptors, + wifi_event_ap_wps_rg_fail_reason__field_indices_by_name, + 1, wifi_event_ap_wps_rg_fail_reason__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_wps_rg_fail_reason__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_wps_rg_success__field_descriptors[1] = +{ + { + "peer_macaddr", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgSuccess, peer_macaddr), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_wps_rg_success__field_indices_by_name[] = { + 0, /* field[0] = peer_macaddr */ +}; +static const ProtobufCIntRange wifi_event_ap_wps_rg_success__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_success__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_wps_rg_success", + "WifiEventApWpsRgSuccess", + "WifiEventApWpsRgSuccess", + "", + sizeof(WifiEventApWpsRgSuccess), + 1, + wifi_event_ap_wps_rg_success__field_descriptors, + wifi_event_ap_wps_rg_success__field_indices_by_name, + 1, wifi_event_ap_wps_rg_success__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_wps_rg_success__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_protocols__field_descriptors[2] = +{ + { + "ghz_2g", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiProtocols, ghz_2g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ghz_5g", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiProtocols, ghz_5g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_protocols__field_indices_by_name[] = { + 0, /* field[0] = ghz_2g */ + 1, /* field[1] = ghz_5g */ +}; +static const ProtobufCIntRange wifi_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_protocols", + "WifiProtocols", + "WifiProtocols", + "", + sizeof(WifiProtocols), + 2, + wifi_protocols__field_descriptors, + wifi_protocols__field_indices_by_name, + 1, wifi_protocols__number_ranges, + (ProtobufCMessageInit) wifi_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_bandwidths__field_descriptors[2] = +{ + { + "ghz_2g", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiBandwidths, ghz_2g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ghz_5g", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiBandwidths, ghz_5g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_bandwidths__field_indices_by_name[] = { + 0, /* field[0] = ghz_2g */ + 1, /* field[1] = ghz_5g */ +}; +static const ProtobufCIntRange wifi_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_bandwidths", + "WifiBandwidths", + "WifiBandwidths", + "", + sizeof(WifiBandwidths), + 2, + wifi_bandwidths__field_descriptors, + wifi_bandwidths__field_indices_by_name, + 1, wifi_bandwidths__number_ranges, + (ProtobufCMessageInit) wifi_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor connected_stalist__field_descriptors[2] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(ConnectedSTAList, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(ConnectedSTAList, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned connected_stalist__field_indices_by_name[] = { + 0, /* field[0] = mac */ + 1, /* field[1] = rssi */ +}; +static const ProtobufCIntRange connected_stalist__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor connected_stalist__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ConnectedSTAList", + "ConnectedSTAList", + "ConnectedSTAList", + "", + sizeof(ConnectedSTAList), + 2, + connected_stalist__field_descriptors, + connected_stalist__field_indices_by_name, + 1, connected_stalist__number_ranges, + (ProtobufCMessageInit) connected_stalist__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__get_mac_address__field_descriptors[1] = +{ + { + "mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqGetMacAddress, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__get_mac_address__field_indices_by_name[] = { + 0, /* field[0] = mode */ +}; +static const ProtobufCIntRange rpc__req__get_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__get_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetMacAddress", + "RpcReqGetMacAddress", + "RpcReqGetMacAddress", + "", + sizeof(RpcReqGetMacAddress), + 1, + rpc__req__get_mac_address__field_descriptors, + rpc__req__get_mac_address__field_indices_by_name, + 1, rpc__req__get_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__req__get_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_mac_address__field_descriptors[2] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMacAddress, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMacAddress, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_mac_address__field_indices_by_name[] = { + 0, /* field[0] = mac */ + 1, /* field[1] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetMacAddress", + "RpcRespGetMacAddress", + "RpcRespGetMacAddress", + "", + sizeof(RpcRespGetMacAddress), + 2, + rpc__resp__get_mac_address__field_descriptors, + rpc__resp__get_mac_address__field_indices_by_name, + 1, rpc__resp__get_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__get_mode__field_descriptors NULL +#define rpc__req__get_mode__field_indices_by_name NULL +#define rpc__req__get_mode__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__get_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetMode", + "RpcReqGetMode", + "RpcReqGetMode", + "", + sizeof(RpcReqGetMode), + 0, + rpc__req__get_mode__field_descriptors, + rpc__req__get_mode__field_indices_by_name, + 0, rpc__req__get_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__get_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_mode__field_descriptors[2] = +{ + { + "mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMode, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_mode__field_indices_by_name[] = { + 0, /* field[0] = mode */ + 1, /* field[1] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetMode", + "RpcRespGetMode", + "RpcRespGetMode", + "", + sizeof(RpcRespGetMode), + 2, + rpc__resp__get_mode__field_descriptors, + rpc__resp__get_mode__field_indices_by_name, + 1, rpc__resp__get_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_mode__field_descriptors[1] = +{ + { + "mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetMode, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_mode__field_indices_by_name[] = { + 0, /* field[0] = mode */ +}; +static const ProtobufCIntRange rpc__req__set_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__set_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetMode", + "RpcReqSetMode", + "RpcReqSetMode", + "", + sizeof(RpcReqSetMode), + 1, + rpc__req__set_mode__field_descriptors, + rpc__req__set_mode__field_indices_by_name, + 1, rpc__req__set_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__set_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_mode__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_mode__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetMode", + "RpcRespSetMode", + "RpcRespSetMode", + "", + sizeof(RpcRespSetMode), + 1, + rpc__resp__set_mode__field_descriptors, + rpc__resp__set_mode__field_indices_by_name, + 1, rpc__resp__set_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__get_ps__field_descriptors NULL +#define rpc__req__get_ps__field_indices_by_name NULL +#define rpc__req__get_ps__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__get_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetPs", + "RpcReqGetPs", + "RpcReqGetPs", + "", + sizeof(RpcReqGetPs), + 0, + rpc__req__get_ps__field_descriptors, + rpc__req__get_ps__field_indices_by_name, + 0, rpc__req__get_ps__number_ranges, + (ProtobufCMessageInit) rpc__req__get_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_ps__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetPs, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetPs, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_ps__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = type */ +}; +static const ProtobufCIntRange rpc__resp__get_ps__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetPs", + "RpcRespGetPs", + "RpcRespGetPs", + "", + sizeof(RpcRespGetPs), + 2, + rpc__resp__get_ps__field_descriptors, + rpc__resp__get_ps__field_indices_by_name, + 1, rpc__resp__get_ps__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_ps__field_descriptors[1] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetPs, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_ps__field_indices_by_name[] = { + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange rpc__req__set_ps__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__set_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetPs", + "RpcReqSetPs", + "RpcReqSetPs", + "", + sizeof(RpcReqSetPs), + 1, + rpc__req__set_ps__field_descriptors, + rpc__req__set_ps__field_indices_by_name, + 1, rpc__req__set_ps__number_ranges, + (ProtobufCMessageInit) rpc__req__set_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_ps__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetPs, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_ps__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_ps__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetPs", + "RpcRespSetPs", + "RpcRespSetPs", + "", + sizeof(RpcRespSetPs), + 1, + rpc__resp__set_ps__field_descriptors, + rpc__resp__set_ps__field_indices_by_name, + 1, rpc__resp__set_ps__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_mac_address__field_descriptors[2] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSetMacAddress, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetMacAddress, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_mac_address__field_indices_by_name[] = { + 0, /* field[0] = mac */ + 1, /* field[1] = mode */ +}; +static const ProtobufCIntRange rpc__req__set_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__set_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetMacAddress", + "RpcReqSetMacAddress", + "RpcReqSetMacAddress", + "", + sizeof(RpcReqSetMacAddress), + 2, + rpc__req__set_mac_address__field_descriptors, + rpc__req__set_mac_address__field_indices_by_name, + 1, rpc__req__set_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__req__set_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_mac_address__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetMacAddress, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_mac_address__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetMacAddress", + "RpcRespSetMacAddress", + "RpcRespSetMacAddress", + "", + sizeof(RpcRespSetMacAddress), + 1, + rpc__resp__set_mac_address__field_descriptors, + rpc__resp__set_mac_address__field_indices_by_name, + 1, rpc__resp__set_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__otabegin__field_descriptors NULL +#define rpc__req__otabegin__field_indices_by_name NULL +#define rpc__req__otabegin__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__otabegin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_OTABegin", + "RpcReqOTABegin", + "RpcReqOTABegin", + "", + sizeof(RpcReqOTABegin), + 0, + rpc__req__otabegin__field_descriptors, + rpc__req__otabegin__field_indices_by_name, + 0, rpc__req__otabegin__number_ranges, + (ProtobufCMessageInit) rpc__req__otabegin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__otabegin__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespOTABegin, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__otabegin__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__otabegin__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__otabegin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_OTABegin", + "RpcRespOTABegin", + "RpcRespOTABegin", + "", + sizeof(RpcRespOTABegin), + 1, + rpc__resp__otabegin__field_descriptors, + rpc__resp__otabegin__field_indices_by_name, + 1, rpc__resp__otabegin__number_ranges, + (ProtobufCMessageInit) rpc__resp__otabegin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__otawrite__field_descriptors[1] = +{ + { + "ota_data", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqOTAWrite, ota_data), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__otawrite__field_indices_by_name[] = { + 0, /* field[0] = ota_data */ +}; +static const ProtobufCIntRange rpc__req__otawrite__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__otawrite__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_OTAWrite", + "RpcReqOTAWrite", + "RpcReqOTAWrite", + "", + sizeof(RpcReqOTAWrite), + 1, + rpc__req__otawrite__field_descriptors, + rpc__req__otawrite__field_indices_by_name, + 1, rpc__req__otawrite__number_ranges, + (ProtobufCMessageInit) rpc__req__otawrite__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__otawrite__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespOTAWrite, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__otawrite__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__otawrite__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__otawrite__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_OTAWrite", + "RpcRespOTAWrite", + "RpcRespOTAWrite", + "", + sizeof(RpcRespOTAWrite), + 1, + rpc__resp__otawrite__field_descriptors, + rpc__resp__otawrite__field_indices_by_name, + 1, rpc__resp__otawrite__number_ranges, + (ProtobufCMessageInit) rpc__resp__otawrite__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__otaend__field_descriptors NULL +#define rpc__req__otaend__field_indices_by_name NULL +#define rpc__req__otaend__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__otaend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_OTAEnd", + "RpcReqOTAEnd", + "RpcReqOTAEnd", + "", + sizeof(RpcReqOTAEnd), + 0, + rpc__req__otaend__field_descriptors, + rpc__req__otaend__field_indices_by_name, + 0, rpc__req__otaend__number_ranges, + (ProtobufCMessageInit) rpc__req__otaend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__otaend__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespOTAEnd, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__otaend__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__otaend__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__otaend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_OTAEnd", + "RpcRespOTAEnd", + "RpcRespOTAEnd", + "", + sizeof(RpcRespOTAEnd), + 1, + rpc__resp__otaend__field_descriptors, + rpc__resp__otaend__field_indices_by_name, + 1, rpc__resp__otaend__number_ranges, + (ProtobufCMessageInit) rpc__resp__otaend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_max_tx_power__field_descriptors[1] = +{ + { + "power", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetMaxTxPower, power), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_max_tx_power__field_indices_by_name[] = { + 0, /* field[0] = power */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_max_tx_power__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetMaxTxPower", + "RpcReqWifiSetMaxTxPower", + "RpcReqWifiSetMaxTxPower", + "", + sizeof(RpcReqWifiSetMaxTxPower), + 1, + rpc__req__wifi_set_max_tx_power__field_descriptors, + rpc__req__wifi_set_max_tx_power__field_indices_by_name, + 1, rpc__req__wifi_set_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_max_tx_power__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetMaxTxPower, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_max_tx_power__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_max_tx_power__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetMaxTxPower", + "RpcRespWifiSetMaxTxPower", + "RpcRespWifiSetMaxTxPower", + "", + sizeof(RpcRespWifiSetMaxTxPower), + 1, + rpc__resp__wifi_set_max_tx_power__field_descriptors, + rpc__resp__wifi_set_max_tx_power__field_indices_by_name, + 1, rpc__resp__wifi_set_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_max_tx_power__field_descriptors NULL +#define rpc__req__wifi_get_max_tx_power__field_indices_by_name NULL +#define rpc__req__wifi_get_max_tx_power__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetMaxTxPower", + "RpcReqWifiGetMaxTxPower", + "RpcReqWifiGetMaxTxPower", + "", + sizeof(RpcReqWifiGetMaxTxPower), + 0, + rpc__req__wifi_get_max_tx_power__field_descriptors, + rpc__req__wifi_get_max_tx_power__field_indices_by_name, + 0, rpc__req__wifi_get_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_max_tx_power__field_descriptors[2] = +{ + { + "power", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetMaxTxPower, power), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetMaxTxPower, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_max_tx_power__field_indices_by_name[] = { + 0, /* field[0] = power */ + 1, /* field[1] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_max_tx_power__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetMaxTxPower", + "RpcRespWifiGetMaxTxPower", + "RpcRespWifiGetMaxTxPower", + "", + sizeof(RpcRespWifiGetMaxTxPower), + 2, + rpc__resp__wifi_get_max_tx_power__field_descriptors, + rpc__resp__wifi_get_max_tx_power__field_indices_by_name, + 1, rpc__resp__wifi_get_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__config_heartbeat__field_descriptors[2] = +{ + { + "enable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqConfigHeartbeat, enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "duration", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqConfigHeartbeat, duration), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__config_heartbeat__field_indices_by_name[] = { + 1, /* field[1] = duration */ + 0, /* field[0] = enable */ +}; +static const ProtobufCIntRange rpc__req__config_heartbeat__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__config_heartbeat__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_ConfigHeartbeat", + "RpcReqConfigHeartbeat", + "RpcReqConfigHeartbeat", + "", + sizeof(RpcReqConfigHeartbeat), + 2, + rpc__req__config_heartbeat__field_descriptors, + rpc__req__config_heartbeat__field_indices_by_name, + 1, rpc__req__config_heartbeat__number_ranges, + (ProtobufCMessageInit) rpc__req__config_heartbeat__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__config_heartbeat__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespConfigHeartbeat, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__config_heartbeat__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__config_heartbeat__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__config_heartbeat__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_ConfigHeartbeat", + "RpcRespConfigHeartbeat", + "RpcRespConfigHeartbeat", + "", + sizeof(RpcRespConfigHeartbeat), + 1, + rpc__resp__config_heartbeat__field_descriptors, + rpc__resp__config_heartbeat__field_indices_by_name, + 1, rpc__resp__config_heartbeat__number_ranges, + (ProtobufCMessageInit) rpc__resp__config_heartbeat__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_init__field_descriptors[1] = +{ + { + "cfg", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiInit, cfg), + &wifi_init_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_init__field_indices_by_name[] = { + 0, /* field[0] = cfg */ +}; +static const ProtobufCIntRange rpc__req__wifi_init__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_init__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiInit", + "RpcReqWifiInit", + "RpcReqWifiInit", + "", + sizeof(RpcReqWifiInit), + 1, + rpc__req__wifi_init__field_descriptors, + rpc__req__wifi_init__field_indices_by_name, + 1, rpc__req__wifi_init__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_init__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_init__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiInit, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_init__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_init__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_init__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiInit", + "RpcRespWifiInit", + "RpcRespWifiInit", + "", + sizeof(RpcRespWifiInit), + 1, + rpc__resp__wifi_init__field_descriptors, + rpc__resp__wifi_init__field_indices_by_name, + 1, rpc__resp__wifi_init__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_init__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_deinit__field_descriptors NULL +#define rpc__req__wifi_deinit__field_indices_by_name NULL +#define rpc__req__wifi_deinit__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_deinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiDeinit", + "RpcReqWifiDeinit", + "RpcReqWifiDeinit", + "", + sizeof(RpcReqWifiDeinit), + 0, + rpc__req__wifi_deinit__field_descriptors, + rpc__req__wifi_deinit__field_indices_by_name, + 0, rpc__req__wifi_deinit__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_deinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_deinit__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDeinit, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_deinit__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_deinit__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_deinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiDeinit", + "RpcRespWifiDeinit", + "RpcRespWifiDeinit", + "", + sizeof(RpcRespWifiDeinit), + 1, + rpc__resp__wifi_deinit__field_descriptors, + rpc__resp__wifi_deinit__field_indices_by_name, + 1, rpc__resp__wifi_deinit__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_deinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_config__field_descriptors[2] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetConfig, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cfg", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetConfig, cfg), + &wifi_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_config__field_indices_by_name[] = { + 1, /* field[1] = cfg */ + 0, /* field[0] = iface */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetConfig", + "RpcReqWifiSetConfig", + "RpcReqWifiSetConfig", + "", + sizeof(RpcReqWifiSetConfig), + 2, + rpc__req__wifi_set_config__field_descriptors, + rpc__req__wifi_set_config__field_indices_by_name, + 1, rpc__req__wifi_set_config__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_config__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetConfig, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_config__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetConfig", + "RpcRespWifiSetConfig", + "RpcRespWifiSetConfig", + "", + sizeof(RpcRespWifiSetConfig), + 1, + rpc__resp__wifi_set_config__field_descriptors, + rpc__resp__wifi_set_config__field_indices_by_name, + 1, rpc__resp__wifi_set_config__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_config__field_descriptors[1] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetConfig, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_config__field_indices_by_name[] = { + 0, /* field[0] = iface */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetConfig", + "RpcReqWifiGetConfig", + "RpcReqWifiGetConfig", + "", + sizeof(RpcReqWifiGetConfig), + 1, + rpc__req__wifi_get_config__field_descriptors, + rpc__req__wifi_get_config__field_indices_by_name, + 1, rpc__req__wifi_get_config__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_config__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetConfig, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "iface", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetConfig, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cfg", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetConfig, cfg), + &wifi_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_config__field_indices_by_name[] = { + 2, /* field[2] = cfg */ + 1, /* field[1] = iface */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetConfig", + "RpcRespWifiGetConfig", + "RpcRespWifiGetConfig", + "", + sizeof(RpcRespWifiGetConfig), + 3, + rpc__resp__wifi_get_config__field_descriptors, + rpc__resp__wifi_get_config__field_indices_by_name, + 1, rpc__resp__wifi_get_config__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_connect__field_descriptors NULL +#define rpc__req__wifi_connect__field_indices_by_name NULL +#define rpc__req__wifi_connect__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiConnect", + "RpcReqWifiConnect", + "RpcReqWifiConnect", + "", + sizeof(RpcReqWifiConnect), + 0, + rpc__req__wifi_connect__field_descriptors, + rpc__req__wifi_connect__field_indices_by_name, + 0, rpc__req__wifi_connect__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_connect__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiConnect, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_connect__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_connect__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiConnect", + "RpcRespWifiConnect", + "RpcRespWifiConnect", + "", + sizeof(RpcRespWifiConnect), + 1, + rpc__resp__wifi_connect__field_descriptors, + rpc__resp__wifi_connect__field_indices_by_name, + 1, rpc__resp__wifi_connect__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_disconnect__field_descriptors NULL +#define rpc__req__wifi_disconnect__field_indices_by_name NULL +#define rpc__req__wifi_disconnect__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_disconnect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiDisconnect", + "RpcReqWifiDisconnect", + "RpcReqWifiDisconnect", + "", + sizeof(RpcReqWifiDisconnect), + 0, + rpc__req__wifi_disconnect__field_descriptors, + rpc__req__wifi_disconnect__field_indices_by_name, + 0, rpc__req__wifi_disconnect__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_disconnect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_disconnect__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDisconnect, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_disconnect__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_disconnect__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_disconnect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiDisconnect", + "RpcRespWifiDisconnect", + "RpcRespWifiDisconnect", + "", + sizeof(RpcRespWifiDisconnect), + 1, + rpc__resp__wifi_disconnect__field_descriptors, + rpc__resp__wifi_disconnect__field_indices_by_name, + 1, rpc__resp__wifi_disconnect__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_disconnect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_start__field_descriptors NULL +#define rpc__req__wifi_start__field_indices_by_name NULL +#define rpc__req__wifi_start__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStart", + "RpcReqWifiStart", + "RpcReqWifiStart", + "", + sizeof(RpcReqWifiStart), + 0, + rpc__req__wifi_start__field_descriptors, + rpc__req__wifi_start__field_indices_by_name, + 0, rpc__req__wifi_start__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_start__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStart, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_start__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_start__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStart", + "RpcRespWifiStart", + "RpcRespWifiStart", + "", + sizeof(RpcRespWifiStart), + 1, + rpc__resp__wifi_start__field_descriptors, + rpc__resp__wifi_start__field_indices_by_name, + 1, rpc__resp__wifi_start__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_stop__field_descriptors NULL +#define rpc__req__wifi_stop__field_indices_by_name NULL +#define rpc__req__wifi_stop__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStop", + "RpcReqWifiStop", + "RpcReqWifiStop", + "", + sizeof(RpcReqWifiStop), + 0, + rpc__req__wifi_stop__field_descriptors, + rpc__req__wifi_stop__field_indices_by_name, + 0, rpc__req__wifi_stop__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_stop__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStop, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_stop__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_stop__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStop", + "RpcRespWifiStop", + "RpcRespWifiStop", + "", + sizeof(RpcRespWifiStop), + 1, + rpc__resp__wifi_stop__field_descriptors, + rpc__resp__wifi_stop__field_indices_by_name, + 1, rpc__resp__wifi_stop__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_scan_start__field_descriptors[3] = +{ + { + "config", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanStart, config), + &wifi_scan_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "block", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanStart, block), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "config_set", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanStart, config_set), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_scan_start__field_indices_by_name[] = { + 1, /* field[1] = block */ + 0, /* field[0] = config */ + 2, /* field[2] = config_set */ +}; +static const ProtobufCIntRange rpc__req__wifi_scan_start__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_scan_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanStart", + "RpcReqWifiScanStart", + "RpcReqWifiScanStart", + "", + sizeof(RpcReqWifiScanStart), + 3, + rpc__req__wifi_scan_start__field_descriptors, + rpc__req__wifi_scan_start__field_indices_by_name, + 1, rpc__req__wifi_scan_start__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_start__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanStart, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_start__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_start__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanStart", + "RpcRespWifiScanStart", + "RpcRespWifiScanStart", + "", + sizeof(RpcRespWifiScanStart), + 1, + rpc__resp__wifi_scan_start__field_descriptors, + rpc__resp__wifi_scan_start__field_indices_by_name, + 1, rpc__resp__wifi_scan_start__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_scan_stop__field_descriptors NULL +#define rpc__req__wifi_scan_stop__field_indices_by_name NULL +#define rpc__req__wifi_scan_stop__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_scan_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanStop", + "RpcReqWifiScanStop", + "RpcReqWifiScanStop", + "", + sizeof(RpcReqWifiScanStop), + 0, + rpc__req__wifi_scan_stop__field_descriptors, + rpc__req__wifi_scan_stop__field_indices_by_name, + 0, rpc__req__wifi_scan_stop__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_stop__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanStop, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_stop__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_stop__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanStop", + "RpcRespWifiScanStop", + "RpcRespWifiScanStop", + "", + sizeof(RpcRespWifiScanStop), + 1, + rpc__resp__wifi_scan_stop__field_descriptors, + rpc__resp__wifi_scan_stop__field_indices_by_name, + 1, rpc__resp__wifi_scan_stop__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_scan_get_ap_num__field_descriptors NULL +#define rpc__req__wifi_scan_get_ap_num__field_indices_by_name NULL +#define rpc__req__wifi_scan_get_ap_num__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_num__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanGetApNum", + "RpcReqWifiScanGetApNum", + "RpcReqWifiScanGetApNum", + "", + sizeof(RpcReqWifiScanGetApNum), + 0, + rpc__req__wifi_scan_get_ap_num__field_descriptors, + rpc__req__wifi_scan_get_ap_num__field_indices_by_name, + 0, rpc__req__wifi_scan_get_ap_num__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_get_ap_num__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_get_ap_num__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApNum, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "number", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApNum, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_get_ap_num__field_indices_by_name[] = { + 1, /* field[1] = number */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_get_ap_num__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_num__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanGetApNum", + "RpcRespWifiScanGetApNum", + "RpcRespWifiScanGetApNum", + "", + sizeof(RpcRespWifiScanGetApNum), + 2, + rpc__resp__wifi_scan_get_ap_num__field_descriptors, + rpc__resp__wifi_scan_get_ap_num__field_indices_by_name, + 1, rpc__resp__wifi_scan_get_ap_num__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_get_ap_num__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_scan_get_ap_records__field_descriptors[1] = +{ + { + "number", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanGetApRecords, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_scan_get_ap_records__field_indices_by_name[] = { + 0, /* field[0] = number */ +}; +static const ProtobufCIntRange rpc__req__wifi_scan_get_ap_records__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_records__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanGetApRecords", + "RpcReqWifiScanGetApRecords", + "RpcReqWifiScanGetApRecords", + "", + sizeof(RpcReqWifiScanGetApRecords), + 1, + rpc__req__wifi_scan_get_ap_records__field_descriptors, + rpc__req__wifi_scan_get_ap_records__field_indices_by_name, + 1, rpc__req__wifi_scan_get_ap_records__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_get_ap_records__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_get_ap_records__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecords, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "number", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecords, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_records", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(RpcRespWifiScanGetApRecords, n_ap_records), + offsetof(RpcRespWifiScanGetApRecords, ap_records), + &wifi_ap_record__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_get_ap_records__field_indices_by_name[] = { + 2, /* field[2] = ap_records */ + 1, /* field[1] = number */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_get_ap_records__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_records__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanGetApRecords", + "RpcRespWifiScanGetApRecords", + "RpcRespWifiScanGetApRecords", + "", + sizeof(RpcRespWifiScanGetApRecords), + 3, + rpc__resp__wifi_scan_get_ap_records__field_descriptors, + rpc__resp__wifi_scan_get_ap_records__field_indices_by_name, + 1, rpc__resp__wifi_scan_get_ap_records__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_get_ap_records__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_scan_get_ap_record__field_descriptors NULL +#define rpc__req__wifi_scan_get_ap_record__field_indices_by_name NULL +#define rpc__req__wifi_scan_get_ap_record__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_record__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanGetApRecord", + "RpcReqWifiScanGetApRecord", + "RpcReqWifiScanGetApRecord", + "", + sizeof(RpcReqWifiScanGetApRecord), + 0, + rpc__req__wifi_scan_get_ap_record__field_descriptors, + rpc__req__wifi_scan_get_ap_record__field_indices_by_name, + 0, rpc__req__wifi_scan_get_ap_record__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_get_ap_record__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_get_ap_record__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecord, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_record", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecord, ap_record), + &wifi_ap_record__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_get_ap_record__field_indices_by_name[] = { + 1, /* field[1] = ap_record */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_get_ap_record__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_record__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanGetApRecord", + "RpcRespWifiScanGetApRecord", + "RpcRespWifiScanGetApRecord", + "", + sizeof(RpcRespWifiScanGetApRecord), + 2, + rpc__resp__wifi_scan_get_ap_record__field_descriptors, + rpc__resp__wifi_scan_get_ap_record__field_indices_by_name, + 1, rpc__resp__wifi_scan_get_ap_record__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_get_ap_record__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_clear_ap_list__field_descriptors NULL +#define rpc__req__wifi_clear_ap_list__field_indices_by_name NULL +#define rpc__req__wifi_clear_ap_list__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_clear_ap_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiClearApList", + "RpcReqWifiClearApList", + "RpcReqWifiClearApList", + "", + sizeof(RpcReqWifiClearApList), + 0, + rpc__req__wifi_clear_ap_list__field_descriptors, + rpc__req__wifi_clear_ap_list__field_indices_by_name, + 0, rpc__req__wifi_clear_ap_list__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_clear_ap_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_clear_ap_list__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiClearApList, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_clear_ap_list__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_clear_ap_list__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_clear_ap_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiClearApList", + "RpcRespWifiClearApList", + "RpcRespWifiClearApList", + "", + sizeof(RpcRespWifiClearApList), + 1, + rpc__resp__wifi_clear_ap_list__field_descriptors, + rpc__resp__wifi_clear_ap_list__field_indices_by_name, + 1, rpc__resp__wifi_clear_ap_list__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_clear_ap_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_restore__field_descriptors NULL +#define rpc__req__wifi_restore__field_indices_by_name NULL +#define rpc__req__wifi_restore__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_restore__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiRestore", + "RpcReqWifiRestore", + "RpcReqWifiRestore", + "", + sizeof(RpcReqWifiRestore), + 0, + rpc__req__wifi_restore__field_descriptors, + rpc__req__wifi_restore__field_indices_by_name, + 0, rpc__req__wifi_restore__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_restore__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_restore__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiRestore, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_restore__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_restore__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_restore__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiRestore", + "RpcRespWifiRestore", + "RpcRespWifiRestore", + "", + sizeof(RpcRespWifiRestore), + 1, + rpc__resp__wifi_restore__field_descriptors, + rpc__resp__wifi_restore__field_indices_by_name, + 1, rpc__resp__wifi_restore__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_restore__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_clear_fast_connect__field_descriptors NULL +#define rpc__req__wifi_clear_fast_connect__field_indices_by_name NULL +#define rpc__req__wifi_clear_fast_connect__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_clear_fast_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiClearFastConnect", + "RpcReqWifiClearFastConnect", + "RpcReqWifiClearFastConnect", + "", + sizeof(RpcReqWifiClearFastConnect), + 0, + rpc__req__wifi_clear_fast_connect__field_descriptors, + rpc__req__wifi_clear_fast_connect__field_indices_by_name, + 0, rpc__req__wifi_clear_fast_connect__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_clear_fast_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_clear_fast_connect__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiClearFastConnect, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_clear_fast_connect__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_clear_fast_connect__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_clear_fast_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiClearFastConnect", + "RpcRespWifiClearFastConnect", + "RpcRespWifiClearFastConnect", + "", + sizeof(RpcRespWifiClearFastConnect), + 1, + rpc__resp__wifi_clear_fast_connect__field_descriptors, + rpc__resp__wifi_clear_fast_connect__field_indices_by_name, + 1, rpc__resp__wifi_clear_fast_connect__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_clear_fast_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_deauth_sta__field_descriptors[1] = +{ + { + "aid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiDeauthSta, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_deauth_sta__field_indices_by_name[] = { + 0, /* field[0] = aid */ +}; +static const ProtobufCIntRange rpc__req__wifi_deauth_sta__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_deauth_sta__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiDeauthSta", + "RpcReqWifiDeauthSta", + "RpcReqWifiDeauthSta", + "", + sizeof(RpcReqWifiDeauthSta), + 1, + rpc__req__wifi_deauth_sta__field_descriptors, + rpc__req__wifi_deauth_sta__field_indices_by_name, + 1, rpc__req__wifi_deauth_sta__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_deauth_sta__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_deauth_sta__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDeauthSta, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDeauthSta, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_deauth_sta__field_indices_by_name[] = { + 1, /* field[1] = aid */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_deauth_sta__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_deauth_sta__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiDeauthSta", + "RpcRespWifiDeauthSta", + "RpcRespWifiDeauthSta", + "", + sizeof(RpcRespWifiDeauthSta), + 2, + rpc__resp__wifi_deauth_sta__field_descriptors, + rpc__resp__wifi_deauth_sta__field_indices_by_name, + 1, rpc__resp__wifi_deauth_sta__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_deauth_sta__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_ap_info__field_descriptors NULL +#define rpc__req__wifi_sta_get_ap_info__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_ap_info__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_ap_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetApInfo", + "RpcReqWifiStaGetApInfo", + "RpcReqWifiStaGetApInfo", + "", + sizeof(RpcReqWifiStaGetApInfo), + 0, + rpc__req__wifi_sta_get_ap_info__field_descriptors, + rpc__req__wifi_sta_get_ap_info__field_indices_by_name, + 0, rpc__req__wifi_sta_get_ap_info__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_ap_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_ap_info__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetApInfo, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_record", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetApInfo, ap_record), + &wifi_ap_record__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_ap_info__field_indices_by_name[] = { + 1, /* field[1] = ap_record */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_ap_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_ap_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetApInfo", + "RpcRespWifiStaGetApInfo", + "RpcRespWifiStaGetApInfo", + "", + sizeof(RpcRespWifiStaGetApInfo), + 2, + rpc__resp__wifi_sta_get_ap_info__field_descriptors, + rpc__resp__wifi_sta_get_ap_info__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_ap_info__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_ap_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_protocol__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocol, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocol_bitmap", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocol, protocol_bitmap), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_protocol__field_indices_by_name[] = { + 0, /* field[0] = ifx */ + 1, /* field[1] = protocol_bitmap */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetProtocol", + "RpcReqWifiSetProtocol", + "RpcReqWifiSetProtocol", + "", + sizeof(RpcReqWifiSetProtocol), + 2, + rpc__req__wifi_set_protocol__field_descriptors, + rpc__req__wifi_set_protocol__field_indices_by_name, + 1, rpc__req__wifi_set_protocol__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_protocol__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetProtocol, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_protocol__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetProtocol", + "RpcRespWifiSetProtocol", + "RpcRespWifiSetProtocol", + "", + sizeof(RpcRespWifiSetProtocol), + 1, + rpc__resp__wifi_set_protocol__field_descriptors, + rpc__resp__wifi_set_protocol__field_indices_by_name, + 1, rpc__resp__wifi_set_protocol__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_protocol__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetProtocol, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_protocol__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetProtocol", + "RpcReqWifiGetProtocol", + "RpcReqWifiGetProtocol", + "", + sizeof(RpcReqWifiGetProtocol), + 1, + rpc__req__wifi_get_protocol__field_descriptors, + rpc__req__wifi_get_protocol__field_indices_by_name, + 1, rpc__req__wifi_get_protocol__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_protocol__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocol, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocol_bitmap", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocol, protocol_bitmap), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_protocol__field_indices_by_name[] = { + 1, /* field[1] = protocol_bitmap */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetProtocol", + "RpcRespWifiGetProtocol", + "RpcRespWifiGetProtocol", + "", + sizeof(RpcRespWifiGetProtocol), + 2, + rpc__resp__wifi_get_protocol__field_descriptors, + rpc__resp__wifi_get_protocol__field_indices_by_name, + 1, rpc__resp__wifi_get_protocol__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_bandwidth__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidth, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bw", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidth, bw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_bandwidth__field_indices_by_name[] = { + 1, /* field[1] = bw */ + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBandwidth", + "RpcReqWifiSetBandwidth", + "RpcReqWifiSetBandwidth", + "", + sizeof(RpcReqWifiSetBandwidth), + 2, + rpc__req__wifi_set_bandwidth__field_descriptors, + rpc__req__wifi_set_bandwidth__field_indices_by_name, + 1, rpc__req__wifi_set_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_bandwidth__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandwidth, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_bandwidth__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBandwidth", + "RpcRespWifiSetBandwidth", + "RpcRespWifiSetBandwidth", + "", + sizeof(RpcRespWifiSetBandwidth), + 1, + rpc__resp__wifi_set_bandwidth__field_descriptors, + rpc__resp__wifi_set_bandwidth__field_indices_by_name, + 1, rpc__resp__wifi_set_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_bandwidth__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetBandwidth, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_bandwidth__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBandwidth", + "RpcReqWifiGetBandwidth", + "RpcReqWifiGetBandwidth", + "", + sizeof(RpcReqWifiGetBandwidth), + 1, + rpc__req__wifi_get_bandwidth__field_descriptors, + rpc__req__wifi_get_bandwidth__field_indices_by_name, + 1, rpc__req__wifi_get_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_bandwidth__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidth, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bw", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidth, bw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_bandwidth__field_indices_by_name[] = { + 1, /* field[1] = bw */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBandwidth", + "RpcRespWifiGetBandwidth", + "RpcRespWifiGetBandwidth", + "", + sizeof(RpcRespWifiGetBandwidth), + 2, + rpc__resp__wifi_get_bandwidth__field_descriptors, + rpc__resp__wifi_get_bandwidth__field_indices_by_name, + 1, rpc__resp__wifi_get_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_channel__field_descriptors[2] = +{ + { + "primary", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetChannel, primary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "second", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetChannel, second), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_channel__field_indices_by_name[] = { + 0, /* field[0] = primary */ + 1, /* field[1] = second */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_channel__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetChannel", + "RpcReqWifiSetChannel", + "RpcReqWifiSetChannel", + "", + sizeof(RpcReqWifiSetChannel), + 2, + rpc__req__wifi_set_channel__field_descriptors, + rpc__req__wifi_set_channel__field_indices_by_name, + 1, rpc__req__wifi_set_channel__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_channel__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetChannel, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_channel__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_channel__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetChannel", + "RpcRespWifiSetChannel", + "RpcRespWifiSetChannel", + "", + sizeof(RpcRespWifiSetChannel), + 1, + rpc__resp__wifi_set_channel__field_descriptors, + rpc__resp__wifi_set_channel__field_indices_by_name, + 1, rpc__resp__wifi_set_channel__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_channel__field_descriptors NULL +#define rpc__req__wifi_get_channel__field_indices_by_name NULL +#define rpc__req__wifi_get_channel__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetChannel", + "RpcReqWifiGetChannel", + "RpcReqWifiGetChannel", + "", + sizeof(RpcReqWifiGetChannel), + 0, + rpc__req__wifi_get_channel__field_descriptors, + rpc__req__wifi_get_channel__field_indices_by_name, + 0, rpc__req__wifi_get_channel__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_channel__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetChannel, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "primary", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetChannel, primary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "second", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetChannel, second), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_channel__field_indices_by_name[] = { + 1, /* field[1] = primary */ + 0, /* field[0] = resp */ + 2, /* field[2] = second */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_channel__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetChannel", + "RpcRespWifiGetChannel", + "RpcRespWifiGetChannel", + "", + sizeof(RpcRespWifiGetChannel), + 3, + rpc__resp__wifi_get_channel__field_descriptors, + rpc__resp__wifi_get_channel__field_indices_by_name, + 1, rpc__resp__wifi_get_channel__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_storage__field_descriptors[1] = +{ + { + "storage", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetStorage, storage), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_storage__field_indices_by_name[] = { + 0, /* field[0] = storage */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_storage__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_storage__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetStorage", + "RpcReqWifiSetStorage", + "RpcReqWifiSetStorage", + "", + sizeof(RpcReqWifiSetStorage), + 1, + rpc__req__wifi_set_storage__field_descriptors, + rpc__req__wifi_set_storage__field_indices_by_name, + 1, rpc__req__wifi_set_storage__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_storage__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_storage__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetStorage, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_storage__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_storage__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_storage__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetStorage", + "RpcRespWifiSetStorage", + "RpcRespWifiSetStorage", + "", + sizeof(RpcRespWifiSetStorage), + 1, + rpc__resp__wifi_set_storage__field_descriptors, + rpc__resp__wifi_set_storage__field_indices_by_name, + 1, rpc__resp__wifi_set_storage__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_storage__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_country_code__field_descriptors[2] = +{ + { + "country", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetCountryCode, country), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ieee80211d_enabled", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetCountryCode, ieee80211d_enabled), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_country_code__field_indices_by_name[] = { + 0, /* field[0] = country */ + 1, /* field[1] = ieee80211d_enabled */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_country_code__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetCountryCode", + "RpcReqWifiSetCountryCode", + "RpcReqWifiSetCountryCode", + "", + sizeof(RpcReqWifiSetCountryCode), + 2, + rpc__req__wifi_set_country_code__field_descriptors, + rpc__req__wifi_set_country_code__field_indices_by_name, + 1, rpc__req__wifi_set_country_code__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_country_code__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetCountryCode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_country_code__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_country_code__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetCountryCode", + "RpcRespWifiSetCountryCode", + "RpcRespWifiSetCountryCode", + "", + sizeof(RpcRespWifiSetCountryCode), + 1, + rpc__resp__wifi_set_country_code__field_descriptors, + rpc__resp__wifi_set_country_code__field_indices_by_name, + 1, rpc__resp__wifi_set_country_code__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_country_code__field_descriptors NULL +#define rpc__req__wifi_get_country_code__field_indices_by_name NULL +#define rpc__req__wifi_get_country_code__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetCountryCode", + "RpcReqWifiGetCountryCode", + "RpcReqWifiGetCountryCode", + "", + sizeof(RpcReqWifiGetCountryCode), + 0, + rpc__req__wifi_get_country_code__field_descriptors, + rpc__req__wifi_get_country_code__field_indices_by_name, + 0, rpc__req__wifi_get_country_code__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_country_code__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountryCode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "country", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountryCode, country), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_country_code__field_indices_by_name[] = { + 1, /* field[1] = country */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_country_code__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetCountryCode", + "RpcRespWifiGetCountryCode", + "RpcRespWifiGetCountryCode", + "", + sizeof(RpcRespWifiGetCountryCode), + 2, + rpc__resp__wifi_get_country_code__field_descriptors, + rpc__resp__wifi_get_country_code__field_indices_by_name, + 1, rpc__resp__wifi_get_country_code__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_country__field_descriptors[1] = +{ + { + "country", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetCountry, country), + &wifi_country__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_country__field_indices_by_name[] = { + 0, /* field[0] = country */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetCountry", + "RpcReqWifiSetCountry", + "RpcReqWifiSetCountry", + "", + sizeof(RpcReqWifiSetCountry), + 1, + rpc__req__wifi_set_country__field_descriptors, + rpc__req__wifi_set_country__field_indices_by_name, + 1, rpc__req__wifi_set_country__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_country__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetCountry, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_country__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetCountry", + "RpcRespWifiSetCountry", + "RpcRespWifiSetCountry", + "", + sizeof(RpcRespWifiSetCountry), + 1, + rpc__resp__wifi_set_country__field_descriptors, + rpc__resp__wifi_set_country__field_indices_by_name, + 1, rpc__resp__wifi_set_country__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_country__field_descriptors NULL +#define rpc__req__wifi_get_country__field_indices_by_name NULL +#define rpc__req__wifi_get_country__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetCountry", + "RpcReqWifiGetCountry", + "RpcReqWifiGetCountry", + "", + sizeof(RpcReqWifiGetCountry), + 0, + rpc__req__wifi_get_country__field_descriptors, + rpc__req__wifi_get_country__field_indices_by_name, + 0, rpc__req__wifi_get_country__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_country__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountry, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "country", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountry, country), + &wifi_country__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_country__field_indices_by_name[] = { + 1, /* field[1] = country */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetCountry", + "RpcRespWifiGetCountry", + "RpcRespWifiGetCountry", + "", + sizeof(RpcRespWifiGetCountry), + 2, + rpc__resp__wifi_get_country__field_descriptors, + rpc__resp__wifi_get_country__field_indices_by_name, + 1, rpc__resp__wifi_get_country__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_ap_get_sta_list__field_descriptors NULL +#define rpc__req__wifi_ap_get_sta_list__field_indices_by_name NULL +#define rpc__req__wifi_ap_get_sta_list__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiApGetStaList", + "RpcReqWifiApGetStaList", + "RpcReqWifiApGetStaList", + "", + sizeof(RpcReqWifiApGetStaList), + 0, + rpc__req__wifi_ap_get_sta_list__field_descriptors, + rpc__req__wifi_ap_get_sta_list__field_indices_by_name, + 0, rpc__req__wifi_ap_get_sta_list__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_ap_get_sta_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_ap_get_sta_list__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaList, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_list", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaList, sta_list), + &wifi_sta_list__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_ap_get_sta_list__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sta_list */ +}; +static const ProtobufCIntRange rpc__resp__wifi_ap_get_sta_list__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiApGetStaList", + "RpcRespWifiApGetStaList", + "RpcRespWifiApGetStaList", + "", + sizeof(RpcRespWifiApGetStaList), + 2, + rpc__resp__wifi_ap_get_sta_list__field_descriptors, + rpc__resp__wifi_ap_get_sta_list__field_indices_by_name, + 1, rpc__resp__wifi_ap_get_sta_list__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_ap_get_sta_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_ap_get_sta_aid__field_descriptors[1] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiApGetStaAid, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_ap_get_sta_aid__field_indices_by_name[] = { + 0, /* field[0] = mac */ +}; +static const ProtobufCIntRange rpc__req__wifi_ap_get_sta_aid__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiApGetStaAid", + "RpcReqWifiApGetStaAid", + "RpcReqWifiApGetStaAid", + "", + sizeof(RpcReqWifiApGetStaAid), + 1, + rpc__req__wifi_ap_get_sta_aid__field_descriptors, + rpc__req__wifi_ap_get_sta_aid__field_indices_by_name, + 1, rpc__req__wifi_ap_get_sta_aid__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_ap_get_sta_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_negotiated_phymode__field_descriptors NULL +#define rpc__req__wifi_sta_get_negotiated_phymode__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_negotiated_phymode__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_negotiated_phymode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetNegotiatedPhymode", + "RpcReqWifiStaGetNegotiatedPhymode", + "RpcReqWifiStaGetNegotiatedPhymode", + "", + sizeof(RpcReqWifiStaGetNegotiatedPhymode), + 0, + rpc__req__wifi_sta_get_negotiated_phymode__field_descriptors, + rpc__req__wifi_sta_get_negotiated_phymode__field_indices_by_name, + 0, rpc__req__wifi_sta_get_negotiated_phymode__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_negotiated_phymode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetNegotiatedPhymode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "phymode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetNegotiatedPhymode, phymode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_negotiated_phymode__field_indices_by_name[] = { + 1, /* field[1] = phymode */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_negotiated_phymode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetNegotiatedPhymode", + "RpcRespWifiStaGetNegotiatedPhymode", + "RpcRespWifiStaGetNegotiatedPhymode", + "", + sizeof(RpcRespWifiStaGetNegotiatedPhymode), + 2, + rpc__resp__wifi_sta_get_negotiated_phymode__field_descriptors, + rpc__resp__wifi_sta_get_negotiated_phymode__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_negotiated_phymode__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_negotiated_phymode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_ap_get_sta_aid__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaAid, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaAid, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_ap_get_sta_aid__field_indices_by_name[] = { + 1, /* field[1] = aid */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_ap_get_sta_aid__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiApGetStaAid", + "RpcRespWifiApGetStaAid", + "RpcRespWifiApGetStaAid", + "", + sizeof(RpcRespWifiApGetStaAid), + 2, + rpc__resp__wifi_ap_get_sta_aid__field_descriptors, + rpc__resp__wifi_ap_get_sta_aid__field_indices_by_name, + 1, rpc__resp__wifi_ap_get_sta_aid__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_ap_get_sta_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_rssi__field_descriptors NULL +#define rpc__req__wifi_sta_get_rssi__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_rssi__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_rssi__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetRssi", + "RpcReqWifiStaGetRssi", + "RpcReqWifiStaGetRssi", + "", + sizeof(RpcReqWifiStaGetRssi), + 0, + rpc__req__wifi_sta_get_rssi__field_descriptors, + rpc__req__wifi_sta_get_rssi__field_indices_by_name, + 0, rpc__req__wifi_sta_get_rssi__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_rssi__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_rssi__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetRssi, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetRssi, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_rssi__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = rssi */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_rssi__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_rssi__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetRssi", + "RpcRespWifiStaGetRssi", + "RpcRespWifiStaGetRssi", + "", + sizeof(RpcRespWifiStaGetRssi), + 2, + rpc__resp__wifi_sta_get_rssi__field_descriptors, + rpc__resp__wifi_sta_get_rssi__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_rssi__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_rssi__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_aid__field_descriptors NULL +#define rpc__req__wifi_sta_get_aid__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_aid__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetAid", + "RpcReqWifiStaGetAid", + "RpcReqWifiStaGetAid", + "", + sizeof(RpcReqWifiStaGetAid), + 0, + rpc__req__wifi_sta_get_aid__field_descriptors, + rpc__req__wifi_sta_get_aid__field_indices_by_name, + 0, rpc__req__wifi_sta_get_aid__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_aid__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetAid, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetAid, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_aid__field_indices_by_name[] = { + 1, /* field[1] = aid */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_aid__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetAid", + "RpcRespWifiStaGetAid", + "RpcRespWifiStaGetAid", + "", + sizeof(RpcRespWifiStaGetAid), + 2, + rpc__resp__wifi_sta_get_aid__field_descriptors, + rpc__resp__wifi_sta_get_aid__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_aid__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_protocols__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocols", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocols, protocols), + &wifi_protocols__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_protocols__field_indices_by_name[] = { + 0, /* field[0] = ifx */ + 1, /* field[1] = protocols */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetProtocols", + "RpcReqWifiSetProtocols", + "RpcReqWifiSetProtocols", + "", + sizeof(RpcReqWifiSetProtocols), + 2, + rpc__req__wifi_set_protocols__field_descriptors, + rpc__req__wifi_set_protocols__field_indices_by_name, + 1, rpc__req__wifi_set_protocols__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_protocols__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetProtocols, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_protocols__field_indices_by_name[] = { + 1, /* field[1] = ifx */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetProtocols", + "RpcRespWifiSetProtocols", + "RpcRespWifiSetProtocols", + "", + sizeof(RpcRespWifiSetProtocols), + 2, + rpc__resp__wifi_set_protocols__field_descriptors, + rpc__resp__wifi_set_protocols__field_indices_by_name, + 1, rpc__resp__wifi_set_protocols__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_protocols__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_protocols__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetProtocols", + "RpcReqWifiGetProtocols", + "RpcReqWifiGetProtocols", + "", + sizeof(RpcReqWifiGetProtocols), + 1, + rpc__req__wifi_get_protocols__field_descriptors, + rpc__req__wifi_get_protocols__field_indices_by_name, + 1, rpc__req__wifi_get_protocols__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_protocols__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocols, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocols", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocols, protocols), + &wifi_protocols__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_protocols__field_indices_by_name[] = { + 1, /* field[1] = ifx */ + 2, /* field[2] = protocols */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetProtocols", + "RpcRespWifiGetProtocols", + "RpcRespWifiGetProtocols", + "", + sizeof(RpcRespWifiGetProtocols), + 3, + rpc__resp__wifi_get_protocols__field_descriptors, + rpc__resp__wifi_get_protocols__field_indices_by_name, + 1, rpc__resp__wifi_get_protocols__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_bandwidths__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidths", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidths, bandwidths), + &wifi_bandwidths__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_bandwidths__field_indices_by_name[] = { + 1, /* field[1] = bandwidths */ + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBandwidths", + "RpcReqWifiSetBandwidths", + "RpcReqWifiSetBandwidths", + "", + sizeof(RpcReqWifiSetBandwidths), + 2, + rpc__req__wifi_set_bandwidths__field_descriptors, + rpc__req__wifi_set_bandwidths__field_indices_by_name, + 1, rpc__req__wifi_set_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_bandwidths__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandwidths, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_bandwidths__field_indices_by_name[] = { + 1, /* field[1] = ifx */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBandwidths", + "RpcRespWifiSetBandwidths", + "RpcRespWifiSetBandwidths", + "", + sizeof(RpcRespWifiSetBandwidths), + 2, + rpc__resp__wifi_set_bandwidths__field_descriptors, + rpc__resp__wifi_set_bandwidths__field_indices_by_name, + 1, rpc__resp__wifi_set_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_bandwidths__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_bandwidths__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBandwidths", + "RpcReqWifiGetBandwidths", + "RpcReqWifiGetBandwidths", + "", + sizeof(RpcReqWifiGetBandwidths), + 1, + rpc__req__wifi_get_bandwidths__field_descriptors, + rpc__req__wifi_get_bandwidths__field_indices_by_name, + 1, rpc__req__wifi_get_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_bandwidths__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidths, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidths", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidths, bandwidths), + &wifi_bandwidths__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_bandwidths__field_indices_by_name[] = { + 2, /* field[2] = bandwidths */ + 1, /* field[1] = ifx */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBandwidths", + "RpcRespWifiGetBandwidths", + "RpcRespWifiGetBandwidths", + "", + sizeof(RpcRespWifiGetBandwidths), + 3, + rpc__resp__wifi_get_bandwidths__field_descriptors, + rpc__resp__wifi_get_bandwidths__field_indices_by_name, + 1, rpc__resp__wifi_get_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_band__field_descriptors[1] = +{ + { + "band", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBand, band), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_band__field_indices_by_name[] = { + 0, /* field[0] = band */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_band__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBand", + "RpcReqWifiSetBand", + "RpcReqWifiSetBand", + "", + sizeof(RpcReqWifiSetBand), + 1, + rpc__req__wifi_set_band__field_descriptors, + rpc__req__wifi_set_band__field_indices_by_name, + 1, rpc__req__wifi_set_band__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_band__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBand, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_band__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_band__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBand", + "RpcRespWifiSetBand", + "RpcRespWifiSetBand", + "", + sizeof(RpcRespWifiSetBand), + 1, + rpc__resp__wifi_set_band__field_descriptors, + rpc__resp__wifi_set_band__field_indices_by_name, + 1, rpc__resp__wifi_set_band__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_band__field_descriptors NULL +#define rpc__req__wifi_get_band__field_indices_by_name NULL +#define rpc__req__wifi_get_band__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBand", + "RpcReqWifiGetBand", + "RpcReqWifiGetBand", + "", + sizeof(RpcReqWifiGetBand), + 0, + rpc__req__wifi_get_band__field_descriptors, + rpc__req__wifi_get_band__field_indices_by_name, + 0, rpc__req__wifi_get_band__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_band__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBand, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "band", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBand, band), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_band__field_indices_by_name[] = { + 1, /* field[1] = band */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_band__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBand", + "RpcRespWifiGetBand", + "RpcRespWifiGetBand", + "", + sizeof(RpcRespWifiGetBand), + 2, + rpc__resp__wifi_get_band__field_descriptors, + rpc__resp__wifi_get_band__field_indices_by_name, + 1, rpc__resp__wifi_get_band__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_band_mode__field_descriptors[1] = +{ + { + "bandmode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandMode, bandmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_band_mode__field_indices_by_name[] = { + 0, /* field[0] = bandmode */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_band_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBandMode", + "RpcReqWifiSetBandMode", + "RpcReqWifiSetBandMode", + "", + sizeof(RpcReqWifiSetBandMode), + 1, + rpc__req__wifi_set_band_mode__field_descriptors, + rpc__req__wifi_set_band_mode__field_indices_by_name, + 1, rpc__req__wifi_set_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_band_mode__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_band_mode__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_band_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBandMode", + "RpcRespWifiSetBandMode", + "RpcRespWifiSetBandMode", + "", + sizeof(RpcRespWifiSetBandMode), + 1, + rpc__resp__wifi_set_band_mode__field_descriptors, + rpc__resp__wifi_set_band_mode__field_indices_by_name, + 1, rpc__resp__wifi_set_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_band_mode__field_descriptors NULL +#define rpc__req__wifi_get_band_mode__field_indices_by_name NULL +#define rpc__req__wifi_get_band_mode__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBandMode", + "RpcReqWifiGetBandMode", + "RpcReqWifiGetBandMode", + "", + sizeof(RpcReqWifiGetBandMode), + 0, + rpc__req__wifi_get_band_mode__field_descriptors, + rpc__req__wifi_get_band_mode__field_indices_by_name, + 0, rpc__req__wifi_get_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_band_mode__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandmode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandMode, bandmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_band_mode__field_indices_by_name[] = { + 1, /* field[1] = bandmode */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_band_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBandMode", + "RpcRespWifiGetBandMode", + "RpcRespWifiGetBandMode", + "", + sizeof(RpcRespWifiGetBandMode), + 2, + rpc__resp__wifi_get_band_mode__field_descriptors, + rpc__resp__wifi_get_band_mode__field_indices_by_name, + 1, rpc__resp__wifi_get_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__get_coprocessor_fw_version__field_descriptors NULL +#define rpc__req__get_coprocessor_fw_version__field_indices_by_name NULL +#define rpc__req__get_coprocessor_fw_version__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__get_coprocessor_fw_version__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetCoprocessorFwVersion", + "RpcReqGetCoprocessorFwVersion", + "RpcReqGetCoprocessorFwVersion", + "", + sizeof(RpcReqGetCoprocessorFwVersion), + 0, + rpc__req__get_coprocessor_fw_version__field_descriptors, + rpc__req__get_coprocessor_fw_version__field_indices_by_name, + 0, rpc__req__get_coprocessor_fw_version__number_ranges, + (ProtobufCMessageInit) rpc__req__get_coprocessor_fw_version__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_coprocessor_fw_version__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "major1", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, major1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "minor1", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, minor1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "patch1", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, patch1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_coprocessor_fw_version__field_indices_by_name[] = { + 1, /* field[1] = major1 */ + 2, /* field[2] = minor1 */ + 3, /* field[3] = patch1 */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_coprocessor_fw_version__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_coprocessor_fw_version__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetCoprocessorFwVersion", + "RpcRespGetCoprocessorFwVersion", + "RpcRespGetCoprocessorFwVersion", + "", + sizeof(RpcRespGetCoprocessorFwVersion), + 4, + rpc__resp__get_coprocessor_fw_version__field_descriptors, + rpc__resp__get_coprocessor_fw_version__field_indices_by_name, + 1, rpc__resp__get_coprocessor_fw_version__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_coprocessor_fw_version__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__wifi_event_no_args__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiEventNoArgs, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_id", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiEventNoArgs, event_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__wifi_event_no_args__field_indices_by_name[] = { + 1, /* field[1] = event_id */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__wifi_event_no_args__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__wifi_event_no_args__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_WifiEventNoArgs", + "RpcEventWifiEventNoArgs", + "RpcEventWifiEventNoArgs", + "", + sizeof(RpcEventWifiEventNoArgs), + 2, + rpc__event__wifi_event_no_args__field_descriptors, + rpc__event__wifi_event_no_args__field_indices_by_name, + 1, rpc__event__wifi_event_no_args__number_ranges, + (ProtobufCMessageInit) rpc__event__wifi_event_no_args__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__espinit__field_descriptors[1] = +{ + { + "init_data", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventESPInit, init_data), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__espinit__field_indices_by_name[] = { + 0, /* field[0] = init_data */ +}; +static const ProtobufCIntRange rpc__event__espinit__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__event__espinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_ESPInit", + "RpcEventESPInit", + "RpcEventESPInit", + "", + sizeof(RpcEventESPInit), + 1, + rpc__event__espinit__field_descriptors, + rpc__event__espinit__field_indices_by_name, + 1, rpc__event__espinit__number_ranges, + (ProtobufCMessageInit) rpc__event__espinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__heartbeat__field_descriptors[1] = +{ + { + "hb_num", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventHeartbeat, hb_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__heartbeat__field_indices_by_name[] = { + 0, /* field[0] = hb_num */ +}; +static const ProtobufCIntRange rpc__event__heartbeat__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__event__heartbeat__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_Heartbeat", + "RpcEventHeartbeat", + "RpcEventHeartbeat", + "", + sizeof(RpcEventHeartbeat), + 1, + rpc__event__heartbeat__field_descriptors, + rpc__event__heartbeat__field_indices_by_name, + 1, rpc__event__heartbeat__number_ranges, + (ProtobufCMessageInit) rpc__event__heartbeat__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__ap__sta_disconnected__field_descriptors[5] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "is_mesh_child", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, is_mesh_child), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__ap__sta_disconnected__field_indices_by_name[] = { + 2, /* field[2] = aid */ + 3, /* field[3] = is_mesh_child */ + 1, /* field[1] = mac */ + 4, /* field[4] = reason */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__ap__sta_disconnected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor rpc__event__ap__sta_disconnected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_AP_StaDisconnected", + "RpcEventAPStaDisconnected", + "RpcEventAPStaDisconnected", + "", + sizeof(RpcEventAPStaDisconnected), + 5, + rpc__event__ap__sta_disconnected__field_descriptors, + rpc__event__ap__sta_disconnected__field_indices_by_name, + 1, rpc__event__ap__sta_disconnected__number_ranges, + (ProtobufCMessageInit) rpc__event__ap__sta_disconnected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__ap__sta_connected__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "is_mesh_child", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, is_mesh_child), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__ap__sta_connected__field_indices_by_name[] = { + 2, /* field[2] = aid */ + 3, /* field[3] = is_mesh_child */ + 1, /* field[1] = mac */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__ap__sta_connected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__event__ap__sta_connected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_AP_StaConnected", + "RpcEventAPStaConnected", + "RpcEventAPStaConnected", + "", + sizeof(RpcEventAPStaConnected), + 4, + rpc__event__ap__sta_connected__field_descriptors, + rpc__event__ap__sta_connected__field_indices_by_name, + 1, rpc__event__ap__sta_connected__number_ranges, + (ProtobufCMessageInit) rpc__event__ap__sta_connected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_scan_done__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaScanDone, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_done", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaScanDone, scan_done), + &wifi_event_sta_scan_done__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_scan_done__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = scan_done */ +}; +static const ProtobufCIntRange rpc__event__sta_scan_done__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_scan_done__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaScanDone", + "RpcEventStaScanDone", + "RpcEventStaScanDone", + "", + sizeof(RpcEventStaScanDone), + 2, + rpc__event__sta_scan_done__field_descriptors, + rpc__event__sta_scan_done__field_indices_by_name, + 1, rpc__event__sta_scan_done__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_scan_done__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_connected__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaConnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_connected", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaConnected, sta_connected), + &wifi_event_sta_connected__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_connected__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sta_connected */ +}; +static const ProtobufCIntRange rpc__event__sta_connected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_connected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaConnected", + "RpcEventStaConnected", + "RpcEventStaConnected", + "", + sizeof(RpcEventStaConnected), + 2, + rpc__event__sta_connected__field_descriptors, + rpc__event__sta_connected__field_indices_by_name, + 1, rpc__event__sta_connected__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_connected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_disconnected__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaDisconnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_disconnected", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaDisconnected, sta_disconnected), + &wifi_event_sta_disconnected__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_disconnected__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sta_disconnected */ +}; +static const ProtobufCIntRange rpc__event__sta_disconnected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_disconnected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaDisconnected", + "RpcEventStaDisconnected", + "RpcEventStaDisconnected", + "", + sizeof(RpcEventStaDisconnected), + 2, + rpc__event__sta_disconnected__field_descriptors, + rpc__event__sta_disconnected__field_indices_by_name, + 1, rpc__event__sta_disconnected__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_disconnected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__field_descriptors[121] = +{ + { + "msg_type", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Rpc, msg_type), + &rpc_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "msg_id", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Rpc, msg_id), + &rpc_id__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "uid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Rpc, uid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_mac_address", + 257, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_mac_address), + &rpc__req__get_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_mac_address", + 258, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_mac_address), + &rpc__req__set_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_wifi_mode", + 259, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_wifi_mode), + &rpc__req__get_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_wifi_mode", + 260, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_wifi_mode), + &rpc__req__set_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_ps", + 270, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_ps), + &rpc__req__set_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_ps", + 271, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_ps), + &rpc__req__get_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_ota_begin", + 272, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_ota_begin), + &rpc__req__otabegin__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_ota_write", + 273, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_ota_write), + &rpc__req__otawrite__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_ota_end", + 274, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_ota_end), + &rpc__req__otaend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_wifi_max_tx_power", + 275, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_wifi_max_tx_power), + &rpc__req__wifi_set_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_wifi_max_tx_power", + 276, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_wifi_max_tx_power), + &rpc__req__wifi_get_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_config_heartbeat", + 277, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_config_heartbeat), + &rpc__req__config_heartbeat__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_init", + 278, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_init), + &rpc__req__wifi_init__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_deinit", + 279, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_deinit), + &rpc__req__wifi_deinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_start", + 280, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_start), + &rpc__req__wifi_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_stop", + 281, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_stop), + &rpc__req__wifi_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_connect", + 282, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_connect), + &rpc__req__wifi_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_disconnect", + 283, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_disconnect), + &rpc__req__wifi_disconnect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_config", + 284, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_config), + &rpc__req__wifi_set_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_config", + 285, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_config), + &rpc__req__wifi_get_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_start", + 286, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_start), + &rpc__req__wifi_scan_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_stop", + 287, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_stop), + &rpc__req__wifi_scan_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_get_ap_num", + 288, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_get_ap_num), + &rpc__req__wifi_scan_get_ap_num__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_get_ap_records", + 289, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_get_ap_records), + &rpc__req__wifi_scan_get_ap_records__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_clear_ap_list", + 290, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_clear_ap_list), + &rpc__req__wifi_clear_ap_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_restore", + 291, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_restore), + &rpc__req__wifi_restore__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_clear_fast_connect", + 292, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_clear_fast_connect), + &rpc__req__wifi_clear_fast_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_deauth_sta", + 293, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_deauth_sta), + &rpc__req__wifi_deauth_sta__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_ap_info", + 294, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_ap_info), + &rpc__req__wifi_sta_get_ap_info__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_protocol", + 297, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_protocol), + &rpc__req__wifi_set_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_protocol", + 298, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_protocol), + &rpc__req__wifi_get_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_bandwidth", + 299, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_bandwidth), + &rpc__req__wifi_set_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_bandwidth", + 300, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_bandwidth), + &rpc__req__wifi_get_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_channel", + 301, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_channel), + &rpc__req__wifi_set_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_channel", + 302, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_channel), + &rpc__req__wifi_get_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_country", + 303, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_country), + &rpc__req__wifi_set_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_country", + 304, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_country), + &rpc__req__wifi_get_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_ap_get_sta_list", + 311, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_ap_get_sta_list), + &rpc__req__wifi_ap_get_sta_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_ap_get_sta_aid", + 312, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_ap_get_sta_aid), + &rpc__req__wifi_ap_get_sta_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_storage", + 313, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_storage), + &rpc__req__wifi_set_storage__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_country_code", + 334, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_country_code), + &rpc__req__wifi_set_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_country_code", + 335, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_country_code), + &rpc__req__wifi_get_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_aid", + 338, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_aid), + &rpc__req__wifi_sta_get_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_negotiated_phymode", + 339, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_negotiated_phymode), + &rpc__req__wifi_sta_get_negotiated_phymode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_rssi", + 341, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_rssi), + &rpc__req__wifi_sta_get_rssi__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_protocols", + 342, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_protocols), + &rpc__req__wifi_set_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_protocols", + 343, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_protocols), + &rpc__req__wifi_get_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_bandwidths", + 344, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_bandwidths), + &rpc__req__wifi_set_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_bandwidths", + 345, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_bandwidths), + &rpc__req__wifi_get_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_band", + 346, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_band), + &rpc__req__wifi_set_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_band", + 347, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_band), + &rpc__req__wifi_get_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_bandmode", + 348, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_bandmode), + &rpc__req__wifi_set_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_bandmode", + 349, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_bandmode), + &rpc__req__wifi_get_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_coprocessor_fwversion", + 350, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_coprocessor_fwversion), + &rpc__req__get_coprocessor_fw_version__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_get_ap_record", + 351, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_get_ap_record), + &rpc__req__wifi_scan_get_ap_record__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_mac_address", + 513, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_mac_address), + &rpc__resp__get_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_mac_address", + 514, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_mac_address), + &rpc__resp__set_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_wifi_mode", + 515, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_wifi_mode), + &rpc__resp__get_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_wifi_mode", + 516, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_wifi_mode), + &rpc__resp__set_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_ps", + 526, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_ps), + &rpc__resp__set_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_ps", + 527, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_ps), + &rpc__resp__get_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_ota_begin", + 528, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_ota_begin), + &rpc__resp__otabegin__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_ota_write", + 529, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_ota_write), + &rpc__resp__otawrite__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_ota_end", + 530, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_ota_end), + &rpc__resp__otaend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_wifi_max_tx_power", + 531, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_wifi_max_tx_power), + &rpc__resp__wifi_set_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_wifi_max_tx_power", + 532, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_wifi_max_tx_power), + &rpc__resp__wifi_get_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_config_heartbeat", + 533, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_config_heartbeat), + &rpc__resp__config_heartbeat__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_init", + 534, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_init), + &rpc__resp__wifi_init__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_deinit", + 535, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_deinit), + &rpc__resp__wifi_deinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_start", + 536, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_start), + &rpc__resp__wifi_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_stop", + 537, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_stop), + &rpc__resp__wifi_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_connect", + 538, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_connect), + &rpc__resp__wifi_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_disconnect", + 539, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_disconnect), + &rpc__resp__wifi_disconnect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_config", + 540, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_config), + &rpc__resp__wifi_set_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_config", + 541, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_config), + &rpc__resp__wifi_get_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_start", + 542, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_start), + &rpc__resp__wifi_scan_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_stop", + 543, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_stop), + &rpc__resp__wifi_scan_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_get_ap_num", + 544, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_get_ap_num), + &rpc__resp__wifi_scan_get_ap_num__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_get_ap_records", + 545, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_get_ap_records), + &rpc__resp__wifi_scan_get_ap_records__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_clear_ap_list", + 546, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_clear_ap_list), + &rpc__resp__wifi_clear_ap_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_restore", + 547, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_restore), + &rpc__resp__wifi_restore__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_clear_fast_connect", + 548, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_clear_fast_connect), + &rpc__resp__wifi_clear_fast_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_deauth_sta", + 549, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_deauth_sta), + &rpc__resp__wifi_deauth_sta__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_ap_info", + 550, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_ap_info), + &rpc__resp__wifi_sta_get_ap_info__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_protocol", + 553, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_protocol), + &rpc__resp__wifi_set_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_protocol", + 554, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_protocol), + &rpc__resp__wifi_get_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_bandwidth", + 555, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_bandwidth), + &rpc__resp__wifi_set_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_bandwidth", + 556, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_bandwidth), + &rpc__resp__wifi_get_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_channel", + 557, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_channel), + &rpc__resp__wifi_set_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_channel", + 558, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_channel), + &rpc__resp__wifi_get_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_country", + 559, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_country), + &rpc__resp__wifi_set_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_country", + 560, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_country), + &rpc__resp__wifi_get_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_ap_get_sta_list", + 567, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_ap_get_sta_list), + &rpc__resp__wifi_ap_get_sta_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_ap_get_sta_aid", + 568, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_ap_get_sta_aid), + &rpc__resp__wifi_ap_get_sta_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_storage", + 569, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_storage), + &rpc__resp__wifi_set_storage__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_country_code", + 590, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_country_code), + &rpc__resp__wifi_set_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_country_code", + 591, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_country_code), + &rpc__resp__wifi_get_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_aid", + 594, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_aid), + &rpc__resp__wifi_sta_get_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_negotiated_phymode", + 595, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_negotiated_phymode), + &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_rssi", + 597, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_rssi), + &rpc__resp__wifi_sta_get_rssi__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_protocols", + 598, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_protocols), + &rpc__resp__wifi_set_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_protocols", + 599, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_protocols), + &rpc__resp__wifi_get_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_bandwidths", + 600, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_bandwidths), + &rpc__resp__wifi_set_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_bandwidths", + 601, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_bandwidths), + &rpc__resp__wifi_get_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_band", + 602, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_band), + &rpc__resp__wifi_set_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_band", + 603, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_band), + &rpc__resp__wifi_get_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_bandmode", + 604, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_bandmode), + &rpc__resp__wifi_set_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_bandmode", + 605, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_bandmode), + &rpc__resp__wifi_get_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_coprocessor_fwversion", + 606, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_coprocessor_fwversion), + &rpc__resp__get_coprocessor_fw_version__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_get_ap_record", + 607, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_get_ap_record), + &rpc__resp__wifi_scan_get_ap_record__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_esp_init", + 769, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_esp_init), + &rpc__event__espinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_heartbeat", + 770, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_heartbeat), + &rpc__event__heartbeat__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_ap_sta_connected", + 771, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_ap_sta_connected), + &rpc__event__ap__sta_connected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_ap_sta_disconnected", + 772, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_ap_sta_disconnected), + &rpc__event__ap__sta_disconnected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_wifi_event_no_args", + 773, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_wifi_event_no_args), + &rpc__event__wifi_event_no_args__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_scan_done", + 774, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_scan_done), + &rpc__event__sta_scan_done__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_connected", + 775, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_connected), + &rpc__event__sta_connected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_disconnected", + 776, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_disconnected), + &rpc__event__sta_disconnected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__field_indices_by_name[] = { + 115, /* field[115] = event_ap_sta_connected */ + 116, /* field[116] = event_ap_sta_disconnected */ + 113, /* field[113] = event_esp_init */ + 114, /* field[114] = event_heartbeat */ + 119, /* field[119] = event_sta_connected */ + 120, /* field[120] = event_sta_disconnected */ + 118, /* field[118] = event_sta_scan_done */ + 117, /* field[117] = event_wifi_event_no_args */ + 1, /* field[1] = msg_id */ + 0, /* field[0] = msg_type */ + 14, /* field[14] = req_config_heartbeat */ + 56, /* field[56] = req_get_coprocessor_fwversion */ + 3, /* field[3] = req_get_mac_address */ + 13, /* field[13] = req_get_wifi_max_tx_power */ + 5, /* field[5] = req_get_wifi_mode */ + 9, /* field[9] = req_ota_begin */ + 11, /* field[11] = req_ota_end */ + 10, /* field[10] = req_ota_write */ + 4, /* field[4] = req_set_mac_address */ + 12, /* field[12] = req_set_wifi_max_tx_power */ + 6, /* field[6] = req_set_wifi_mode */ + 41, /* field[41] = req_wifi_ap_get_sta_aid */ + 40, /* field[40] = req_wifi_ap_get_sta_list */ + 27, /* field[27] = req_wifi_clear_ap_list */ + 29, /* field[29] = req_wifi_clear_fast_connect */ + 19, /* field[19] = req_wifi_connect */ + 30, /* field[30] = req_wifi_deauth_sta */ + 16, /* field[16] = req_wifi_deinit */ + 20, /* field[20] = req_wifi_disconnect */ + 53, /* field[53] = req_wifi_get_band */ + 55, /* field[55] = req_wifi_get_bandmode */ + 35, /* field[35] = req_wifi_get_bandwidth */ + 51, /* field[51] = req_wifi_get_bandwidths */ + 37, /* field[37] = req_wifi_get_channel */ + 22, /* field[22] = req_wifi_get_config */ + 39, /* field[39] = req_wifi_get_country */ + 44, /* field[44] = req_wifi_get_country_code */ + 33, /* field[33] = req_wifi_get_protocol */ + 49, /* field[49] = req_wifi_get_protocols */ + 8, /* field[8] = req_wifi_get_ps */ + 15, /* field[15] = req_wifi_init */ + 28, /* field[28] = req_wifi_restore */ + 25, /* field[25] = req_wifi_scan_get_ap_num */ + 57, /* field[57] = req_wifi_scan_get_ap_record */ + 26, /* field[26] = req_wifi_scan_get_ap_records */ + 23, /* field[23] = req_wifi_scan_start */ + 24, /* field[24] = req_wifi_scan_stop */ + 52, /* field[52] = req_wifi_set_band */ + 54, /* field[54] = req_wifi_set_bandmode */ + 34, /* field[34] = req_wifi_set_bandwidth */ + 50, /* field[50] = req_wifi_set_bandwidths */ + 36, /* field[36] = req_wifi_set_channel */ + 21, /* field[21] = req_wifi_set_config */ + 38, /* field[38] = req_wifi_set_country */ + 43, /* field[43] = req_wifi_set_country_code */ + 32, /* field[32] = req_wifi_set_protocol */ + 48, /* field[48] = req_wifi_set_protocols */ + 7, /* field[7] = req_wifi_set_ps */ + 42, /* field[42] = req_wifi_set_storage */ + 45, /* field[45] = req_wifi_sta_get_aid */ + 31, /* field[31] = req_wifi_sta_get_ap_info */ + 46, /* field[46] = req_wifi_sta_get_negotiated_phymode */ + 47, /* field[47] = req_wifi_sta_get_rssi */ + 17, /* field[17] = req_wifi_start */ + 18, /* field[18] = req_wifi_stop */ + 69, /* field[69] = resp_config_heartbeat */ + 111, /* field[111] = resp_get_coprocessor_fwversion */ + 58, /* field[58] = resp_get_mac_address */ + 68, /* field[68] = resp_get_wifi_max_tx_power */ + 60, /* field[60] = resp_get_wifi_mode */ + 64, /* field[64] = resp_ota_begin */ + 66, /* field[66] = resp_ota_end */ + 65, /* field[65] = resp_ota_write */ + 59, /* field[59] = resp_set_mac_address */ + 67, /* field[67] = resp_set_wifi_max_tx_power */ + 61, /* field[61] = resp_set_wifi_mode */ + 96, /* field[96] = resp_wifi_ap_get_sta_aid */ + 95, /* field[95] = resp_wifi_ap_get_sta_list */ + 82, /* field[82] = resp_wifi_clear_ap_list */ + 84, /* field[84] = resp_wifi_clear_fast_connect */ + 74, /* field[74] = resp_wifi_connect */ + 85, /* field[85] = resp_wifi_deauth_sta */ + 71, /* field[71] = resp_wifi_deinit */ + 75, /* field[75] = resp_wifi_disconnect */ + 108, /* field[108] = resp_wifi_get_band */ + 110, /* field[110] = resp_wifi_get_bandmode */ + 90, /* field[90] = resp_wifi_get_bandwidth */ + 106, /* field[106] = resp_wifi_get_bandwidths */ + 92, /* field[92] = resp_wifi_get_channel */ + 77, /* field[77] = resp_wifi_get_config */ + 94, /* field[94] = resp_wifi_get_country */ + 99, /* field[99] = resp_wifi_get_country_code */ + 88, /* field[88] = resp_wifi_get_protocol */ + 104, /* field[104] = resp_wifi_get_protocols */ + 63, /* field[63] = resp_wifi_get_ps */ + 70, /* field[70] = resp_wifi_init */ + 83, /* field[83] = resp_wifi_restore */ + 80, /* field[80] = resp_wifi_scan_get_ap_num */ + 112, /* field[112] = resp_wifi_scan_get_ap_record */ + 81, /* field[81] = resp_wifi_scan_get_ap_records */ + 78, /* field[78] = resp_wifi_scan_start */ + 79, /* field[79] = resp_wifi_scan_stop */ + 107, /* field[107] = resp_wifi_set_band */ + 109, /* field[109] = resp_wifi_set_bandmode */ + 89, /* field[89] = resp_wifi_set_bandwidth */ + 105, /* field[105] = resp_wifi_set_bandwidths */ + 91, /* field[91] = resp_wifi_set_channel */ + 76, /* field[76] = resp_wifi_set_config */ + 93, /* field[93] = resp_wifi_set_country */ + 98, /* field[98] = resp_wifi_set_country_code */ + 87, /* field[87] = resp_wifi_set_protocol */ + 103, /* field[103] = resp_wifi_set_protocols */ + 62, /* field[62] = resp_wifi_set_ps */ + 97, /* field[97] = resp_wifi_set_storage */ + 100, /* field[100] = resp_wifi_sta_get_aid */ + 86, /* field[86] = resp_wifi_sta_get_ap_info */ + 101, /* field[101] = resp_wifi_sta_get_negotiated_phymode */ + 102, /* field[102] = resp_wifi_sta_get_rssi */ + 72, /* field[72] = resp_wifi_start */ + 73, /* field[73] = resp_wifi_stop */ + 2, /* field[2] = uid */ +}; +static const ProtobufCIntRange rpc__number_ranges[16 + 1] = +{ + { 1, 0 }, + { 257, 3 }, + { 270, 7 }, + { 297, 32 }, + { 311, 40 }, + { 334, 43 }, + { 338, 45 }, + { 341, 47 }, + { 513, 58 }, + { 526, 62 }, + { 553, 87 }, + { 567, 95 }, + { 590, 98 }, + { 594, 100 }, + { 597, 102 }, + { 769, 113 }, + { 0, 121 } +}; +const ProtobufCMessageDescriptor rpc__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc", + "Rpc", + "Rpc", + "", + sizeof(Rpc), + 121, + rpc__field_descriptors, + rpc__field_indices_by_name, + 16, rpc__number_ranges, + (ProtobufCMessageInit) rpc__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue rpc__wifi_bw__enum_values_by_number[3] = +{ + { "BW_Invalid", "RPC__WIFI_BW__BW_Invalid", 0 }, + { "HT20", "RPC__WIFI_BW__HT20", 1 }, + { "HT40", "RPC__WIFI_BW__HT40", 2 }, +}; +static const ProtobufCIntRange rpc__wifi_bw__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex rpc__wifi_bw__enum_values_by_name[3] = +{ + { "BW_Invalid", 0 }, + { "HT20", 1 }, + { "HT40", 2 }, +}; +const ProtobufCEnumDescriptor rpc__wifi_bw__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_WifiBw", + "Rpc_WifiBw", + "RpcWifiBw", + "", + 3, + rpc__wifi_bw__enum_values_by_number, + 3, + rpc__wifi_bw__enum_values_by_name, + 1, + rpc__wifi_bw__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc__wifi_power_save__enum_values_by_number[3] = +{ + { "PS_Invalid", "RPC__WIFI_POWER_SAVE__PS_Invalid", 0 }, + { "MIN_MODEM", "RPC__WIFI_POWER_SAVE__MIN_MODEM", 1 }, + { "MAX_MODEM", "RPC__WIFI_POWER_SAVE__MAX_MODEM", 2 }, +}; +static const ProtobufCIntRange rpc__wifi_power_save__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex rpc__wifi_power_save__enum_values_by_name[3] = +{ + { "MAX_MODEM", 2 }, + { "MIN_MODEM", 1 }, + { "PS_Invalid", 0 }, +}; +const ProtobufCEnumDescriptor rpc__wifi_power_save__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_WifiPowerSave", + "Rpc_WifiPowerSave", + "RpcWifiPowerSave", + "", + 3, + rpc__wifi_power_save__enum_values_by_number, + 3, + rpc__wifi_power_save__enum_values_by_name, + 1, + rpc__wifi_power_save__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc__wifi_sec_prot__enum_values_by_number[8] = +{ + { "Open", "RPC__WIFI_SEC_PROT__Open", 0 }, + { "WEP", "RPC__WIFI_SEC_PROT__WEP", 1 }, + { "WPA_PSK", "RPC__WIFI_SEC_PROT__WPA_PSK", 2 }, + { "WPA2_PSK", "RPC__WIFI_SEC_PROT__WPA2_PSK", 3 }, + { "WPA_WPA2_PSK", "RPC__WIFI_SEC_PROT__WPA_WPA2_PSK", 4 }, + { "WPA2_ENTERPRISE", "RPC__WIFI_SEC_PROT__WPA2_ENTERPRISE", 5 }, + { "WPA3_PSK", "RPC__WIFI_SEC_PROT__WPA3_PSK", 6 }, + { "WPA2_WPA3_PSK", "RPC__WIFI_SEC_PROT__WPA2_WPA3_PSK", 7 }, +}; +static const ProtobufCIntRange rpc__wifi_sec_prot__value_ranges[] = { +{0, 0},{0, 8} +}; +static const ProtobufCEnumValueIndex rpc__wifi_sec_prot__enum_values_by_name[8] = +{ + { "Open", 0 }, + { "WEP", 1 }, + { "WPA2_ENTERPRISE", 5 }, + { "WPA2_PSK", 3 }, + { "WPA2_WPA3_PSK", 7 }, + { "WPA3_PSK", 6 }, + { "WPA_PSK", 2 }, + { "WPA_WPA2_PSK", 4 }, +}; +const ProtobufCEnumDescriptor rpc__wifi_sec_prot__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_WifiSecProt", + "Rpc_WifiSecProt", + "RpcWifiSecProt", + "", + 8, + rpc__wifi_sec_prot__enum_values_by_number, + 8, + rpc__wifi_sec_prot__enum_values_by_name, + 1, + rpc__wifi_sec_prot__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc__status__enum_values_by_number[6] = +{ + { "Connected", "RPC__STATUS__Connected", 0 }, + { "Not_Connected", "RPC__STATUS__Not_Connected", 1 }, + { "No_AP_Found", "RPC__STATUS__No_AP_Found", 2 }, + { "Connection_Fail", "RPC__STATUS__Connection_Fail", 3 }, + { "Invalid_Argument", "RPC__STATUS__Invalid_Argument", 4 }, + { "Out_Of_Range", "RPC__STATUS__Out_Of_Range", 5 }, +}; +static const ProtobufCIntRange rpc__status__value_ranges[] = { +{0, 0},{0, 6} +}; +static const ProtobufCEnumValueIndex rpc__status__enum_values_by_name[6] = +{ + { "Connected", 0 }, + { "Connection_Fail", 3 }, + { "Invalid_Argument", 4 }, + { "No_AP_Found", 2 }, + { "Not_Connected", 1 }, + { "Out_Of_Range", 5 }, +}; +const ProtobufCEnumDescriptor rpc__status__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_Status", + "Rpc_Status", + "RpcStatus", + "", + 6, + rpc__status__enum_values_by_number, + 6, + rpc__status__enum_values_by_name, + 1, + rpc__status__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_type__enum_values_by_number[5] = +{ + { "MsgType_Invalid", "RPC_TYPE__MsgType_Invalid", 0 }, + { "Req", "RPC_TYPE__Req", 1 }, + { "Resp", "RPC_TYPE__Resp", 2 }, + { "Event", "RPC_TYPE__Event", 3 }, + { "MsgType_Max", "RPC_TYPE__MsgType_Max", 4 }, +}; +static const ProtobufCIntRange rpc_type__value_ranges[] = { +{0, 0},{0, 5} +}; +static const ProtobufCEnumValueIndex rpc_type__enum_values_by_name[5] = +{ + { "Event", 3 }, + { "MsgType_Invalid", 0 }, + { "MsgType_Max", 4 }, + { "Req", 1 }, + { "Resp", 2 }, +}; +const ProtobufCEnumDescriptor rpc_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcType", + "RpcType", + "RpcType", + "", + 5, + rpc_type__enum_values_by_number, + 5, + rpc_type__enum_values_by_name, + 1, + rpc_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_id__enum_values_by_number[183] = +{ + { "MsgId_Invalid", "RPC_ID__MsgId_Invalid", 0 }, + { "Req_Base", "RPC_ID__Req_Base", 256 }, + { "Req_GetMACAddress", "RPC_ID__Req_GetMACAddress", 257 }, + { "Req_SetMacAddress", "RPC_ID__Req_SetMacAddress", 258 }, + { "Req_GetWifiMode", "RPC_ID__Req_GetWifiMode", 259 }, + { "Req_SetWifiMode", "RPC_ID__Req_SetWifiMode", 260 }, + { "Req_WifiSetPs", "RPC_ID__Req_WifiSetPs", 270 }, + { "Req_WifiGetPs", "RPC_ID__Req_WifiGetPs", 271 }, + { "Req_OTABegin", "RPC_ID__Req_OTABegin", 272 }, + { "Req_OTAWrite", "RPC_ID__Req_OTAWrite", 273 }, + { "Req_OTAEnd", "RPC_ID__Req_OTAEnd", 274 }, + { "Req_WifiSetMaxTxPower", "RPC_ID__Req_WifiSetMaxTxPower", 275 }, + { "Req_WifiGetMaxTxPower", "RPC_ID__Req_WifiGetMaxTxPower", 276 }, + { "Req_ConfigHeartbeat", "RPC_ID__Req_ConfigHeartbeat", 277 }, + { "Req_WifiInit", "RPC_ID__Req_WifiInit", 278 }, + { "Req_WifiDeinit", "RPC_ID__Req_WifiDeinit", 279 }, + { "Req_WifiStart", "RPC_ID__Req_WifiStart", 280 }, + { "Req_WifiStop", "RPC_ID__Req_WifiStop", 281 }, + { "Req_WifiConnect", "RPC_ID__Req_WifiConnect", 282 }, + { "Req_WifiDisconnect", "RPC_ID__Req_WifiDisconnect", 283 }, + { "Req_WifiSetConfig", "RPC_ID__Req_WifiSetConfig", 284 }, + { "Req_WifiGetConfig", "RPC_ID__Req_WifiGetConfig", 285 }, + { "Req_WifiScanStart", "RPC_ID__Req_WifiScanStart", 286 }, + { "Req_WifiScanStop", "RPC_ID__Req_WifiScanStop", 287 }, + { "Req_WifiScanGetApNum", "RPC_ID__Req_WifiScanGetApNum", 288 }, + { "Req_WifiScanGetApRecords", "RPC_ID__Req_WifiScanGetApRecords", 289 }, + { "Req_WifiClearApList", "RPC_ID__Req_WifiClearApList", 290 }, + { "Req_WifiRestore", "RPC_ID__Req_WifiRestore", 291 }, + { "Req_WifiClearFastConnect", "RPC_ID__Req_WifiClearFastConnect", 292 }, + { "Req_WifiDeauthSta", "RPC_ID__Req_WifiDeauthSta", 293 }, + { "Req_WifiStaGetApInfo", "RPC_ID__Req_WifiStaGetApInfo", 294 }, + { "Req_WifiSetProtocol", "RPC_ID__Req_WifiSetProtocol", 297 }, + { "Req_WifiGetProtocol", "RPC_ID__Req_WifiGetProtocol", 298 }, + { "Req_WifiSetBandwidth", "RPC_ID__Req_WifiSetBandwidth", 299 }, + { "Req_WifiGetBandwidth", "RPC_ID__Req_WifiGetBandwidth", 300 }, + { "Req_WifiSetChannel", "RPC_ID__Req_WifiSetChannel", 301 }, + { "Req_WifiGetChannel", "RPC_ID__Req_WifiGetChannel", 302 }, + { "Req_WifiSetCountry", "RPC_ID__Req_WifiSetCountry", 303 }, + { "Req_WifiGetCountry", "RPC_ID__Req_WifiGetCountry", 304 }, + { "Req_WifiSetPromiscuous", "RPC_ID__Req_WifiSetPromiscuous", 305 }, + { "Req_WifiGetPromiscuous", "RPC_ID__Req_WifiGetPromiscuous", 306 }, + { "Req_WifiSetPromiscuousFilter", "RPC_ID__Req_WifiSetPromiscuousFilter", 307 }, + { "Req_WifiGetPromiscuousFilter", "RPC_ID__Req_WifiGetPromiscuousFilter", 308 }, + { "Req_WifiSetPromiscuousCtrlFilter", "RPC_ID__Req_WifiSetPromiscuousCtrlFilter", 309 }, + { "Req_WifiGetPromiscuousCtrlFilter", "RPC_ID__Req_WifiGetPromiscuousCtrlFilter", 310 }, + { "Req_WifiApGetStaList", "RPC_ID__Req_WifiApGetStaList", 311 }, + { "Req_WifiApGetStaAid", "RPC_ID__Req_WifiApGetStaAid", 312 }, + { "Req_WifiSetStorage", "RPC_ID__Req_WifiSetStorage", 313 }, + { "Req_WifiSetVendorIe", "RPC_ID__Req_WifiSetVendorIe", 314 }, + { "Req_WifiSetEventMask", "RPC_ID__Req_WifiSetEventMask", 315 }, + { "Req_WifiGetEventMask", "RPC_ID__Req_WifiGetEventMask", 316 }, + { "Req_Wifi80211Tx", "RPC_ID__Req_Wifi80211Tx", 317 }, + { "Req_WifiSetCsiConfig", "RPC_ID__Req_WifiSetCsiConfig", 318 }, + { "Req_WifiSetCsi", "RPC_ID__Req_WifiSetCsi", 319 }, + { "Req_WifiSetAntGpio", "RPC_ID__Req_WifiSetAntGpio", 320 }, + { "Req_WifiGetAntGpio", "RPC_ID__Req_WifiGetAntGpio", 321 }, + { "Req_WifiSetAnt", "RPC_ID__Req_WifiSetAnt", 322 }, + { "Req_WifiGetAnt", "RPC_ID__Req_WifiGetAnt", 323 }, + { "Req_WifiGetTsfTime", "RPC_ID__Req_WifiGetTsfTime", 324 }, + { "Req_WifiSetInactiveTime", "RPC_ID__Req_WifiSetInactiveTime", 325 }, + { "Req_WifiGetInactiveTime", "RPC_ID__Req_WifiGetInactiveTime", 326 }, + { "Req_WifiStatisDump", "RPC_ID__Req_WifiStatisDump", 327 }, + { "Req_WifiSetRssiThreshold", "RPC_ID__Req_WifiSetRssiThreshold", 328 }, + { "Req_WifiFtmInitiateSession", "RPC_ID__Req_WifiFtmInitiateSession", 329 }, + { "Req_WifiFtmEndSession", "RPC_ID__Req_WifiFtmEndSession", 330 }, + { "Req_WifiFtmRespSetOffset", "RPC_ID__Req_WifiFtmRespSetOffset", 331 }, + { "Req_WifiConfig11bRate", "RPC_ID__Req_WifiConfig11bRate", 332 }, + { "Req_WifiConnectionlessModuleSetWakeInterval", "RPC_ID__Req_WifiConnectionlessModuleSetWakeInterval", 333 }, + { "Req_WifiSetCountryCode", "RPC_ID__Req_WifiSetCountryCode", 334 }, + { "Req_WifiGetCountryCode", "RPC_ID__Req_WifiGetCountryCode", 335 }, + { "Req_WifiConfig80211TxRate", "RPC_ID__Req_WifiConfig80211TxRate", 336 }, + { "Req_WifiDisablePmfConfig", "RPC_ID__Req_WifiDisablePmfConfig", 337 }, + { "Req_WifiStaGetAid", "RPC_ID__Req_WifiStaGetAid", 338 }, + { "Req_WifiStaGetNegotiatedPhymode", "RPC_ID__Req_WifiStaGetNegotiatedPhymode", 339 }, + { "Req_WifiSetDynamicCs", "RPC_ID__Req_WifiSetDynamicCs", 340 }, + { "Req_WifiStaGetRssi", "RPC_ID__Req_WifiStaGetRssi", 341 }, + { "Req_WifiSetProtocols", "RPC_ID__Req_WifiSetProtocols", 342 }, + { "Req_WifiGetProtocols", "RPC_ID__Req_WifiGetProtocols", 343 }, + { "Req_WifiSetBandwidths", "RPC_ID__Req_WifiSetBandwidths", 344 }, + { "Req_WifiGetBandwidths", "RPC_ID__Req_WifiGetBandwidths", 345 }, + { "Req_WifiSetBand", "RPC_ID__Req_WifiSetBand", 346 }, + { "Req_WifiGetBand", "RPC_ID__Req_WifiGetBand", 347 }, + { "Req_WifiSetBandMode", "RPC_ID__Req_WifiSetBandMode", 348 }, + { "Req_WifiGetBandMode", "RPC_ID__Req_WifiGetBandMode", 349 }, + { "Req_GetCoprocessorFwVersion", "RPC_ID__Req_GetCoprocessorFwVersion", 350 }, + { "Req_WifiScanGetApRecord", "RPC_ID__Req_WifiScanGetApRecord", 351 }, + { "Req_Max", "RPC_ID__Req_Max", 352 }, + { "Resp_Base", "RPC_ID__Resp_Base", 512 }, + { "Resp_GetMACAddress", "RPC_ID__Resp_GetMACAddress", 513 }, + { "Resp_SetMacAddress", "RPC_ID__Resp_SetMacAddress", 514 }, + { "Resp_GetWifiMode", "RPC_ID__Resp_GetWifiMode", 515 }, + { "Resp_SetWifiMode", "RPC_ID__Resp_SetWifiMode", 516 }, + { "Resp_WifiSetPs", "RPC_ID__Resp_WifiSetPs", 526 }, + { "Resp_WifiGetPs", "RPC_ID__Resp_WifiGetPs", 527 }, + { "Resp_OTABegin", "RPC_ID__Resp_OTABegin", 528 }, + { "Resp_OTAWrite", "RPC_ID__Resp_OTAWrite", 529 }, + { "Resp_OTAEnd", "RPC_ID__Resp_OTAEnd", 530 }, + { "Resp_WifiSetMaxTxPower", "RPC_ID__Resp_WifiSetMaxTxPower", 531 }, + { "Resp_WifiGetMaxTxPower", "RPC_ID__Resp_WifiGetMaxTxPower", 532 }, + { "Resp_ConfigHeartbeat", "RPC_ID__Resp_ConfigHeartbeat", 533 }, + { "Resp_WifiInit", "RPC_ID__Resp_WifiInit", 534 }, + { "Resp_WifiDeinit", "RPC_ID__Resp_WifiDeinit", 535 }, + { "Resp_WifiStart", "RPC_ID__Resp_WifiStart", 536 }, + { "Resp_WifiStop", "RPC_ID__Resp_WifiStop", 537 }, + { "Resp_WifiConnect", "RPC_ID__Resp_WifiConnect", 538 }, + { "Resp_WifiDisconnect", "RPC_ID__Resp_WifiDisconnect", 539 }, + { "Resp_WifiSetConfig", "RPC_ID__Resp_WifiSetConfig", 540 }, + { "Resp_WifiGetConfig", "RPC_ID__Resp_WifiGetConfig", 541 }, + { "Resp_WifiScanStart", "RPC_ID__Resp_WifiScanStart", 542 }, + { "Resp_WifiScanStop", "RPC_ID__Resp_WifiScanStop", 543 }, + { "Resp_WifiScanGetApNum", "RPC_ID__Resp_WifiScanGetApNum", 544 }, + { "Resp_WifiScanGetApRecords", "RPC_ID__Resp_WifiScanGetApRecords", 545 }, + { "Resp_WifiClearApList", "RPC_ID__Resp_WifiClearApList", 546 }, + { "Resp_WifiRestore", "RPC_ID__Resp_WifiRestore", 547 }, + { "Resp_WifiClearFastConnect", "RPC_ID__Resp_WifiClearFastConnect", 548 }, + { "Resp_WifiDeauthSta", "RPC_ID__Resp_WifiDeauthSta", 549 }, + { "Resp_WifiStaGetApInfo", "RPC_ID__Resp_WifiStaGetApInfo", 550 }, + { "Resp_WifiSetProtocol", "RPC_ID__Resp_WifiSetProtocol", 553 }, + { "Resp_WifiGetProtocol", "RPC_ID__Resp_WifiGetProtocol", 554 }, + { "Resp_WifiSetBandwidth", "RPC_ID__Resp_WifiSetBandwidth", 555 }, + { "Resp_WifiGetBandwidth", "RPC_ID__Resp_WifiGetBandwidth", 556 }, + { "Resp_WifiSetChannel", "RPC_ID__Resp_WifiSetChannel", 557 }, + { "Resp_WifiGetChannel", "RPC_ID__Resp_WifiGetChannel", 558 }, + { "Resp_WifiSetCountry", "RPC_ID__Resp_WifiSetCountry", 559 }, + { "Resp_WifiGetCountry", "RPC_ID__Resp_WifiGetCountry", 560 }, + { "Resp_WifiSetPromiscuous", "RPC_ID__Resp_WifiSetPromiscuous", 561 }, + { "Resp_WifiGetPromiscuous", "RPC_ID__Resp_WifiGetPromiscuous", 562 }, + { "Resp_WifiSetPromiscuousFilter", "RPC_ID__Resp_WifiSetPromiscuousFilter", 563 }, + { "Resp_WifiGetPromiscuousFilter", "RPC_ID__Resp_WifiGetPromiscuousFilter", 564 }, + { "Resp_WifiSetPromiscuousCtrlFilter", "RPC_ID__Resp_WifiSetPromiscuousCtrlFilter", 565 }, + { "Resp_WifiGetPromiscuousCtrlFilter", "RPC_ID__Resp_WifiGetPromiscuousCtrlFilter", 566 }, + { "Resp_WifiApGetStaList", "RPC_ID__Resp_WifiApGetStaList", 567 }, + { "Resp_WifiApGetStaAid", "RPC_ID__Resp_WifiApGetStaAid", 568 }, + { "Resp_WifiSetStorage", "RPC_ID__Resp_WifiSetStorage", 569 }, + { "Resp_WifiSetVendorIe", "RPC_ID__Resp_WifiSetVendorIe", 570 }, + { "Resp_WifiSetEventMask", "RPC_ID__Resp_WifiSetEventMask", 571 }, + { "Resp_WifiGetEventMask", "RPC_ID__Resp_WifiGetEventMask", 572 }, + { "Resp_Wifi80211Tx", "RPC_ID__Resp_Wifi80211Tx", 573 }, + { "Resp_WifiSetCsiConfig", "RPC_ID__Resp_WifiSetCsiConfig", 574 }, + { "Resp_WifiSetCsi", "RPC_ID__Resp_WifiSetCsi", 575 }, + { "Resp_WifiSetAntGpio", "RPC_ID__Resp_WifiSetAntGpio", 576 }, + { "Resp_WifiGetAntGpio", "RPC_ID__Resp_WifiGetAntGpio", 577 }, + { "Resp_WifiSetAnt", "RPC_ID__Resp_WifiSetAnt", 578 }, + { "Resp_WifiGetAnt", "RPC_ID__Resp_WifiGetAnt", 579 }, + { "Resp_WifiGetTsfTime", "RPC_ID__Resp_WifiGetTsfTime", 580 }, + { "Resp_WifiSetInactiveTime", "RPC_ID__Resp_WifiSetInactiveTime", 581 }, + { "Resp_WifiGetInactiveTime", "RPC_ID__Resp_WifiGetInactiveTime", 582 }, + { "Resp_WifiStatisDump", "RPC_ID__Resp_WifiStatisDump", 583 }, + { "Resp_WifiSetRssiThreshold", "RPC_ID__Resp_WifiSetRssiThreshold", 584 }, + { "Resp_WifiFtmInitiateSession", "RPC_ID__Resp_WifiFtmInitiateSession", 585 }, + { "Resp_WifiFtmEndSession", "RPC_ID__Resp_WifiFtmEndSession", 586 }, + { "Resp_WifiFtmRespSetOffset", "RPC_ID__Resp_WifiFtmRespSetOffset", 587 }, + { "Resp_WifiConfig11bRate", "RPC_ID__Resp_WifiConfig11bRate", 588 }, + { "Resp_WifiConnectionlessModuleSetWakeInterval", "RPC_ID__Resp_WifiConnectionlessModuleSetWakeInterval", 589 }, + { "Resp_WifiSetCountryCode", "RPC_ID__Resp_WifiSetCountryCode", 590 }, + { "Resp_WifiGetCountryCode", "RPC_ID__Resp_WifiGetCountryCode", 591 }, + { "Resp_WifiConfig80211TxRate", "RPC_ID__Resp_WifiConfig80211TxRate", 592 }, + { "Resp_WifiDisablePmfConfig", "RPC_ID__Resp_WifiDisablePmfConfig", 593 }, + { "Resp_WifiStaGetAid", "RPC_ID__Resp_WifiStaGetAid", 594 }, + { "Resp_WifiStaGetNegotiatedPhymode", "RPC_ID__Resp_WifiStaGetNegotiatedPhymode", 595 }, + { "Resp_WifiSetDynamicCs", "RPC_ID__Resp_WifiSetDynamicCs", 596 }, + { "Resp_WifiStaGetRssi", "RPC_ID__Resp_WifiStaGetRssi", 597 }, + { "Resp_WifiSetProtocols", "RPC_ID__Resp_WifiSetProtocols", 598 }, + { "Resp_WifiGetProtocols", "RPC_ID__Resp_WifiGetProtocols", 599 }, + { "Resp_WifiSetBandwidths", "RPC_ID__Resp_WifiSetBandwidths", 600 }, + { "Resp_WifiGetBandwidths", "RPC_ID__Resp_WifiGetBandwidths", 601 }, + { "Resp_WifiSetBand", "RPC_ID__Resp_WifiSetBand", 602 }, + { "Resp_WifiGetBand", "RPC_ID__Resp_WifiGetBand", 603 }, + { "Resp_WifiSetBandMode", "RPC_ID__Resp_WifiSetBandMode", 604 }, + { "Resp_WifiGetBandMode", "RPC_ID__Resp_WifiGetBandMode", 605 }, + { "Resp_GetCoprocessorFwVersion", "RPC_ID__Resp_GetCoprocessorFwVersion", 606 }, + { "Resp_WifiScanGetApRecord", "RPC_ID__Resp_WifiScanGetApRecord", 607 }, + { "Resp_Max", "RPC_ID__Resp_Max", 608 }, + { "Event_Base", "RPC_ID__Event_Base", 768 }, + { "Event_ESPInit", "RPC_ID__Event_ESPInit", 769 }, + { "Event_Heartbeat", "RPC_ID__Event_Heartbeat", 770 }, + { "Event_AP_StaConnected", "RPC_ID__Event_AP_StaConnected", 771 }, + { "Event_AP_StaDisconnected", "RPC_ID__Event_AP_StaDisconnected", 772 }, + { "Event_WifiEventNoArgs", "RPC_ID__Event_WifiEventNoArgs", 773 }, + { "Event_StaScanDone", "RPC_ID__Event_StaScanDone", 774 }, + { "Event_StaConnected", "RPC_ID__Event_StaConnected", 775 }, + { "Event_StaDisconnected", "RPC_ID__Event_StaDisconnected", 776 }, + { "Event_Max", "RPC_ID__Event_Max", 777 }, +}; +static const ProtobufCIntRange rpc_id__value_ranges[] = { +{0, 0},{256, 1},{270, 6},{297, 31},{512, 87},{526, 92},{553, 117},{768, 173},{0, 183} +}; +static const ProtobufCEnumValueIndex rpc_id__enum_values_by_name[183] = +{ + { "Event_AP_StaConnected", 176 }, + { "Event_AP_StaDisconnected", 177 }, + { "Event_Base", 173 }, + { "Event_ESPInit", 174 }, + { "Event_Heartbeat", 175 }, + { "Event_Max", 182 }, + { "Event_StaConnected", 180 }, + { "Event_StaDisconnected", 181 }, + { "Event_StaScanDone", 179 }, + { "Event_WifiEventNoArgs", 178 }, + { "MsgId_Invalid", 0 }, + { "Req_Base", 1 }, + { "Req_ConfigHeartbeat", 13 }, + { "Req_GetCoprocessorFwVersion", 84 }, + { "Req_GetMACAddress", 2 }, + { "Req_GetWifiMode", 4 }, + { "Req_Max", 86 }, + { "Req_OTABegin", 8 }, + { "Req_OTAEnd", 10 }, + { "Req_OTAWrite", 9 }, + { "Req_SetMacAddress", 3 }, + { "Req_SetWifiMode", 5 }, + { "Req_Wifi80211Tx", 51 }, + { "Req_WifiApGetStaAid", 46 }, + { "Req_WifiApGetStaList", 45 }, + { "Req_WifiClearApList", 26 }, + { "Req_WifiClearFastConnect", 28 }, + { "Req_WifiConfig11bRate", 66 }, + { "Req_WifiConfig80211TxRate", 70 }, + { "Req_WifiConnect", 18 }, + { "Req_WifiConnectionlessModuleSetWakeInterval", 67 }, + { "Req_WifiDeauthSta", 29 }, + { "Req_WifiDeinit", 15 }, + { "Req_WifiDisablePmfConfig", 71 }, + { "Req_WifiDisconnect", 19 }, + { "Req_WifiFtmEndSession", 64 }, + { "Req_WifiFtmInitiateSession", 63 }, + { "Req_WifiFtmRespSetOffset", 65 }, + { "Req_WifiGetAnt", 57 }, + { "Req_WifiGetAntGpio", 55 }, + { "Req_WifiGetBand", 81 }, + { "Req_WifiGetBandMode", 83 }, + { "Req_WifiGetBandwidth", 34 }, + { "Req_WifiGetBandwidths", 79 }, + { "Req_WifiGetChannel", 36 }, + { "Req_WifiGetConfig", 21 }, + { "Req_WifiGetCountry", 38 }, + { "Req_WifiGetCountryCode", 69 }, + { "Req_WifiGetEventMask", 50 }, + { "Req_WifiGetInactiveTime", 60 }, + { "Req_WifiGetMaxTxPower", 12 }, + { "Req_WifiGetPromiscuous", 40 }, + { "Req_WifiGetPromiscuousCtrlFilter", 44 }, + { "Req_WifiGetPromiscuousFilter", 42 }, + { "Req_WifiGetProtocol", 32 }, + { "Req_WifiGetProtocols", 77 }, + { "Req_WifiGetPs", 7 }, + { "Req_WifiGetTsfTime", 58 }, + { "Req_WifiInit", 14 }, + { "Req_WifiRestore", 27 }, + { "Req_WifiScanGetApNum", 24 }, + { "Req_WifiScanGetApRecord", 85 }, + { "Req_WifiScanGetApRecords", 25 }, + { "Req_WifiScanStart", 22 }, + { "Req_WifiScanStop", 23 }, + { "Req_WifiSetAnt", 56 }, + { "Req_WifiSetAntGpio", 54 }, + { "Req_WifiSetBand", 80 }, + { "Req_WifiSetBandMode", 82 }, + { "Req_WifiSetBandwidth", 33 }, + { "Req_WifiSetBandwidths", 78 }, + { "Req_WifiSetChannel", 35 }, + { "Req_WifiSetConfig", 20 }, + { "Req_WifiSetCountry", 37 }, + { "Req_WifiSetCountryCode", 68 }, + { "Req_WifiSetCsi", 53 }, + { "Req_WifiSetCsiConfig", 52 }, + { "Req_WifiSetDynamicCs", 74 }, + { "Req_WifiSetEventMask", 49 }, + { "Req_WifiSetInactiveTime", 59 }, + { "Req_WifiSetMaxTxPower", 11 }, + { "Req_WifiSetPromiscuous", 39 }, + { "Req_WifiSetPromiscuousCtrlFilter", 43 }, + { "Req_WifiSetPromiscuousFilter", 41 }, + { "Req_WifiSetProtocol", 31 }, + { "Req_WifiSetProtocols", 76 }, + { "Req_WifiSetPs", 6 }, + { "Req_WifiSetRssiThreshold", 62 }, + { "Req_WifiSetStorage", 47 }, + { "Req_WifiSetVendorIe", 48 }, + { "Req_WifiStaGetAid", 72 }, + { "Req_WifiStaGetApInfo", 30 }, + { "Req_WifiStaGetNegotiatedPhymode", 73 }, + { "Req_WifiStaGetRssi", 75 }, + { "Req_WifiStart", 16 }, + { "Req_WifiStatisDump", 61 }, + { "Req_WifiStop", 17 }, + { "Resp_Base", 87 }, + { "Resp_ConfigHeartbeat", 99 }, + { "Resp_GetCoprocessorFwVersion", 170 }, + { "Resp_GetMACAddress", 88 }, + { "Resp_GetWifiMode", 90 }, + { "Resp_Max", 172 }, + { "Resp_OTABegin", 94 }, + { "Resp_OTAEnd", 96 }, + { "Resp_OTAWrite", 95 }, + { "Resp_SetMacAddress", 89 }, + { "Resp_SetWifiMode", 91 }, + { "Resp_Wifi80211Tx", 137 }, + { "Resp_WifiApGetStaAid", 132 }, + { "Resp_WifiApGetStaList", 131 }, + { "Resp_WifiClearApList", 112 }, + { "Resp_WifiClearFastConnect", 114 }, + { "Resp_WifiConfig11bRate", 152 }, + { "Resp_WifiConfig80211TxRate", 156 }, + { "Resp_WifiConnect", 104 }, + { "Resp_WifiConnectionlessModuleSetWakeInterval", 153 }, + { "Resp_WifiDeauthSta", 115 }, + { "Resp_WifiDeinit", 101 }, + { "Resp_WifiDisablePmfConfig", 157 }, + { "Resp_WifiDisconnect", 105 }, + { "Resp_WifiFtmEndSession", 150 }, + { "Resp_WifiFtmInitiateSession", 149 }, + { "Resp_WifiFtmRespSetOffset", 151 }, + { "Resp_WifiGetAnt", 143 }, + { "Resp_WifiGetAntGpio", 141 }, + { "Resp_WifiGetBand", 167 }, + { "Resp_WifiGetBandMode", 169 }, + { "Resp_WifiGetBandwidth", 120 }, + { "Resp_WifiGetBandwidths", 165 }, + { "Resp_WifiGetChannel", 122 }, + { "Resp_WifiGetConfig", 107 }, + { "Resp_WifiGetCountry", 124 }, + { "Resp_WifiGetCountryCode", 155 }, + { "Resp_WifiGetEventMask", 136 }, + { "Resp_WifiGetInactiveTime", 146 }, + { "Resp_WifiGetMaxTxPower", 98 }, + { "Resp_WifiGetPromiscuous", 126 }, + { "Resp_WifiGetPromiscuousCtrlFilter", 130 }, + { "Resp_WifiGetPromiscuousFilter", 128 }, + { "Resp_WifiGetProtocol", 118 }, + { "Resp_WifiGetProtocols", 163 }, + { "Resp_WifiGetPs", 93 }, + { "Resp_WifiGetTsfTime", 144 }, + { "Resp_WifiInit", 100 }, + { "Resp_WifiRestore", 113 }, + { "Resp_WifiScanGetApNum", 110 }, + { "Resp_WifiScanGetApRecord", 171 }, + { "Resp_WifiScanGetApRecords", 111 }, + { "Resp_WifiScanStart", 108 }, + { "Resp_WifiScanStop", 109 }, + { "Resp_WifiSetAnt", 142 }, + { "Resp_WifiSetAntGpio", 140 }, + { "Resp_WifiSetBand", 166 }, + { "Resp_WifiSetBandMode", 168 }, + { "Resp_WifiSetBandwidth", 119 }, + { "Resp_WifiSetBandwidths", 164 }, + { "Resp_WifiSetChannel", 121 }, + { "Resp_WifiSetConfig", 106 }, + { "Resp_WifiSetCountry", 123 }, + { "Resp_WifiSetCountryCode", 154 }, + { "Resp_WifiSetCsi", 139 }, + { "Resp_WifiSetCsiConfig", 138 }, + { "Resp_WifiSetDynamicCs", 160 }, + { "Resp_WifiSetEventMask", 135 }, + { "Resp_WifiSetInactiveTime", 145 }, + { "Resp_WifiSetMaxTxPower", 97 }, + { "Resp_WifiSetPromiscuous", 125 }, + { "Resp_WifiSetPromiscuousCtrlFilter", 129 }, + { "Resp_WifiSetPromiscuousFilter", 127 }, + { "Resp_WifiSetProtocol", 117 }, + { "Resp_WifiSetProtocols", 162 }, + { "Resp_WifiSetPs", 92 }, + { "Resp_WifiSetRssiThreshold", 148 }, + { "Resp_WifiSetStorage", 133 }, + { "Resp_WifiSetVendorIe", 134 }, + { "Resp_WifiStaGetAid", 158 }, + { "Resp_WifiStaGetApInfo", 116 }, + { "Resp_WifiStaGetNegotiatedPhymode", 159 }, + { "Resp_WifiStaGetRssi", 161 }, + { "Resp_WifiStart", 102 }, + { "Resp_WifiStatisDump", 147 }, + { "Resp_WifiStop", 103 }, +}; +const ProtobufCEnumDescriptor rpc_id__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcId", + "RpcId", + "RpcId", + "", + 183, + rpc_id__enum_values_by_number, + 183, + rpc_id__enum_values_by_name, + 8, + rpc_id__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.pb-c.h b/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.pb-c.h new file mode 100644 index 0000000..03a11fc --- /dev/null +++ b/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.pb-c.h @@ -0,0 +1,7219 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: esp_hosted_rpc.proto */ + +#ifndef PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED +#define PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct WifiInitConfig WifiInitConfig; +typedef struct WifiCountry WifiCountry; +typedef struct WifiActiveScanTime WifiActiveScanTime; +typedef struct WifiScanTime WifiScanTime; +typedef struct WifiScanConfig WifiScanConfig; +typedef struct WifiHeApInfo WifiHeApInfo; +typedef struct WifiApRecord WifiApRecord; +typedef struct WifiScanThreshold WifiScanThreshold; +typedef struct WifiPmfConfig WifiPmfConfig; +typedef struct WifiApConfig WifiApConfig; +typedef struct WifiStaConfig WifiStaConfig; +typedef struct WifiConfig WifiConfig; +typedef struct WifiStaInfo WifiStaInfo; +typedef struct WifiStaList WifiStaList; +typedef struct WifiPktRxCtrl WifiPktRxCtrl; +typedef struct WifiPromiscuousPkt WifiPromiscuousPkt; +typedef struct WifiPromiscuousFilter WifiPromiscuousFilter; +typedef struct WifiCsiConfig WifiCsiConfig; +typedef struct WifiCsiInfo WifiCsiInfo; +typedef struct WifiAntGpio WifiAntGpio; +typedef struct WifiAntGpioConfig WifiAntGpioConfig; +typedef struct WifiAntConfig WifiAntConfig; +typedef struct WifiActionTxReq WifiActionTxReq; +typedef struct WifiFtmInitiatorCfg WifiFtmInitiatorCfg; +typedef struct WifiEventStaScanDone WifiEventStaScanDone; +typedef struct WifiEventStaConnected WifiEventStaConnected; +typedef struct WifiEventStaDisconnected WifiEventStaDisconnected; +typedef struct WifiEventStaAuthmodeChange WifiEventStaAuthmodeChange; +typedef struct WifiEventStaWpsErPin WifiEventStaWpsErPin; +typedef struct ApCred ApCred; +typedef struct WifiEventStaWpsErSuccess WifiEventStaWpsErSuccess; +typedef struct WifiEventApProbeReqRx WifiEventApProbeReqRx; +typedef struct WifiEventBssRssiLow WifiEventBssRssiLow; +typedef struct WifiFtmReportEntry WifiFtmReportEntry; +typedef struct WifiEventFtmReport WifiEventFtmReport; +typedef struct WifiEventActionTxStatus WifiEventActionTxStatus; +typedef struct WifiEventRocDone WifiEventRocDone; +typedef struct WifiEventApWpsRgPin WifiEventApWpsRgPin; +typedef struct WifiEventApWpsRgFailReason WifiEventApWpsRgFailReason; +typedef struct WifiEventApWpsRgSuccess WifiEventApWpsRgSuccess; +typedef struct WifiProtocols WifiProtocols; +typedef struct WifiBandwidths WifiBandwidths; +typedef struct ConnectedSTAList ConnectedSTAList; +typedef struct RpcReqGetMacAddress RpcReqGetMacAddress; +typedef struct RpcRespGetMacAddress RpcRespGetMacAddress; +typedef struct RpcReqGetMode RpcReqGetMode; +typedef struct RpcRespGetMode RpcRespGetMode; +typedef struct RpcReqSetMode RpcReqSetMode; +typedef struct RpcRespSetMode RpcRespSetMode; +typedef struct RpcReqGetPs RpcReqGetPs; +typedef struct RpcRespGetPs RpcRespGetPs; +typedef struct RpcReqSetPs RpcReqSetPs; +typedef struct RpcRespSetPs RpcRespSetPs; +typedef struct RpcReqSetMacAddress RpcReqSetMacAddress; +typedef struct RpcRespSetMacAddress RpcRespSetMacAddress; +typedef struct RpcReqOTABegin RpcReqOTABegin; +typedef struct RpcRespOTABegin RpcRespOTABegin; +typedef struct RpcReqOTAWrite RpcReqOTAWrite; +typedef struct RpcRespOTAWrite RpcRespOTAWrite; +typedef struct RpcReqOTAEnd RpcReqOTAEnd; +typedef struct RpcRespOTAEnd RpcRespOTAEnd; +typedef struct RpcReqWifiSetMaxTxPower RpcReqWifiSetMaxTxPower; +typedef struct RpcRespWifiSetMaxTxPower RpcRespWifiSetMaxTxPower; +typedef struct RpcReqWifiGetMaxTxPower RpcReqWifiGetMaxTxPower; +typedef struct RpcRespWifiGetMaxTxPower RpcRespWifiGetMaxTxPower; +typedef struct RpcReqConfigHeartbeat RpcReqConfigHeartbeat; +typedef struct RpcRespConfigHeartbeat RpcRespConfigHeartbeat; +typedef struct RpcReqWifiInit RpcReqWifiInit; +typedef struct RpcRespWifiInit RpcRespWifiInit; +typedef struct RpcReqWifiDeinit RpcReqWifiDeinit; +typedef struct RpcRespWifiDeinit RpcRespWifiDeinit; +typedef struct RpcReqWifiSetConfig RpcReqWifiSetConfig; +typedef struct RpcRespWifiSetConfig RpcRespWifiSetConfig; +typedef struct RpcReqWifiGetConfig RpcReqWifiGetConfig; +typedef struct RpcRespWifiGetConfig RpcRespWifiGetConfig; +typedef struct RpcReqWifiConnect RpcReqWifiConnect; +typedef struct RpcRespWifiConnect RpcRespWifiConnect; +typedef struct RpcReqWifiDisconnect RpcReqWifiDisconnect; +typedef struct RpcRespWifiDisconnect RpcRespWifiDisconnect; +typedef struct RpcReqWifiStart RpcReqWifiStart; +typedef struct RpcRespWifiStart RpcRespWifiStart; +typedef struct RpcReqWifiStop RpcReqWifiStop; +typedef struct RpcRespWifiStop RpcRespWifiStop; +typedef struct RpcReqWifiScanStart RpcReqWifiScanStart; +typedef struct RpcRespWifiScanStart RpcRespWifiScanStart; +typedef struct RpcReqWifiScanStop RpcReqWifiScanStop; +typedef struct RpcRespWifiScanStop RpcRespWifiScanStop; +typedef struct RpcReqWifiScanGetApNum RpcReqWifiScanGetApNum; +typedef struct RpcRespWifiScanGetApNum RpcRespWifiScanGetApNum; +typedef struct RpcReqWifiScanGetApRecords RpcReqWifiScanGetApRecords; +typedef struct RpcRespWifiScanGetApRecords RpcRespWifiScanGetApRecords; +typedef struct RpcReqWifiScanGetApRecord RpcReqWifiScanGetApRecord; +typedef struct RpcRespWifiScanGetApRecord RpcRespWifiScanGetApRecord; +typedef struct RpcReqWifiClearApList RpcReqWifiClearApList; +typedef struct RpcRespWifiClearApList RpcRespWifiClearApList; +typedef struct RpcReqWifiRestore RpcReqWifiRestore; +typedef struct RpcRespWifiRestore RpcRespWifiRestore; +typedef struct RpcReqWifiClearFastConnect RpcReqWifiClearFastConnect; +typedef struct RpcRespWifiClearFastConnect RpcRespWifiClearFastConnect; +typedef struct RpcReqWifiDeauthSta RpcReqWifiDeauthSta; +typedef struct RpcRespWifiDeauthSta RpcRespWifiDeauthSta; +typedef struct RpcReqWifiStaGetApInfo RpcReqWifiStaGetApInfo; +typedef struct RpcRespWifiStaGetApInfo RpcRespWifiStaGetApInfo; +typedef struct RpcReqWifiSetProtocol RpcReqWifiSetProtocol; +typedef struct RpcRespWifiSetProtocol RpcRespWifiSetProtocol; +typedef struct RpcReqWifiGetProtocol RpcReqWifiGetProtocol; +typedef struct RpcRespWifiGetProtocol RpcRespWifiGetProtocol; +typedef struct RpcReqWifiSetBandwidth RpcReqWifiSetBandwidth; +typedef struct RpcRespWifiSetBandwidth RpcRespWifiSetBandwidth; +typedef struct RpcReqWifiGetBandwidth RpcReqWifiGetBandwidth; +typedef struct RpcRespWifiGetBandwidth RpcRespWifiGetBandwidth; +typedef struct RpcReqWifiSetChannel RpcReqWifiSetChannel; +typedef struct RpcRespWifiSetChannel RpcRespWifiSetChannel; +typedef struct RpcReqWifiGetChannel RpcReqWifiGetChannel; +typedef struct RpcRespWifiGetChannel RpcRespWifiGetChannel; +typedef struct RpcReqWifiSetStorage RpcReqWifiSetStorage; +typedef struct RpcRespWifiSetStorage RpcRespWifiSetStorage; +typedef struct RpcReqWifiSetCountryCode RpcReqWifiSetCountryCode; +typedef struct RpcRespWifiSetCountryCode RpcRespWifiSetCountryCode; +typedef struct RpcReqWifiGetCountryCode RpcReqWifiGetCountryCode; +typedef struct RpcRespWifiGetCountryCode RpcRespWifiGetCountryCode; +typedef struct RpcReqWifiSetCountry RpcReqWifiSetCountry; +typedef struct RpcRespWifiSetCountry RpcRespWifiSetCountry; +typedef struct RpcReqWifiGetCountry RpcReqWifiGetCountry; +typedef struct RpcRespWifiGetCountry RpcRespWifiGetCountry; +typedef struct RpcReqWifiApGetStaList RpcReqWifiApGetStaList; +typedef struct RpcRespWifiApGetStaList RpcRespWifiApGetStaList; +typedef struct RpcReqWifiApGetStaAid RpcReqWifiApGetStaAid; +typedef struct RpcReqWifiStaGetNegotiatedPhymode RpcReqWifiStaGetNegotiatedPhymode; +typedef struct RpcRespWifiStaGetNegotiatedPhymode RpcRespWifiStaGetNegotiatedPhymode; +typedef struct RpcRespWifiApGetStaAid RpcRespWifiApGetStaAid; +typedef struct RpcReqWifiStaGetRssi RpcReqWifiStaGetRssi; +typedef struct RpcRespWifiStaGetRssi RpcRespWifiStaGetRssi; +typedef struct RpcReqWifiStaGetAid RpcReqWifiStaGetAid; +typedef struct RpcRespWifiStaGetAid RpcRespWifiStaGetAid; +typedef struct RpcReqWifiSetProtocols RpcReqWifiSetProtocols; +typedef struct RpcRespWifiSetProtocols RpcRespWifiSetProtocols; +typedef struct RpcReqWifiGetProtocols RpcReqWifiGetProtocols; +typedef struct RpcRespWifiGetProtocols RpcRespWifiGetProtocols; +typedef struct RpcReqWifiSetBandwidths RpcReqWifiSetBandwidths; +typedef struct RpcRespWifiSetBandwidths RpcRespWifiSetBandwidths; +typedef struct RpcReqWifiGetBandwidths RpcReqWifiGetBandwidths; +typedef struct RpcRespWifiGetBandwidths RpcRespWifiGetBandwidths; +typedef struct RpcReqWifiSetBand RpcReqWifiSetBand; +typedef struct RpcRespWifiSetBand RpcRespWifiSetBand; +typedef struct RpcReqWifiGetBand RpcReqWifiGetBand; +typedef struct RpcRespWifiGetBand RpcRespWifiGetBand; +typedef struct RpcReqWifiSetBandMode RpcReqWifiSetBandMode; +typedef struct RpcRespWifiSetBandMode RpcRespWifiSetBandMode; +typedef struct RpcReqWifiGetBandMode RpcReqWifiGetBandMode; +typedef struct RpcRespWifiGetBandMode RpcRespWifiGetBandMode; +typedef struct RpcReqGetCoprocessorFwVersion RpcReqGetCoprocessorFwVersion; +typedef struct RpcRespGetCoprocessorFwVersion RpcRespGetCoprocessorFwVersion; +typedef struct RpcEventWifiEventNoArgs RpcEventWifiEventNoArgs; +typedef struct RpcEventESPInit RpcEventESPInit; +typedef struct RpcEventHeartbeat RpcEventHeartbeat; +typedef struct RpcEventAPStaDisconnected RpcEventAPStaDisconnected; +typedef struct RpcEventAPStaConnected RpcEventAPStaConnected; +typedef struct RpcEventStaScanDone RpcEventStaScanDone; +typedef struct RpcEventStaConnected RpcEventStaConnected; +typedef struct RpcEventStaDisconnected RpcEventStaDisconnected; +typedef struct Rpc Rpc; + + +/* --- enums --- */ + +typedef enum _RpcWifiBw { + RPC__WIFI_BW__BW_Invalid = 0, + RPC__WIFI_BW__HT20 = 1, + RPC__WIFI_BW__HT40 = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_BW) +} RpcWifiBw; +typedef enum _RpcWifiPowerSave { + RPC__WIFI_POWER_SAVE__PS_Invalid = 0, + RPC__WIFI_POWER_SAVE__MIN_MODEM = 1, + RPC__WIFI_POWER_SAVE__MAX_MODEM = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_POWER_SAVE) +} RpcWifiPowerSave; +typedef enum _RpcWifiSecProt { + RPC__WIFI_SEC_PROT__Open = 0, + RPC__WIFI_SEC_PROT__WEP = 1, + RPC__WIFI_SEC_PROT__WPA_PSK = 2, + RPC__WIFI_SEC_PROT__WPA2_PSK = 3, + RPC__WIFI_SEC_PROT__WPA_WPA2_PSK = 4, + RPC__WIFI_SEC_PROT__WPA2_ENTERPRISE = 5, + RPC__WIFI_SEC_PROT__WPA3_PSK = 6, + RPC__WIFI_SEC_PROT__WPA2_WPA3_PSK = 7 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_SEC_PROT) +} RpcWifiSecProt; +/* + * enums for Control path + */ +typedef enum _RpcStatus { + RPC__STATUS__Connected = 0, + RPC__STATUS__Not_Connected = 1, + RPC__STATUS__No_AP_Found = 2, + RPC__STATUS__Connection_Fail = 3, + RPC__STATUS__Invalid_Argument = 4, + RPC__STATUS__Out_Of_Range = 5 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__STATUS) +} RpcStatus; +typedef enum _RpcType { + RPC_TYPE__MsgType_Invalid = 0, + RPC_TYPE__Req = 1, + RPC_TYPE__Resp = 2, + RPC_TYPE__Event = 3, + RPC_TYPE__MsgType_Max = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_TYPE) +} RpcType; +typedef enum _RpcId { + RPC_ID__MsgId_Invalid = 0, + /* + ** Request Msgs * + */ + /* + *0x100 + */ + RPC_ID__Req_Base = 256, + /* + *0x101 + */ + RPC_ID__Req_GetMACAddress = 257, + /* + *0x102 + */ + RPC_ID__Req_SetMacAddress = 258, + /* + *0x103 + */ + RPC_ID__Req_GetWifiMode = 259, + /* + *0x104 + */ + RPC_ID__Req_SetWifiMode = 260, + /* + *0x10e + */ + RPC_ID__Req_WifiSetPs = 270, + /* + *0x10f + */ + RPC_ID__Req_WifiGetPs = 271, + /* + *0x110 + */ + RPC_ID__Req_OTABegin = 272, + /* + *0x111 + */ + RPC_ID__Req_OTAWrite = 273, + /* + *0x112 + */ + RPC_ID__Req_OTAEnd = 274, + /* + *0x113 + */ + RPC_ID__Req_WifiSetMaxTxPower = 275, + /* + *0x114 + */ + RPC_ID__Req_WifiGetMaxTxPower = 276, + /* + *0x115 + */ + RPC_ID__Req_ConfigHeartbeat = 277, + /* + *0x116 + */ + RPC_ID__Req_WifiInit = 278, + /* + *0x117 + */ + RPC_ID__Req_WifiDeinit = 279, + /* + *0x118 + */ + RPC_ID__Req_WifiStart = 280, + /* + *0x119 + */ + RPC_ID__Req_WifiStop = 281, + /* + *0x11a + */ + RPC_ID__Req_WifiConnect = 282, + /* + *0x11b + */ + RPC_ID__Req_WifiDisconnect = 283, + /* + *0x11c + */ + RPC_ID__Req_WifiSetConfig = 284, + /* + *0x11d + */ + RPC_ID__Req_WifiGetConfig = 285, + /* + *0x11e + */ + RPC_ID__Req_WifiScanStart = 286, + /* + *0x11f + */ + RPC_ID__Req_WifiScanStop = 287, + /* + *0x120 + */ + RPC_ID__Req_WifiScanGetApNum = 288, + /* + *0x121 + */ + RPC_ID__Req_WifiScanGetApRecords = 289, + /* + *0x122 + */ + RPC_ID__Req_WifiClearApList = 290, + /* + *0x123 + */ + RPC_ID__Req_WifiRestore = 291, + /* + *0x124 + */ + RPC_ID__Req_WifiClearFastConnect = 292, + /* + *0x125 + */ + RPC_ID__Req_WifiDeauthSta = 293, + /* + *0x126 + */ + RPC_ID__Req_WifiStaGetApInfo = 294, + /* + *Req_WifiSetPs = 295; //0x127 + *Req_WifiGetPs = 296; //0x128 + */ + /* + *0x129 + */ + RPC_ID__Req_WifiSetProtocol = 297, + /* + *0x12a + */ + RPC_ID__Req_WifiGetProtocol = 298, + /* + *0x12b + */ + RPC_ID__Req_WifiSetBandwidth = 299, + /* + *0x12c + */ + RPC_ID__Req_WifiGetBandwidth = 300, + /* + *0x12d + */ + RPC_ID__Req_WifiSetChannel = 301, + /* + *0x12e + */ + RPC_ID__Req_WifiGetChannel = 302, + /* + *0x12f + */ + RPC_ID__Req_WifiSetCountry = 303, + /* + *0x130 + */ + RPC_ID__Req_WifiGetCountry = 304, + /* + * Req_WifiSetPromiscuousRxCb = 305; //0x131 + */ + /* + *0x131 + */ + RPC_ID__Req_WifiSetPromiscuous = 305, + /* + *0x132 + */ + RPC_ID__Req_WifiGetPromiscuous = 306, + /* + *0x133 + */ + RPC_ID__Req_WifiSetPromiscuousFilter = 307, + /* + *0x134 + */ + RPC_ID__Req_WifiGetPromiscuousFilter = 308, + /* + *0x135 + */ + RPC_ID__Req_WifiSetPromiscuousCtrlFilter = 309, + /* + *0x136 + */ + RPC_ID__Req_WifiGetPromiscuousCtrlFilter = 310, + /* + *0x137 + */ + RPC_ID__Req_WifiApGetStaList = 311, + /* + *0x138 + */ + RPC_ID__Req_WifiApGetStaAid = 312, + /* + *0x139 + */ + RPC_ID__Req_WifiSetStorage = 313, + /* + *0x13a + */ + RPC_ID__Req_WifiSetVendorIe = 314, + /* + * Req_WifiSetVendorIeCb = 315; //0x13b + */ + /* + *0x13b + */ + RPC_ID__Req_WifiSetEventMask = 315, + /* + *0x13c + */ + RPC_ID__Req_WifiGetEventMask = 316, + /* + *0x13d + */ + RPC_ID__Req_Wifi80211Tx = 317, + /* + * Req_WifiSetCsiRxCb = 318; //0x13e + */ + /* + *0x13e + */ + RPC_ID__Req_WifiSetCsiConfig = 318, + /* + *0x13f + */ + RPC_ID__Req_WifiSetCsi = 319, + /* + *0x140 + */ + RPC_ID__Req_WifiSetAntGpio = 320, + /* + *0x141 + */ + RPC_ID__Req_WifiGetAntGpio = 321, + /* + *0x142 + */ + RPC_ID__Req_WifiSetAnt = 322, + /* + *0x143 + */ + RPC_ID__Req_WifiGetAnt = 323, + /* + *0x144 + */ + RPC_ID__Req_WifiGetTsfTime = 324, + /* + *0x145 + */ + RPC_ID__Req_WifiSetInactiveTime = 325, + /* + *0x146 + */ + RPC_ID__Req_WifiGetInactiveTime = 326, + /* + *0x147 + */ + RPC_ID__Req_WifiStatisDump = 327, + /* + *0x148 + */ + RPC_ID__Req_WifiSetRssiThreshold = 328, + /* + *0x149 + */ + RPC_ID__Req_WifiFtmInitiateSession = 329, + /* + *0x14a + */ + RPC_ID__Req_WifiFtmEndSession = 330, + /* + *0x14b + */ + RPC_ID__Req_WifiFtmRespSetOffset = 331, + /* + *0x14c + */ + RPC_ID__Req_WifiConfig11bRate = 332, + /* + *0x14d + */ + RPC_ID__Req_WifiConnectionlessModuleSetWakeInterval = 333, + /* + *0x14e + */ + RPC_ID__Req_WifiSetCountryCode = 334, + /* + *0x14f + */ + RPC_ID__Req_WifiGetCountryCode = 335, + /* + *0x150 + */ + RPC_ID__Req_WifiConfig80211TxRate = 336, + /* + *0x151 + */ + RPC_ID__Req_WifiDisablePmfConfig = 337, + /* + *0x152 + */ + RPC_ID__Req_WifiStaGetAid = 338, + /* + *0x153 + */ + RPC_ID__Req_WifiStaGetNegotiatedPhymode = 339, + /* + *0x154 + */ + RPC_ID__Req_WifiSetDynamicCs = 340, + /* + *0x155 + */ + RPC_ID__Req_WifiStaGetRssi = 341, + /* + *0x156 + */ + RPC_ID__Req_WifiSetProtocols = 342, + /* + *0x157 + */ + RPC_ID__Req_WifiGetProtocols = 343, + /* + *0x158 + */ + RPC_ID__Req_WifiSetBandwidths = 344, + /* + *0x159 + */ + RPC_ID__Req_WifiGetBandwidths = 345, + /* + *0x15a + */ + RPC_ID__Req_WifiSetBand = 346, + /* + *0x15b + */ + RPC_ID__Req_WifiGetBand = 347, + /* + *0x15c + */ + RPC_ID__Req_WifiSetBandMode = 348, + /* + *0x15d + */ + RPC_ID__Req_WifiGetBandMode = 349, + /* + *0x15e + */ + RPC_ID__Req_GetCoprocessorFwVersion = 350, + /* + *0x15f + */ + RPC_ID__Req_WifiScanGetApRecord = 351, + /* + * Add new control path command response before Req_Max + * and update Req_Max + */ + /* + *0x160 + */ + RPC_ID__Req_Max = 352, + /* + ** Response Msgs * + */ + RPC_ID__Resp_Base = 512, + RPC_ID__Resp_GetMACAddress = 513, + RPC_ID__Resp_SetMacAddress = 514, + RPC_ID__Resp_GetWifiMode = 515, + RPC_ID__Resp_SetWifiMode = 516, + RPC_ID__Resp_WifiSetPs = 526, + RPC_ID__Resp_WifiGetPs = 527, + RPC_ID__Resp_OTABegin = 528, + RPC_ID__Resp_OTAWrite = 529, + RPC_ID__Resp_OTAEnd = 530, + RPC_ID__Resp_WifiSetMaxTxPower = 531, + RPC_ID__Resp_WifiGetMaxTxPower = 532, + RPC_ID__Resp_ConfigHeartbeat = 533, + RPC_ID__Resp_WifiInit = 534, + RPC_ID__Resp_WifiDeinit = 535, + RPC_ID__Resp_WifiStart = 536, + RPC_ID__Resp_WifiStop = 537, + RPC_ID__Resp_WifiConnect = 538, + RPC_ID__Resp_WifiDisconnect = 539, + RPC_ID__Resp_WifiSetConfig = 540, + RPC_ID__Resp_WifiGetConfig = 541, + RPC_ID__Resp_WifiScanStart = 542, + RPC_ID__Resp_WifiScanStop = 543, + RPC_ID__Resp_WifiScanGetApNum = 544, + RPC_ID__Resp_WifiScanGetApRecords = 545, + RPC_ID__Resp_WifiClearApList = 546, + RPC_ID__Resp_WifiRestore = 547, + RPC_ID__Resp_WifiClearFastConnect = 548, + RPC_ID__Resp_WifiDeauthSta = 549, + RPC_ID__Resp_WifiStaGetApInfo = 550, + /* + *Resp_WifiSetPs = 551; + *Resp_WifiGetPs = 552; + */ + RPC_ID__Resp_WifiSetProtocol = 553, + RPC_ID__Resp_WifiGetProtocol = 554, + RPC_ID__Resp_WifiSetBandwidth = 555, + RPC_ID__Resp_WifiGetBandwidth = 556, + RPC_ID__Resp_WifiSetChannel = 557, + RPC_ID__Resp_WifiGetChannel = 558, + RPC_ID__Resp_WifiSetCountry = 559, + RPC_ID__Resp_WifiGetCountry = 560, + /* + * Resp_WifiSetPromiscuousRxCb = 561; + */ + RPC_ID__Resp_WifiSetPromiscuous = 561, + RPC_ID__Resp_WifiGetPromiscuous = 562, + RPC_ID__Resp_WifiSetPromiscuousFilter = 563, + RPC_ID__Resp_WifiGetPromiscuousFilter = 564, + RPC_ID__Resp_WifiSetPromiscuousCtrlFilter = 565, + RPC_ID__Resp_WifiGetPromiscuousCtrlFilter = 566, + RPC_ID__Resp_WifiApGetStaList = 567, + RPC_ID__Resp_WifiApGetStaAid = 568, + RPC_ID__Resp_WifiSetStorage = 569, + RPC_ID__Resp_WifiSetVendorIe = 570, + /* + * Resp_WifiSetVendorIeCb = 571; + */ + RPC_ID__Resp_WifiSetEventMask = 571, + RPC_ID__Resp_WifiGetEventMask = 572, + RPC_ID__Resp_Wifi80211Tx = 573, + /* + * Resp_WifiSetCsiRxCb = 573; + */ + RPC_ID__Resp_WifiSetCsiConfig = 574, + RPC_ID__Resp_WifiSetCsi = 575, + RPC_ID__Resp_WifiSetAntGpio = 576, + RPC_ID__Resp_WifiGetAntGpio = 577, + RPC_ID__Resp_WifiSetAnt = 578, + RPC_ID__Resp_WifiGetAnt = 579, + RPC_ID__Resp_WifiGetTsfTime = 580, + RPC_ID__Resp_WifiSetInactiveTime = 581, + RPC_ID__Resp_WifiGetInactiveTime = 582, + RPC_ID__Resp_WifiStatisDump = 583, + RPC_ID__Resp_WifiSetRssiThreshold = 584, + RPC_ID__Resp_WifiFtmInitiateSession = 585, + RPC_ID__Resp_WifiFtmEndSession = 586, + RPC_ID__Resp_WifiFtmRespSetOffset = 587, + RPC_ID__Resp_WifiConfig11bRate = 588, + RPC_ID__Resp_WifiConnectionlessModuleSetWakeInterval = 589, + RPC_ID__Resp_WifiSetCountryCode = 590, + RPC_ID__Resp_WifiGetCountryCode = 591, + RPC_ID__Resp_WifiConfig80211TxRate = 592, + RPC_ID__Resp_WifiDisablePmfConfig = 593, + RPC_ID__Resp_WifiStaGetAid = 594, + RPC_ID__Resp_WifiStaGetNegotiatedPhymode = 595, + RPC_ID__Resp_WifiSetDynamicCs = 596, + RPC_ID__Resp_WifiStaGetRssi = 597, + RPC_ID__Resp_WifiSetProtocols = 598, + RPC_ID__Resp_WifiGetProtocols = 599, + RPC_ID__Resp_WifiSetBandwidths = 600, + RPC_ID__Resp_WifiGetBandwidths = 601, + RPC_ID__Resp_WifiSetBand = 602, + RPC_ID__Resp_WifiGetBand = 603, + RPC_ID__Resp_WifiSetBandMode = 604, + RPC_ID__Resp_WifiGetBandMode = 605, + RPC_ID__Resp_GetCoprocessorFwVersion = 606, + RPC_ID__Resp_WifiScanGetApRecord = 607, + /* + * Add new control path command response before Resp_Max + * and update Resp_Max + */ + RPC_ID__Resp_Max = 608, + /* + ** Event Msgs * + */ + RPC_ID__Event_Base = 768, + RPC_ID__Event_ESPInit = 769, + RPC_ID__Event_Heartbeat = 770, + RPC_ID__Event_AP_StaConnected = 771, + RPC_ID__Event_AP_StaDisconnected = 772, + RPC_ID__Event_WifiEventNoArgs = 773, + RPC_ID__Event_StaScanDone = 774, + RPC_ID__Event_StaConnected = 775, + RPC_ID__Event_StaDisconnected = 776, + /* + * Add new control path command notification before Event_Max + * and update Event_Max + */ + RPC_ID__Event_Max = 777 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_ID) +} RpcId; + +/* --- messages --- */ + +struct WifiInitConfig +{ + ProtobufCMessage base; + /* + **< WiFi static RX buffer number + */ + int32_t static_rx_buf_num; + /* + **< WiFi dynamic RX buffer number + */ + int32_t dynamic_rx_buf_num; + /* + **< WiFi TX buffer type + */ + int32_t tx_buf_type; + /* + **< WiFi static TX buffer number + */ + int32_t static_tx_buf_num; + /* + **< WiFi dynamic TX buffer number + */ + int32_t dynamic_tx_buf_num; + /* + **< WiFi TX cache buffer number + */ + int32_t cache_tx_buf_num; + /* + **< WiFi channel state information enable flag + */ + int32_t csi_enable; + /* + **< WiFi AMPDU RX feature enable flag + */ + int32_t ampdu_rx_enable; + /* + **< WiFi AMPDU TX feature enable flag + */ + int32_t ampdu_tx_enable; + /* + **< WiFi AMSDU TX feature enable flag + */ + int32_t amsdu_tx_enable; + /* + **< WiFi NVS flash enable flag + */ + int32_t nvs_enable; + /* + **< Nano option for printf/scan family enable flag + */ + int32_t nano_enable; + /* + **< WiFi Block Ack RX window size + */ + int32_t rx_ba_win; + /* + **< WiFi Task Core ID + */ + int32_t wifi_task_core_id; + /* + **< WiFi softAP maximum length of the beacon + */ + int32_t beacon_max_len; + /* + **< WiFi management short buffer number, the minimum value is 6, the maximum value is 32 + */ + int32_t mgmt_sbuf_num; + /* + **< Enables additional WiFi features and capabilities + */ + uint64_t feature_caps; + /* + **< WiFi Power Management for station at disconnected status + */ + protobuf_c_boolean sta_disconnected_pm; + /* + **< Maximum encrypt number of peers supported by espnow + */ + int32_t espnow_max_encrypt_num; + /* + **< WiFi init magic number, it should be the last field + */ + int32_t magic; +}; +#define WIFI_INIT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_init_config__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiCountry +{ + ProtobufCMessage base; + /* + **< country code string of 3 chars + */ + ProtobufCBinaryData cc; + /* + **< start channel + */ + uint32_t schan; + /* + **< total channel number + */ + uint32_t nchan; + /* + **< This field is used for getting WiFi maximum transmitting power, + *call esp_wifi_set_max_tx_power to set the maximum transmitting power. + */ + int32_t max_tx_power; + /* + **< country policy + */ + int32_t policy; +}; +#define WIFI_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_country__descriptor) \ + , {0,NULL}, 0, 0, 0, 0 } + + +struct WifiActiveScanTime +{ + ProtobufCMessage base; + /* + **< minimum active scan time per channel, units: millisecond + */ + uint32_t min; + /* + **< maximum active scan time per channel, units: millisecond, values above 1500ms may + *cause station to disconnect from AP and are not recommended. + */ + uint32_t max; +}; +#define WIFI_ACTIVE_SCAN_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_active_scan_time__descriptor) \ + , 0, 0 } + + +struct WifiScanTime +{ + ProtobufCMessage base; + /* + **< active scan time per channel, units: millisecond. + */ + WifiActiveScanTime *active; + /* + **< passive scan time per channel, units: millisecond, values above 1500ms may + *cause station to disconnect from AP and are not recommended. + */ + uint32_t passive; +}; +#define WIFI_SCAN_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_time__descriptor) \ + , NULL, 0 } + + +struct WifiScanConfig +{ + ProtobufCMessage base; + /* + **< SSID of AP 33char + */ + ProtobufCBinaryData ssid; + /* + **< MAC address of AP 6char + */ + ProtobufCBinaryData bssid; + /* + **< channel, scan the specific channel + */ + uint32_t channel; + /* + **< enable to scan AP whose SSID is hidden + */ + protobuf_c_boolean show_hidden; + /* + **< scan type, active or passive + */ + int32_t scan_type; + /* + **< scan time per channel + */ + WifiScanTime *scan_time; + /* + **< time spent at home channel between scanning consecutive channels. + */ + uint32_t home_chan_dwell_time; +}; +#define WIFI_SCAN_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_config__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, 0, NULL, 0 } + + +struct WifiHeApInfo +{ + ProtobufCMessage base; + /* + *uint8_t bss_color:6; **< an unsigned integer whose value is the BSS Color of the BSS corresponding to the AP * + *uint8_t partial_bss_color:1; **< indicate if an AID assignment rule based on the BSS color * + *uint8_t bss_color_disabled:1; **< indicate if the use of BSS color is disabled * + */ + /* + * Manually have to parse for above bits + */ + uint32_t bitmask; + /* + **< in M-BSSID set, identifies the nontransmitted BSSID + */ + uint32_t bssid_index; +}; +#define WIFI_HE_AP_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_he_ap_info__descriptor) \ + , 0, 0 } + + +struct WifiApRecord +{ + ProtobufCMessage base; + /* + **< MAC address of AP 6char + */ + ProtobufCBinaryData bssid; + /* + **< SSID of AP 33char + */ + ProtobufCBinaryData ssid; + /* + **< channel of AP + */ + uint32_t primary; + /* + **< secondary channel of AP + */ + int32_t second; + /* + **< signal strength of AP + */ + int32_t rssi; + /* + **< authmode of AP + */ + int32_t authmode; + /* + **< pairwise cipher of AP + */ + int32_t pairwise_cipher; + /* + **< group cipher of AP + */ + int32_t group_cipher; + /* + **< antenna used to receive beacon from AP + */ + int32_t ant; + /* + *uint32_t phy_11b:1; **< bit: 0 flag to identify if 11b mode is enabled or not * + *uint32_t phy_11g:1; **< bit: 1 flag to identify if 11g mode is enabled or not * + *uint32_t phy_11n:1; **< bit: 2 flag to identify if 11n mode is enabled or not * + *uint32_t phy_lr:1; **< bit: 3 flag to identify if low rate is enabled or not * + *uint32_t wps:1; **< bit: 4 flag to identify if WPS is supported or not * + *uint32_t ftm_responder:1; **< bit: 5 flag to identify if FTM is supported in responder mode * + *uint32_t ftm_initiator:1; **< bit: 6 flag to identify if FTM is supported in initiator mode * + *uint32_t reserved:25; **< bit: 7..31 reserved * + */ + /* + * Manually have to parse for above bits + */ + uint32_t bitmask; + /* + **< country information of AP + */ + WifiCountry *country; + WifiHeApInfo *he_ap; + /* + **< For AP 20 MHz this value is set to 1. For AP 40 MHz this value is set to 2. + *For AP 80 MHz this value is set to 3. For AP 160MHz this value is set to 4. + *For AP 80+80MHz this value is set to 5 + */ + uint32_t bandwidth; + /* + **< This fields are used only AP bandwidth is 80 and 160 MHz, to transmit the center channel + *frequency of the BSS. For AP bandwidth is 80 + 80 MHz, it is the center channel frequency + *of the lower frequency segment. + */ + uint32_t vht_ch_freq1; + /* + **< This fields are used only AP bandwidth is 80 + 80 MHz, and is used to transmit the center + *channel frequency of the second segment. + */ + uint32_t vht_ch_freq2; +}; +#define WIFI_AP_RECORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ap_record__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, 0, 0, 0 } + + +struct WifiScanThreshold +{ + ProtobufCMessage base; + /* + **< The minimum rssi to accept in the fast scan mode + */ + int32_t rssi; + /* + **< The weakest authmode to accept in the fast scan mode + *Note: Incase this value is not set and password is set as per WPA2 standards(password len >= 8), + *it will be defaulted to WPA2 and device won't connect to deprecated WEP/WPA networks. + *Please set authmode threshold as WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK to connect to WEP/WPA networks + */ + int32_t authmode; +}; +#define WIFI_SCAN_THRESHOLD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_threshold__descriptor) \ + , 0, 0 } + + +struct WifiPmfConfig +{ + ProtobufCMessage base; + /* + **< Deprecated variable. Device will always connect in PMF mode if other device also advertizes PMF capability. + */ + protobuf_c_boolean capable; + /* + **< Advertizes that Protected Management Frame is required. Device will not associate to non-PMF capable devices. + */ + protobuf_c_boolean required; +}; +#define WIFI_PMF_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_pmf_config__descriptor) \ + , 0, 0 } + + +struct WifiApConfig +{ + ProtobufCMessage base; + /* + **< SSID of ESP32 soft-AP. If ssid_len field is 0, this must be a Null terminated string. Otherwise, length is set according to ssid_len. 32 char + */ + ProtobufCBinaryData ssid; + /* + **< Password of ESP32 soft-AP. 64 char + */ + ProtobufCBinaryData password; + /* + **< Optional length of SSID field. + */ + uint32_t ssid_len; + /* + **< Channel of ESP32 soft-AP + */ + uint32_t channel; + /* + **< Auth mode of ESP32 soft-AP. Do not support AUTH_WEP in soft-AP mode + */ + int32_t authmode; + /* + **< Broadcast SSID or not, default 0, broadcast the SSID + */ + uint32_t ssid_hidden; + /* + **< Max number of stations allowed to connect in + */ + uint32_t max_connection; + /* + **< Beacon interval which should be multiples of 100. Unit: TU(time unit, 1 TU = 1024 us). Range: 100 ~ 60000. Default value: 100 + */ + uint32_t beacon_interval; + /* + **< pairwise cipher of SoftAP, group cipher will be derived using this. + *cipher values are valid starting from WIFI_CIPHER_TYPE_TKIP, enum values before that will be considered as invalid and default cipher suites(TKIP+CCMP) will be used. + *Valid cipher suites in softAP mode are WIFI_CIPHER_TYPE_TKIP, WIFI_CIPHER_TYPE_CCMP and WIFI_CIPHER_TYPE_TKIP_CCMP. + */ + int32_t pairwise_cipher; + /* + **< Enable FTM Responder mode + */ + protobuf_c_boolean ftm_responder; + /* + **< Configuration for Protected Management Frame + */ + WifiPmfConfig *pmf_cfg; + /* + **< Configuration for SAE PWE derivation method + */ + int32_t sae_pwe_h2e; +}; +#define WIFI_AP_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ap_config__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0 } + + +struct WifiStaConfig +{ + ProtobufCMessage base; + /* + **< SSID of target AP. 32char + */ + ProtobufCBinaryData ssid; + /* + **< Password of target AP. 64char + */ + ProtobufCBinaryData password; + /* + **< do all channel scan or fast scan + */ + int32_t scan_method; + /* + **< whether set MAC address of target AP or not. Generally, station_config.bssid_set needs to be 0, + *and it needs to be 1 only when users need to check the MAC address of the AP. + */ + protobuf_c_boolean bssid_set; + /* + **< MAC address of target AP 6char + */ + ProtobufCBinaryData bssid; + /* + **< channel of target AP. Set to 1~13 to scan starting from the specified channel + *before connecting to AP. If the channel of AP is unknown, set it to 0. + */ + uint32_t channel; + /* + **< Listen interval for ESP32 station to receive beacon when WIFI_PS_MAX_MODEM is set. + *Units: AP beacon intervals. Defaults to 3 if set to 0. + */ + uint32_t listen_interval; + /* + **< sort the connect AP in the list by rssi or security mode + */ + int32_t sort_method; + /* + **< When sort_method is set, only APs which have an auth mode that is more secure + *than the selected auth mode and a signal stronger than the minimum RSSI will be used. + */ + WifiScanThreshold *threshold; + /* + **< Configuration for Protected Management Frame. Will be advertized in RSN Capabilities in RSN IE. + */ + WifiPmfConfig *pmf_cfg; + /* + *uint32_t rm_enabled:1; **< Whether Radio Measurements are enabled for the connection * + *uint32_t btm_enabled:1; **< Whether BSS Transition Management is enabled for the connection * + *uint32_t mbo_enabled:1; **< Whether MBO is enabled for the connection * + *uint32_t ft_enabled:1; **< Whether FT is enabled for the connection * + *uint32_t owe_enabled:1; **< Whether OWE is enabled for the connection * + *uint32_t transition_disable:1; **< Whether to enable transition disable feature * + *uint32_t reserved:26; **< Reserved for future feature set * + */ + uint32_t bitmask; + /* + **< Whether SAE hash to element is enabled + */ + int32_t sae_pwe_h2e; + /* + **< Number of connection retries station will do before moving to next AP. + *scan_method should be set as WIFI_ALL_CHANNEL_SCAN to use this config. + *Note: Enabling this may cause connection time to increase incase best AP doesn't behave properly. + */ + uint32_t failure_retry_cnt; + /* + *uint32_t he_dcm_set:1; **< Whether DCM max.constellation for transmission and reception is set. * + *uint32_t he_dcm_max_constellation_tx:2; **< Indicate the max.constellation for DCM in TB PPDU the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. * + *uint32_t he_dcm_max_constellation_rx:2; **< Indicate the max.constellation for DCM in both Data field and HE-SIG-B field the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. * + *uint32_t he_mcs9_enabled:1; **< Whether to support HE-MCS 0 to 9. The default value is 0. * + *uint32_t he_su_beamformee_disabled:1; **< Whether to disable support for operation as an SU beamformee. * + *uint32_t he_trig_su_bmforming_feedback_disabled:1; **< Whether to disable support the transmission of SU feedback in an HE TB sounding sequence. * + *uint32_t he_trig_mu_bmforming_partial_feedback_disabled:1; **< Whether to disable support the transmission of partial-bandwidth MU feedback in an HE TB sounding sequence. * + * uint32_t he_trig_cqi_feedback_disabled:1; **< Whether to disable support the transmission of CQI feedback in an HE TB sounding sequence. * + * uint32_t he_reserved:22; **< Reserved for future feature set * + */ + uint32_t he_bitmask; + /* + **< Password identifier for H2E. this needs to be null terminated string. SAE_H2E_IDENTIFIER_LEN chars + */ + ProtobufCBinaryData sae_h2e_identifier; +}; +#define WIFI_STA_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_config__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, {0,NULL}, 0, 0, 0, NULL, NULL, 0, 0, 0, 0, {0,NULL} } + + +typedef enum { + WIFI_CONFIG__U__NOT_SET = 0, + WIFI_CONFIG__U_AP = 1, + WIFI_CONFIG__U_STA = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(WIFI_CONFIG__U__CASE) +} WifiConfig__UCase; + +struct WifiConfig +{ + ProtobufCMessage base; + WifiConfig__UCase u_case; + union { + /* + **< configuration of AP + */ + WifiApConfig *ap; + /* + **< configuration of STA + */ + WifiStaConfig *sta; + }; +}; +#define WIFI_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_config__descriptor) \ + , WIFI_CONFIG__U__NOT_SET, {0} } + + +struct WifiStaInfo +{ + ProtobufCMessage base; + /* + **< mac address 6 char + */ + ProtobufCBinaryData mac; + /* + **< current average rssi of sta connected + */ + int32_t rssi; + /* + *uint32_t phy_11b:1; **< bit: 0 flag to identify if 11b mode is enabled or not * + *uint32_t phy_11g:1; **< bit: 1 flag to identify if 11g mode is enabled or not * + *uint32_t phy_11n:1; **< bit: 2 flag to identify if 11n mode is enabled or not * + *uint32_t phy_lr:1; **< bit: 3 flag to identify if low rate is enabled or not * + *uint32_t phy_11x:1; **< bit: 4 flag to identify identify if 11ax mode is enabled or not * + *uint32_t is_mesh_child:1; **< bit: 5 flag to identify mesh child * + *uint32_t reserved:26; **< bit: 6..31 reserved * + */ + uint32_t bitmask; +}; +#define WIFI_STA_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_info__descriptor) \ + , {0,NULL}, 0, 0 } + + +struct WifiStaList +{ + ProtobufCMessage base; + /* + **< station list + */ + size_t n_sta; + WifiStaInfo **sta; + /* + **< number of stations in the list (other entries are invalid) + */ + int32_t num; +}; +#define WIFI_STA_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_list__descriptor) \ + , 0,NULL, 0 } + + +struct WifiPktRxCtrl +{ + ProtobufCMessage base; + /* + **< 8bits Received Signal Strength Indicator(RSSI) of packet. unit: dBm + */ + int32_t rssi; + /* + **< 5bits PHY rate encoding of the packet. Only valid for non HT(11bg) packet + */ + uint32_t rate; + /* + *uint32 :1; **< reserved * + */ + /* + **< 2bits 0: non HT(11bg) packet; 1: HT(11n) packet; 3: VHT(11ac) packet + */ + uint32_t sig_mode; + /* + *uint32 :16; **< reserved * + */ + /* + **< 7bits Modulation Coding Scheme. If is HT(11n) packet, shows the modulation, range from 0 to 76(MSC0 ~ MCS76) + */ + uint32_t mcs; + /* + **< 1bit Channel Bandwidth of the packet. 0: 20MHz; 1: 40MHz + */ + uint32_t cwb; + /* + *uint32 :16; **< reserved * + */ + /* + **< 1bit reserved + */ + uint32_t smoothing; + /* + **< 1bit reserved + */ + uint32_t not_sounding; + /* + *uint32 :1; **< reserved * + */ + /* + **< 1bit Aggregation. 0: MPDU packet; 1: AMPDU packet + */ + uint32_t aggregation; + /* + **< 2bits Space Time Block Code(STBC). 0: non STBC packet; 1: STBC packet + */ + uint32_t stbc; + /* + **< 1bit Flag is set for 11n packets which are LDPC + */ + uint32_t fec_coding; + /* + **< 1bit Short Guide Interval(SGI). 0: Long GI; 1: Short GI + */ + uint32_t sgi; + /* + **< 8bits noise floor of Radio Frequency Module(RF). unit: dBm + */ + int32_t noise_floor; + /* + **< 8bits ampdu cnt + */ + uint32_t ampdu_cnt; + /* + **< 4bits primary channel on which this packet is received + */ + uint32_t channel; + /* + **< 4bits secondary channel on which this packet is received. 0: none; 1: above; 2: below + */ + uint32_t secondary_channel; + /* + *uint32 :8; **< reserved * + */ + /* + **< 32bit timestamp. The local time when this packet is received. It is precise only if modem sleep or light sleep is not enabled. unit: microsecond + */ + uint32_t timestamp; + /* + *uint32 :32; **< reserved * + *unsigned :32; **< reserved * + *unsigned :31; **< reserved * + */ + /* + **< 1bit antenna number from which this packet is received. 0: WiFi antenna 0; 1: WiFi antenna 1 + */ + uint32_t ant; + /* + **< 12bits length of packet including Frame Check Sequence(FCS) + */ + uint32_t sig_len; + /* + *unsigned :12; **< reserved * + */ + /* + **< 8bits state of the packet. 0: no error; others: error numbers which are not public + */ + uint32_t rx_state; +}; +#define WIFI_PKT_RX_CTRL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_pkt_rx_ctrl__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiPromiscuousPkt +{ + ProtobufCMessage base; + /* + **< metadata header + */ + WifiPktRxCtrl *rx_ctrl; + /* + **< Note: variable length. Data or management payload. Length of payload is described by rx_ctrl.sig_len. Type of content determined by packet type argument of callback. + */ + ProtobufCBinaryData payload; +}; +#define WIFI_PROMISCUOUS_PKT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_promiscuous_pkt__descriptor) \ + , NULL, {0,NULL} } + + +struct WifiPromiscuousFilter +{ + ProtobufCMessage base; + /* + **< OR of one or more filter values WIFI_PROMIS_FILTER_* + */ + uint32_t filter_mask; +}; +#define WIFI_PROMISCUOUS_FILTER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_promiscuous_filter__descriptor) \ + , 0 } + + +struct WifiCsiConfig +{ + ProtobufCMessage base; + /* + **< enable to receive legacy long training field(lltf) data. Default enabled + */ + protobuf_c_boolean lltf_en; + /* + **< enable to receive HT long training field(htltf) data. Default enabled + */ + protobuf_c_boolean htltf_en; + /* + **< enable to receive space time block code HT long training field(stbc-htltf2) data. Default enabled + */ + protobuf_c_boolean stbc_htltf2_en; + /* + **< enable to generate htlft data by averaging lltf and ht_ltf data when receiving HT packet. Otherwise, use ht_ltf data directly. Default enabled + */ + protobuf_c_boolean ltf_merge_en; + /* + **< enable to turn on channel filter to smooth adjacent sub-carrier. Disable it to keep independence of adjacent sub-carrier. Default enabled + */ + protobuf_c_boolean channel_filter_en; + /* + **< manually scale the CSI data by left shifting or automatically scale the CSI data. + *If set true, please set the shift bits. false: automatically. true: manually. Default false + */ + protobuf_c_boolean manu_scale; + /* + **< manually left shift bits of the scale of the CSI data. The range of the left shift bits is 0~15 + */ + uint32_t shift; +}; +#define WIFI_CSI_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_csi_config__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiCsiInfo +{ + ProtobufCMessage base; + /* + **< received packet radio metadata header of the CSI data + */ + WifiPktRxCtrl *rx_ctrl; + /* + **< 6bits source MAC address of the CSI data + */ + ProtobufCBinaryData mac; + /* + **< 6bits destination MAC address of the CSI data + */ + ProtobufCBinaryData dmac; + /* + **< first four bytes of the CSI data is invalid or not + */ + protobuf_c_boolean first_word_invalid; + /* + **< Note: variable length. buffer of CSI data + */ + ProtobufCBinaryData buf; + /* + **< length of CSI data + */ + uint32_t len; +}; +#define WIFI_CSI_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_csi_info__descriptor) \ + , NULL, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0 } + + +struct WifiAntGpio +{ + ProtobufCMessage base; + /* + **< 1bit Whether this GPIO is connected to external antenna switch + */ + uint32_t gpio_select; + /* + **< 7bits The GPIO number that connects to external antenna switch + */ + uint32_t gpio_num; +}; +#define WIFI_ANT_GPIO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_gpio__descriptor) \ + , 0, 0 } + + +struct WifiAntGpioConfig +{ + ProtobufCMessage base; + /* + **< The configurations of GPIOs that connect to external antenna switch + */ + size_t n_gpio_cfgs; + WifiAntGpio **gpio_cfgs; +}; +#define WIFI_ANT_GPIO_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_gpio_config__descriptor) \ + , 0,NULL } + + +struct WifiAntConfig +{ + ProtobufCMessage base; + /* + **< WiFi antenna mode for receiving + */ + int32_t rx_ant_mode; + /* + **< Default antenna mode for receiving, it's ignored if rx_ant_mode is not WIFI_ANT_MODE_AUTO + */ + int32_t rx_ant_default; + /* + **< WiFi antenna mode for transmission, it can be set to WIFI_ANT_MODE_AUTO only if rx_ant_mode is set to WIFI_ANT_MODE_AUTO + */ + int32_t tx_ant_mode; + /* + **< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT0 + */ + uint32_t enabled_ant0; + /* + **< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT1 + */ + uint32_t enabled_ant1; +}; +#define WIFI_ANT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_config__descriptor) \ + , 0, 0, 0, 0, 0 } + + +struct WifiActionTxReq +{ + ProtobufCMessage base; + /* + **< WiFi interface to send request to + */ + int32_t ifx; + /* + **< 6bits Destination MAC address + */ + ProtobufCBinaryData dest_mac; + /* + **< Indicates no ack required + */ + protobuf_c_boolean no_ack; + /* + *TODO + *wifi_action_rx_cb_t rx_cb; **< Rx Callback to receive any response * + */ + /* + **< Length of the appended Data + */ + uint32_t data_len; + /* + **< note: variable length. Appended Data payload + */ + ProtobufCBinaryData data; +}; +#define WIFI_ACTION_TX_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_action_tx_req__descriptor) \ + , 0, {0,NULL}, 0, 0, {0,NULL} } + + +struct WifiFtmInitiatorCfg +{ + ProtobufCMessage base; + /* + **< 6bits MAC address of the FTM Responder + */ + ProtobufCBinaryData resp_mac; + /* + **< Primary channel of the FTM Responder + */ + uint32_t channel; + /* + **< No. of FTM frames requested in terms of 4 or 8 bursts (allowed values - 0(No pref), 16, 24, 32, 64) + */ + uint32_t frm_count; + /* + **< Requested time period between consecutive FTM bursts in 100's of milliseconds (0 - No pref) + */ + uint32_t burst_period; +}; +#define WIFI_FTM_INITIATOR_CFG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ftm_initiator_cfg__descriptor) \ + , {0,NULL}, 0, 0, 0 } + + +struct WifiEventStaScanDone +{ + ProtobufCMessage base; + /* + **< status of scanning APs: 0 — success, 1 - failure + */ + uint32_t status; + /* + **< number of scan results + */ + uint32_t number; + /* + **< scan sequence number, used for block scan + */ + uint32_t scan_id; +}; +#define WIFI_EVENT_STA_SCAN_DONE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_scan_done__descriptor) \ + , 0, 0, 0 } + + +struct WifiEventStaConnected +{ + ProtobufCMessage base; + /* + **< 32bytes SSID of connected AP + */ + ProtobufCBinaryData ssid; + /* + **< SSID length of connected AP + */ + uint32_t ssid_len; + /* + **< 6bytes BSSID of connected AP + */ + ProtobufCBinaryData bssid; + /* + **< channel of connected AP + */ + uint32_t channel; + /* + **< authentication mode used by AP + */ + int32_t authmode; + /* + **< authentication id assigned by the connected AP + */ + int32_t aid; +}; +#define WIFI_EVENT_STA_CONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_connected__descriptor) \ + , {0,NULL}, 0, {0,NULL}, 0, 0, 0 } + + +struct WifiEventStaDisconnected +{ + ProtobufCMessage base; + /* + **< SSID of disconnected AP + */ + ProtobufCBinaryData ssid; + /* + **< SSID length of disconnected AP + */ + uint32_t ssid_len; + /* + **< BSSID of disconnected AP + */ + ProtobufCBinaryData bssid; + /* + **< reason of disconnection + */ + uint32_t reason; + /* + **< rssi of disconnection + */ + int32_t rssi; +}; +#define WIFI_EVENT_STA_DISCONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_disconnected__descriptor) \ + , {0,NULL}, 0, {0,NULL}, 0, 0 } + + +struct WifiEventStaAuthmodeChange +{ + ProtobufCMessage base; + /* + **< the old auth mode of AP + */ + int32_t old_mode; + /* + **< the new auth mode of AP + */ + int32_t new_mode; +}; +#define WIFI_EVENT_STA_AUTHMODE_CHANGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_authmode_change__descriptor) \ + , 0, 0 } + + +struct WifiEventStaWpsErPin +{ + ProtobufCMessage base; + /* + **< 8bytes PIN code of station in enrollee mode + */ + ProtobufCBinaryData pin_code; +}; +#define WIFI_EVENT_STA_WPS_ER_PIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_wps_er_pin__descriptor) \ + , {0,NULL} } + + +struct ApCred +{ + ProtobufCMessage base; + /* + **< 32bytes SSID of AP + */ + ProtobufCBinaryData ssid; + /* + **< 64bytes Passphrase for the AP + */ + ProtobufCBinaryData passphrase; +}; +#define AP_CRED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ap_cred__descriptor) \ + , {0,NULL}, {0,NULL} } + + +struct WifiEventStaWpsErSuccess +{ + ProtobufCMessage base; + /* + **< Number of AP credentials received + */ + uint32_t ap_cred_cnt; + /* + **< All AP credentials received from WPS handshake + */ + size_t n_ap_creds; + ApCred **ap_creds; +}; +#define WIFI_EVENT_STA_WPS_ER_SUCCESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_wps_er_success__descriptor) \ + , 0, 0,NULL } + + +/* + ** Argument structure for WIFI_EVENT_AP_PROBEREQRECVED event + */ +struct WifiEventApProbeReqRx +{ + ProtobufCMessage base; + /* + **< Received probe request signal strength + */ + int32_t rssi; + /* + **< MAC address of the station which send probe request + */ + uint32_t mac; +}; +#define WIFI_EVENT_AP_PROBE_REQ_RX__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_probe_req_rx__descriptor) \ + , 0, 0 } + + +/* + ** Argument structure for WIFI_EVENT_STA_BSS_RSSI_LOW event + */ +struct WifiEventBssRssiLow +{ + ProtobufCMessage base; + /* + **< RSSI value of bss + */ + int32_t rssi; +}; +#define WIFI_EVENT_BSS_RSSI_LOW__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_bss_rssi_low__descriptor) \ + , 0 } + + +struct WifiFtmReportEntry +{ + ProtobufCMessage base; + /* + * *< Dialog Token of the FTM frame + */ + uint32_t dlog_token; + /* + * *< RSSI of the FTM frame received + */ + int32_t rssi; + /* + * *< Round Trip Time in pSec with a peer + */ + uint32_t rtt; + /* + * TODO: uint32 is supported by proto? + */ + /* + * *< Time of departure of FTM frame from FTM Responder in pSec + */ + uint64_t t1; + /* + * *< Time of arrival of FTM frame at FTM Initiator in pSec + */ + uint64_t t2; + /* + * *< Time of departure of ACK from FTM Initiator in pSec + */ + uint64_t t3; + /* + * *< Time of arrival of ACK at FTM Responder in pSec + */ + uint64_t t4; +}; +#define WIFI_FTM_REPORT_ENTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ftm_report_entry__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiEventFtmReport +{ + ProtobufCMessage base; + /* + * *< 6bytes MAC address of the FTM Peer + */ + ProtobufCBinaryData peer_mac; + /* + * *< Status of the FTM operation + */ + int32_t status; + /* + * *< Raw average Round-Trip-Time with peer in Nano-Seconds + */ + uint32_t rtt_raw; + /* + * *< Estimated Round-Trip-Time with peer in Nano-Seconds + */ + uint32_t rtt_est; + /* + * *< Estimated one-way distance in Centi-Meters + */ + uint32_t dist_est; + /* + * *< Note var len Pointer to FTM Report with multiple entries, should be freed after use + */ + size_t n_ftm_report_data; + WifiFtmReportEntry **ftm_report_data; + /* + * *< Number of entries in the FTM Report data + */ + uint32_t ftm_report_num_entries; +}; +#define WIFI_EVENT_FTM_REPORT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ftm_report__descriptor) \ + , {0,NULL}, 0, 0, 0, 0, 0,NULL, 0 } + + +struct WifiEventActionTxStatus +{ + ProtobufCMessage base; + /* + **< WiFi interface to send request to + */ + int32_t ifx; + /* + **< Context to identify the request + */ + uint32_t context; + /* + **< 6bytes Destination MAC address + */ + ProtobufCBinaryData da; + /* + **< Status of the operation + */ + uint32_t status; +}; +#define WIFI_EVENT_ACTION_TX_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_action_tx_status__descriptor) \ + , 0, 0, {0,NULL}, 0 } + + +struct WifiEventRocDone +{ + ProtobufCMessage base; + /* + **< Context to identify the request + */ + uint32_t context; +}; +#define WIFI_EVENT_ROC_DONE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_roc_done__descriptor) \ + , 0 } + + +struct WifiEventApWpsRgPin +{ + ProtobufCMessage base; + /* + **< 8bytes PIN code of station in enrollee mode + */ + ProtobufCBinaryData pin_code; +}; +#define WIFI_EVENT_AP_WPS_RG_PIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_pin__descriptor) \ + , {0,NULL} } + + +struct WifiEventApWpsRgFailReason +{ + ProtobufCMessage base; + /* + **< WPS failure reason wps_fail_reason_t + */ + int32_t reason; + /* + **< 6bytes Enrollee mac address + */ + ProtobufCBinaryData peer_macaddr; +}; +#define WIFI_EVENT_AP_WPS_RG_FAIL_REASON__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_fail_reason__descriptor) \ + , 0, {0,NULL} } + + +struct WifiEventApWpsRgSuccess +{ + ProtobufCMessage base; + /* + **< 6bytes Enrollee mac address + */ + ProtobufCBinaryData peer_macaddr; +}; +#define WIFI_EVENT_AP_WPS_RG_SUCCESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_success__descriptor) \ + , {0,NULL} } + + +struct WifiProtocols +{ + ProtobufCMessage base; + /* + **< Represents 2.4 GHz protocol, support 802.11b or 802.11g or 802.11n or 802.11ax or LR mode + */ + uint32_t ghz_2g; + /* + **< Represents 5 GHz protocol, support 802.11a or 802.11n or 802.11ac or 802.11ax + */ + uint32_t ghz_5g; +}; +#define WIFI_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_protocols__descriptor) \ + , 0, 0 } + + +struct WifiBandwidths +{ + ProtobufCMessage base; + /* + * Represents 2.4 GHz bandwidth + */ + uint32_t ghz_2g; + /* + * Represents 5 GHz bandwidth + */ + uint32_t ghz_5g; +}; +#define WIFI_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_bandwidths__descriptor) \ + , 0, 0 } + + +struct ConnectedSTAList +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; + int32_t rssi; +}; +#define CONNECTED_STALIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&connected_stalist__descriptor) \ + , {0,NULL}, 0 } + + +/* + ** Req/Resp structure * + */ +struct RpcReqGetMacAddress +{ + ProtobufCMessage base; + int32_t mode; +}; +#define RPC__REQ__GET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_mac_address__descriptor) \ + , 0 } + + +struct RpcRespGetMacAddress +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; + int32_t resp; +}; +#define RPC__RESP__GET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_mac_address__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcReqGetMode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__GET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_mode__descriptor) \ + } + + +struct RpcRespGetMode +{ + ProtobufCMessage base; + int32_t mode; + int32_t resp; +}; +#define RPC__RESP__GET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_mode__descriptor) \ + , 0, 0 } + + +struct RpcReqSetMode +{ + ProtobufCMessage base; + int32_t mode; +}; +#define RPC__REQ__SET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_mode__descriptor) \ + , 0 } + + +struct RpcRespSetMode +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_mode__descriptor) \ + , 0 } + + +struct RpcReqGetPs +{ + ProtobufCMessage base; +}; +#define RPC__REQ__GET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_ps__descriptor) \ + } + + +struct RpcRespGetPs +{ + ProtobufCMessage base; + int32_t resp; + int32_t type; +}; +#define RPC__RESP__GET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_ps__descriptor) \ + , 0, 0 } + + +struct RpcReqSetPs +{ + ProtobufCMessage base; + int32_t type; +}; +#define RPC__REQ__SET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_ps__descriptor) \ + , 0 } + + +struct RpcRespSetPs +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_ps__descriptor) \ + , 0 } + + +struct RpcReqSetMacAddress +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; + int32_t mode; +}; +#define RPC__REQ__SET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_mac_address__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespSetMacAddress +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_mac_address__descriptor) \ + , 0 } + + +struct RpcReqOTABegin +{ + ProtobufCMessage base; +}; +#define RPC__REQ__OTABEGIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otabegin__descriptor) \ + } + + +struct RpcRespOTABegin +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__OTABEGIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otabegin__descriptor) \ + , 0 } + + +struct RpcReqOTAWrite +{ + ProtobufCMessage base; + ProtobufCBinaryData ota_data; +}; +#define RPC__REQ__OTAWRITE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otawrite__descriptor) \ + , {0,NULL} } + + +struct RpcRespOTAWrite +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__OTAWRITE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otawrite__descriptor) \ + , 0 } + + +struct RpcReqOTAEnd +{ + ProtobufCMessage base; +}; +#define RPC__REQ__OTAEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otaend__descriptor) \ + } + + +struct RpcRespOTAEnd +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__OTAEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otaend__descriptor) \ + , 0 } + + +struct RpcReqWifiSetMaxTxPower +{ + ProtobufCMessage base; + int32_t power; +}; +#define RPC__REQ__WIFI_SET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_max_tx_power__descriptor) \ + , 0 } + + +struct RpcRespWifiSetMaxTxPower +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_max_tx_power__descriptor) \ + , 0 } + + +struct RpcReqWifiGetMaxTxPower +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_max_tx_power__descriptor) \ + } + + +struct RpcRespWifiGetMaxTxPower +{ + ProtobufCMessage base; + int32_t power; + int32_t resp; +}; +#define RPC__RESP__WIFI_GET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_max_tx_power__descriptor) \ + , 0, 0 } + + +struct RpcReqConfigHeartbeat +{ + ProtobufCMessage base; + protobuf_c_boolean enable; + int32_t duration; +}; +#define RPC__REQ__CONFIG_HEARTBEAT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__config_heartbeat__descriptor) \ + , 0, 0 } + + +struct RpcRespConfigHeartbeat +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__CONFIG_HEARTBEAT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__config_heartbeat__descriptor) \ + , 0 } + + +struct RpcReqWifiInit +{ + ProtobufCMessage base; + WifiInitConfig *cfg; +}; +#define RPC__REQ__WIFI_INIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_init__descriptor) \ + , NULL } + + +struct RpcRespWifiInit +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_INIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_init__descriptor) \ + , 0 } + + +struct RpcReqWifiDeinit +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_DEINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_deinit__descriptor) \ + } + + +struct RpcRespWifiDeinit +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_DEINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_deinit__descriptor) \ + , 0 } + + +struct RpcReqWifiSetConfig +{ + ProtobufCMessage base; + int32_t iface; + WifiConfig *cfg; +}; +#define RPC__REQ__WIFI_SET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_config__descriptor) \ + , 0, NULL } + + +struct RpcRespWifiSetConfig +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_config__descriptor) \ + , 0 } + + +struct RpcReqWifiGetConfig +{ + ProtobufCMessage base; + int32_t iface; +}; +#define RPC__REQ__WIFI_GET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_config__descriptor) \ + , 0 } + + +struct RpcRespWifiGetConfig +{ + ProtobufCMessage base; + int32_t resp; + int32_t iface; + WifiConfig *cfg; +}; +#define RPC__RESP__WIFI_GET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_config__descriptor) \ + , 0, 0, NULL } + + +struct RpcReqWifiConnect +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_connect__descriptor) \ + } + + +struct RpcRespWifiConnect +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_connect__descriptor) \ + , 0 } + + +struct RpcReqWifiDisconnect +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_DISCONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_disconnect__descriptor) \ + } + + +struct RpcRespWifiDisconnect +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_DISCONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_disconnect__descriptor) \ + , 0 } + + +struct RpcReqWifiStart +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_start__descriptor) \ + } + + +struct RpcRespWifiStart +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_start__descriptor) \ + , 0 } + + +struct RpcReqWifiStop +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_stop__descriptor) \ + } + + +struct RpcRespWifiStop +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_stop__descriptor) \ + , 0 } + + +struct RpcReqWifiScanStart +{ + ProtobufCMessage base; + WifiScanConfig *config; + protobuf_c_boolean block; + int32_t config_set; +}; +#define RPC__REQ__WIFI_SCAN_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_start__descriptor) \ + , NULL, 0, 0 } + + +struct RpcRespWifiScanStart +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SCAN_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_start__descriptor) \ + , 0 } + + +struct RpcReqWifiScanStop +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_SCAN_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_stop__descriptor) \ + } + + +struct RpcRespWifiScanStop +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SCAN_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_stop__descriptor) \ + , 0 } + + +struct RpcReqWifiScanGetApNum +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_SCAN_GET_AP_NUM__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_num__descriptor) \ + } + + +struct RpcRespWifiScanGetApNum +{ + ProtobufCMessage base; + int32_t resp; + int32_t number; +}; +#define RPC__RESP__WIFI_SCAN_GET_AP_NUM__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_num__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiScanGetApRecords +{ + ProtobufCMessage base; + int32_t number; +}; +#define RPC__REQ__WIFI_SCAN_GET_AP_RECORDS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_records__descriptor) \ + , 0 } + + +struct RpcRespWifiScanGetApRecords +{ + ProtobufCMessage base; + int32_t resp; + int32_t number; + size_t n_ap_records; + WifiApRecord **ap_records; +}; +#define RPC__RESP__WIFI_SCAN_GET_AP_RECORDS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_records__descriptor) \ + , 0, 0, 0,NULL } + + +struct RpcReqWifiScanGetApRecord +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_SCAN_GET_AP_RECORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_record__descriptor) \ + } + + +struct RpcRespWifiScanGetApRecord +{ + ProtobufCMessage base; + int32_t resp; + WifiApRecord *ap_record; +}; +#define RPC__RESP__WIFI_SCAN_GET_AP_RECORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_record__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiClearApList +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_CLEAR_AP_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_clear_ap_list__descriptor) \ + } + + +struct RpcRespWifiClearApList +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_CLEAR_AP_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_clear_ap_list__descriptor) \ + , 0 } + + +struct RpcReqWifiRestore +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_RESTORE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_restore__descriptor) \ + } + + +struct RpcRespWifiRestore +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_RESTORE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_restore__descriptor) \ + , 0 } + + +struct RpcReqWifiClearFastConnect +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_CLEAR_FAST_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_clear_fast_connect__descriptor) \ + } + + +struct RpcRespWifiClearFastConnect +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_CLEAR_FAST_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_clear_fast_connect__descriptor) \ + , 0 } + + +struct RpcReqWifiDeauthSta +{ + ProtobufCMessage base; + int32_t aid; +}; +#define RPC__REQ__WIFI_DEAUTH_STA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_deauth_sta__descriptor) \ + , 0 } + + +struct RpcRespWifiDeauthSta +{ + ProtobufCMessage base; + int32_t resp; + int32_t aid; +}; +#define RPC__RESP__WIFI_DEAUTH_STA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_deauth_sta__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaGetApInfo +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_AP_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_ap_info__descriptor) \ + } + + +struct RpcRespWifiStaGetApInfo +{ + ProtobufCMessage base; + int32_t resp; + WifiApRecord *ap_record; +}; +#define RPC__RESP__WIFI_STA_GET_AP_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_ap_info__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiSetProtocol +{ + ProtobufCMessage base; + int32_t ifx; + int32_t protocol_bitmap; +}; +#define RPC__REQ__WIFI_SET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_protocol__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetProtocol +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_protocol__descriptor) \ + , 0 } + + +struct RpcReqWifiGetProtocol +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_protocol__descriptor) \ + , 0 } + + +struct RpcRespWifiGetProtocol +{ + ProtobufCMessage base; + int32_t resp; + int32_t protocol_bitmap; +}; +#define RPC__RESP__WIFI_GET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_protocol__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetBandwidth +{ + ProtobufCMessage base; + int32_t ifx; + int32_t bw; +}; +#define RPC__REQ__WIFI_SET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_bandwidth__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetBandwidth +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_bandwidth__descriptor) \ + , 0 } + + +struct RpcReqWifiGetBandwidth +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_bandwidth__descriptor) \ + , 0 } + + +struct RpcRespWifiGetBandwidth +{ + ProtobufCMessage base; + int32_t resp; + int32_t bw; +}; +#define RPC__RESP__WIFI_GET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_bandwidth__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetChannel +{ + ProtobufCMessage base; + int32_t primary; + int32_t second; +}; +#define RPC__REQ__WIFI_SET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_channel__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetChannel +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_channel__descriptor) \ + , 0 } + + +struct RpcReqWifiGetChannel +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_channel__descriptor) \ + } + + +struct RpcRespWifiGetChannel +{ + ProtobufCMessage base; + int32_t resp; + int32_t primary; + int32_t second; +}; +#define RPC__RESP__WIFI_GET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_channel__descriptor) \ + , 0, 0, 0 } + + +struct RpcReqWifiSetStorage +{ + ProtobufCMessage base; + int32_t storage; +}; +#define RPC__REQ__WIFI_SET_STORAGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_storage__descriptor) \ + , 0 } + + +struct RpcRespWifiSetStorage +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_STORAGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_storage__descriptor) \ + , 0 } + + +struct RpcReqWifiSetCountryCode +{ + ProtobufCMessage base; + ProtobufCBinaryData country; + protobuf_c_boolean ieee80211d_enabled; +}; +#define RPC__REQ__WIFI_SET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_country_code__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespWifiSetCountryCode +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_country_code__descriptor) \ + , 0 } + + +struct RpcReqWifiGetCountryCode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_country_code__descriptor) \ + } + + +struct RpcRespWifiGetCountryCode +{ + ProtobufCMessage base; + int32_t resp; + ProtobufCBinaryData country; +}; +#define RPC__RESP__WIFI_GET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_country_code__descriptor) \ + , 0, {0,NULL} } + + +struct RpcReqWifiSetCountry +{ + ProtobufCMessage base; + WifiCountry *country; +}; +#define RPC__REQ__WIFI_SET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_country__descriptor) \ + , NULL } + + +struct RpcRespWifiSetCountry +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_country__descriptor) \ + , 0 } + + +struct RpcReqWifiGetCountry +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_country__descriptor) \ + } + + +struct RpcRespWifiGetCountry +{ + ProtobufCMessage base; + int32_t resp; + WifiCountry *country; +}; +#define RPC__RESP__WIFI_GET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_country__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiApGetStaList +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_AP_GET_STA_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_ap_get_sta_list__descriptor) \ + } + + +struct RpcRespWifiApGetStaList +{ + ProtobufCMessage base; + int32_t resp; + WifiStaList *sta_list; +}; +#define RPC__RESP__WIFI_AP_GET_STA_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_ap_get_sta_list__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiApGetStaAid +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; +}; +#define RPC__REQ__WIFI_AP_GET_STA_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_ap_get_sta_aid__descriptor) \ + , {0,NULL} } + + +struct RpcReqWifiStaGetNegotiatedPhymode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_negotiated_phymode__descriptor) \ + } + + +struct RpcRespWifiStaGetNegotiatedPhymode +{ + ProtobufCMessage base; + int32_t resp; + uint32_t phymode; +}; +#define RPC__RESP__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_negotiated_phymode__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiApGetStaAid +{ + ProtobufCMessage base; + int32_t resp; + uint32_t aid; +}; +#define RPC__RESP__WIFI_AP_GET_STA_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_ap_get_sta_aid__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaGetRssi +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_RSSI__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_rssi__descriptor) \ + } + + +struct RpcRespWifiStaGetRssi +{ + ProtobufCMessage base; + int32_t resp; + int32_t rssi; +}; +#define RPC__RESP__WIFI_STA_GET_RSSI__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_rssi__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaGetAid +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_aid__descriptor) \ + } + + +struct RpcRespWifiStaGetAid +{ + ProtobufCMessage base; + int32_t resp; + uint32_t aid; +}; +#define RPC__RESP__WIFI_STA_GET_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_aid__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetProtocols +{ + ProtobufCMessage base; + int32_t ifx; + WifiProtocols *protocols; +}; +#define RPC__REQ__WIFI_SET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_protocols__descriptor) \ + , 0, NULL } + + +struct RpcRespWifiSetProtocols +{ + ProtobufCMessage base; + int32_t resp; + uint32_t ifx; +}; +#define RPC__RESP__WIFI_SET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_protocols__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiGetProtocols +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_protocols__descriptor) \ + , 0 } + + +struct RpcRespWifiGetProtocols +{ + ProtobufCMessage base; + int32_t resp; + int32_t ifx; + WifiProtocols *protocols; +}; +#define RPC__RESP__WIFI_GET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_protocols__descriptor) \ + , 0, 0, NULL } + + +struct RpcReqWifiSetBandwidths +{ + ProtobufCMessage base; + int32_t ifx; + WifiBandwidths *bandwidths; +}; +#define RPC__REQ__WIFI_SET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_bandwidths__descriptor) \ + , 0, NULL } + + +struct RpcRespWifiSetBandwidths +{ + ProtobufCMessage base; + int32_t resp; + int32_t ifx; +}; +#define RPC__RESP__WIFI_SET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_bandwidths__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiGetBandwidths +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_bandwidths__descriptor) \ + , 0 } + + +struct RpcRespWifiGetBandwidths +{ + ProtobufCMessage base; + int32_t resp; + int32_t ifx; + WifiBandwidths *bandwidths; +}; +#define RPC__RESP__WIFI_GET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_bandwidths__descriptor) \ + , 0, 0, NULL } + + +struct RpcReqWifiSetBand +{ + ProtobufCMessage base; + uint32_t band; +}; +#define RPC__REQ__WIFI_SET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_band__descriptor) \ + , 0 } + + +struct RpcRespWifiSetBand +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_band__descriptor) \ + , 0 } + + +struct RpcReqWifiGetBand +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_band__descriptor) \ + } + + +struct RpcRespWifiGetBand +{ + ProtobufCMessage base; + int32_t resp; + uint32_t band; +}; +#define RPC__RESP__WIFI_GET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_band__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetBandMode +{ + ProtobufCMessage base; + uint32_t bandmode; +}; +#define RPC__REQ__WIFI_SET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_band_mode__descriptor) \ + , 0 } + + +struct RpcRespWifiSetBandMode +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_band_mode__descriptor) \ + , 0 } + + +struct RpcReqWifiGetBandMode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_band_mode__descriptor) \ + } + + +struct RpcRespWifiGetBandMode +{ + ProtobufCMessage base; + int32_t resp; + uint32_t bandmode; +}; +#define RPC__RESP__WIFI_GET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_band_mode__descriptor) \ + , 0, 0 } + + +struct RpcReqGetCoprocessorFwVersion +{ + ProtobufCMessage base; +}; +#define RPC__REQ__GET_COPROCESSOR_FW_VERSION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_coprocessor_fw_version__descriptor) \ + } + + +struct RpcRespGetCoprocessorFwVersion +{ + ProtobufCMessage base; + int32_t resp; + uint32_t major1; + uint32_t minor1; + uint32_t patch1; +}; +#define RPC__RESP__GET_COPROCESSOR_FW_VERSION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_coprocessor_fw_version__descriptor) \ + , 0, 0, 0, 0 } + + +struct RpcEventWifiEventNoArgs +{ + ProtobufCMessage base; + int32_t resp; + int32_t event_id; +}; +#define RPC__EVENT__WIFI_EVENT_NO_ARGS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_event_no_args__descriptor) \ + , 0, 0 } + + +struct RpcEventESPInit +{ + ProtobufCMessage base; + ProtobufCBinaryData init_data; +}; +#define RPC__EVENT__ESPINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__espinit__descriptor) \ + , {0,NULL} } + + +struct RpcEventHeartbeat +{ + ProtobufCMessage base; + int32_t hb_num; +}; +#define RPC__EVENT__HEARTBEAT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__heartbeat__descriptor) \ + , 0 } + + +struct RpcEventAPStaDisconnected +{ + ProtobufCMessage base; + int32_t resp; + ProtobufCBinaryData mac; + uint32_t aid; + protobuf_c_boolean is_mesh_child; + uint32_t reason; +}; +#define RPC__EVENT__AP__STA_DISCONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__ap__sta_disconnected__descriptor) \ + , 0, {0,NULL}, 0, 0, 0 } + + +struct RpcEventAPStaConnected +{ + ProtobufCMessage base; + int32_t resp; + ProtobufCBinaryData mac; + uint32_t aid; + protobuf_c_boolean is_mesh_child; +}; +#define RPC__EVENT__AP__STA_CONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__ap__sta_connected__descriptor) \ + , 0, {0,NULL}, 0, 0 } + + +struct RpcEventStaScanDone +{ + ProtobufCMessage base; + int32_t resp; + WifiEventStaScanDone *scan_done; +}; +#define RPC__EVENT__STA_SCAN_DONE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_scan_done__descriptor) \ + , 0, NULL } + + +struct RpcEventStaConnected +{ + ProtobufCMessage base; + int32_t resp; + WifiEventStaConnected *sta_connected; +}; +#define RPC__EVENT__STA_CONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_connected__descriptor) \ + , 0, NULL } + + +struct RpcEventStaDisconnected +{ + ProtobufCMessage base; + int32_t resp; + WifiEventStaDisconnected *sta_disconnected; +}; +#define RPC__EVENT__STA_DISCONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_disconnected__descriptor) \ + , 0, NULL } + + +typedef enum { + RPC__PAYLOAD__NOT_SET = 0, + RPC__PAYLOAD_REQ_GET_MAC_ADDRESS = 257, + RPC__PAYLOAD_REQ_SET_MAC_ADDRESS = 258, + RPC__PAYLOAD_REQ_GET_WIFI_MODE = 259, + RPC__PAYLOAD_REQ_SET_WIFI_MODE = 260, + RPC__PAYLOAD_REQ_WIFI_SET_PS = 270, + RPC__PAYLOAD_REQ_WIFI_GET_PS = 271, + RPC__PAYLOAD_REQ_OTA_BEGIN = 272, + RPC__PAYLOAD_REQ_OTA_WRITE = 273, + RPC__PAYLOAD_REQ_OTA_END = 274, + RPC__PAYLOAD_REQ_SET_WIFI_MAX_TX_POWER = 275, + RPC__PAYLOAD_REQ_GET_WIFI_MAX_TX_POWER = 276, + RPC__PAYLOAD_REQ_CONFIG_HEARTBEAT = 277, + RPC__PAYLOAD_REQ_WIFI_INIT = 278, + RPC__PAYLOAD_REQ_WIFI_DEINIT = 279, + RPC__PAYLOAD_REQ_WIFI_START = 280, + RPC__PAYLOAD_REQ_WIFI_STOP = 281, + RPC__PAYLOAD_REQ_WIFI_CONNECT = 282, + RPC__PAYLOAD_REQ_WIFI_DISCONNECT = 283, + RPC__PAYLOAD_REQ_WIFI_SET_CONFIG = 284, + RPC__PAYLOAD_REQ_WIFI_GET_CONFIG = 285, + RPC__PAYLOAD_REQ_WIFI_SCAN_START = 286, + RPC__PAYLOAD_REQ_WIFI_SCAN_STOP = 287, + RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_NUM = 288, + RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_RECORDS = 289, + RPC__PAYLOAD_REQ_WIFI_CLEAR_AP_LIST = 290, + RPC__PAYLOAD_REQ_WIFI_RESTORE = 291, + RPC__PAYLOAD_REQ_WIFI_CLEAR_FAST_CONNECT = 292, + RPC__PAYLOAD_REQ_WIFI_DEAUTH_STA = 293, + RPC__PAYLOAD_REQ_WIFI_STA_GET_AP_INFO = 294, + RPC__PAYLOAD_REQ_WIFI_SET_PROTOCOL = 297, + RPC__PAYLOAD_REQ_WIFI_GET_PROTOCOL = 298, + RPC__PAYLOAD_REQ_WIFI_SET_BANDWIDTH = 299, + RPC__PAYLOAD_REQ_WIFI_GET_BANDWIDTH = 300, + RPC__PAYLOAD_REQ_WIFI_SET_CHANNEL = 301, + RPC__PAYLOAD_REQ_WIFI_GET_CHANNEL = 302, + RPC__PAYLOAD_REQ_WIFI_SET_COUNTRY = 303, + RPC__PAYLOAD_REQ_WIFI_GET_COUNTRY = 304, + RPC__PAYLOAD_REQ_WIFI_AP_GET_STA_LIST = 311, + RPC__PAYLOAD_REQ_WIFI_AP_GET_STA_AID = 312, + RPC__PAYLOAD_REQ_WIFI_SET_STORAGE = 313, + RPC__PAYLOAD_REQ_WIFI_SET_COUNTRY_CODE = 334, + RPC__PAYLOAD_REQ_WIFI_GET_COUNTRY_CODE = 335, + RPC__PAYLOAD_REQ_WIFI_STA_GET_AID = 338, + RPC__PAYLOAD_REQ_WIFI_STA_GET_NEGOTIATED_PHYMODE = 339, + RPC__PAYLOAD_REQ_WIFI_STA_GET_RSSI = 341, + RPC__PAYLOAD_REQ_WIFI_SET_PROTOCOLS = 342, + RPC__PAYLOAD_REQ_WIFI_GET_PROTOCOLS = 343, + RPC__PAYLOAD_REQ_WIFI_SET_BANDWIDTHS = 344, + RPC__PAYLOAD_REQ_WIFI_GET_BANDWIDTHS = 345, + RPC__PAYLOAD_REQ_WIFI_SET_BAND = 346, + RPC__PAYLOAD_REQ_WIFI_GET_BAND = 347, + RPC__PAYLOAD_REQ_WIFI_SET_BANDMODE = 348, + RPC__PAYLOAD_REQ_WIFI_GET_BANDMODE = 349, + RPC__PAYLOAD_REQ_GET_COPROCESSOR_FWVERSION = 350, + RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_RECORD = 351, + RPC__PAYLOAD_RESP_GET_MAC_ADDRESS = 513, + RPC__PAYLOAD_RESP_SET_MAC_ADDRESS = 514, + RPC__PAYLOAD_RESP_GET_WIFI_MODE = 515, + RPC__PAYLOAD_RESP_SET_WIFI_MODE = 516, + RPC__PAYLOAD_RESP_WIFI_SET_PS = 526, + RPC__PAYLOAD_RESP_WIFI_GET_PS = 527, + RPC__PAYLOAD_RESP_OTA_BEGIN = 528, + RPC__PAYLOAD_RESP_OTA_WRITE = 529, + RPC__PAYLOAD_RESP_OTA_END = 530, + RPC__PAYLOAD_RESP_SET_WIFI_MAX_TX_POWER = 531, + RPC__PAYLOAD_RESP_GET_WIFI_MAX_TX_POWER = 532, + RPC__PAYLOAD_RESP_CONFIG_HEARTBEAT = 533, + RPC__PAYLOAD_RESP_WIFI_INIT = 534, + RPC__PAYLOAD_RESP_WIFI_DEINIT = 535, + RPC__PAYLOAD_RESP_WIFI_START = 536, + RPC__PAYLOAD_RESP_WIFI_STOP = 537, + RPC__PAYLOAD_RESP_WIFI_CONNECT = 538, + RPC__PAYLOAD_RESP_WIFI_DISCONNECT = 539, + RPC__PAYLOAD_RESP_WIFI_SET_CONFIG = 540, + RPC__PAYLOAD_RESP_WIFI_GET_CONFIG = 541, + RPC__PAYLOAD_RESP_WIFI_SCAN_START = 542, + RPC__PAYLOAD_RESP_WIFI_SCAN_STOP = 543, + RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_NUM = 544, + RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_RECORDS = 545, + RPC__PAYLOAD_RESP_WIFI_CLEAR_AP_LIST = 546, + RPC__PAYLOAD_RESP_WIFI_RESTORE = 547, + RPC__PAYLOAD_RESP_WIFI_CLEAR_FAST_CONNECT = 548, + RPC__PAYLOAD_RESP_WIFI_DEAUTH_STA = 549, + RPC__PAYLOAD_RESP_WIFI_STA_GET_AP_INFO = 550, + RPC__PAYLOAD_RESP_WIFI_SET_PROTOCOL = 553, + RPC__PAYLOAD_RESP_WIFI_GET_PROTOCOL = 554, + RPC__PAYLOAD_RESP_WIFI_SET_BANDWIDTH = 555, + RPC__PAYLOAD_RESP_WIFI_GET_BANDWIDTH = 556, + RPC__PAYLOAD_RESP_WIFI_SET_CHANNEL = 557, + RPC__PAYLOAD_RESP_WIFI_GET_CHANNEL = 558, + RPC__PAYLOAD_RESP_WIFI_SET_COUNTRY = 559, + RPC__PAYLOAD_RESP_WIFI_GET_COUNTRY = 560, + RPC__PAYLOAD_RESP_WIFI_AP_GET_STA_LIST = 567, + RPC__PAYLOAD_RESP_WIFI_AP_GET_STA_AID = 568, + RPC__PAYLOAD_RESP_WIFI_SET_STORAGE = 569, + RPC__PAYLOAD_RESP_WIFI_SET_COUNTRY_CODE = 590, + RPC__PAYLOAD_RESP_WIFI_GET_COUNTRY_CODE = 591, + RPC__PAYLOAD_RESP_WIFI_STA_GET_AID = 594, + RPC__PAYLOAD_RESP_WIFI_STA_GET_NEGOTIATED_PHYMODE = 595, + RPC__PAYLOAD_RESP_WIFI_STA_GET_RSSI = 597, + RPC__PAYLOAD_RESP_WIFI_SET_PROTOCOLS = 598, + RPC__PAYLOAD_RESP_WIFI_GET_PROTOCOLS = 599, + RPC__PAYLOAD_RESP_WIFI_SET_BANDWIDTHS = 600, + RPC__PAYLOAD_RESP_WIFI_GET_BANDWIDTHS = 601, + RPC__PAYLOAD_RESP_WIFI_SET_BAND = 602, + RPC__PAYLOAD_RESP_WIFI_GET_BAND = 603, + RPC__PAYLOAD_RESP_WIFI_SET_BANDMODE = 604, + RPC__PAYLOAD_RESP_WIFI_GET_BANDMODE = 605, + RPC__PAYLOAD_RESP_GET_COPROCESSOR_FWVERSION = 606, + RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_RECORD = 607, + RPC__PAYLOAD_EVENT_ESP_INIT = 769, + RPC__PAYLOAD_EVENT_HEARTBEAT = 770, + RPC__PAYLOAD_EVENT_AP_STA_CONNECTED = 771, + RPC__PAYLOAD_EVENT_AP_STA_DISCONNECTED = 772, + RPC__PAYLOAD_EVENT_WIFI_EVENT_NO_ARGS = 773, + RPC__PAYLOAD_EVENT_STA_SCAN_DONE = 774, + RPC__PAYLOAD_EVENT_STA_CONNECTED = 775, + RPC__PAYLOAD_EVENT_STA_DISCONNECTED = 776 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__PAYLOAD__CASE) +} Rpc__PayloadCase; + +struct Rpc +{ + ProtobufCMessage base; + /* + * msg_type could be req, resp or Event + */ + RpcType msg_type; + /* + * msg id + */ + RpcId msg_id; + /* + * UID of message + */ + uint32_t uid; + Rpc__PayloadCase payload_case; + union { + /* + ** Requests * + */ + RpcReqGetMacAddress *req_get_mac_address; + RpcReqSetMacAddress *req_set_mac_address; + RpcReqGetMode *req_get_wifi_mode; + RpcReqSetMode *req_set_wifi_mode; + RpcReqSetPs *req_wifi_set_ps; + RpcReqGetPs *req_wifi_get_ps; + RpcReqOTABegin *req_ota_begin; + RpcReqOTAWrite *req_ota_write; + RpcReqOTAEnd *req_ota_end; + RpcReqWifiSetMaxTxPower *req_set_wifi_max_tx_power; + RpcReqWifiGetMaxTxPower *req_get_wifi_max_tx_power; + RpcReqConfigHeartbeat *req_config_heartbeat; + RpcReqWifiInit *req_wifi_init; + RpcReqWifiDeinit *req_wifi_deinit; + RpcReqWifiStart *req_wifi_start; + RpcReqWifiStop *req_wifi_stop; + RpcReqWifiConnect *req_wifi_connect; + RpcReqWifiDisconnect *req_wifi_disconnect; + RpcReqWifiSetConfig *req_wifi_set_config; + RpcReqWifiGetConfig *req_wifi_get_config; + RpcReqWifiScanStart *req_wifi_scan_start; + RpcReqWifiScanStop *req_wifi_scan_stop; + RpcReqWifiScanGetApNum *req_wifi_scan_get_ap_num; + RpcReqWifiScanGetApRecords *req_wifi_scan_get_ap_records; + RpcReqWifiClearApList *req_wifi_clear_ap_list; + RpcReqWifiRestore *req_wifi_restore; + RpcReqWifiClearFastConnect *req_wifi_clear_fast_connect; + RpcReqWifiDeauthSta *req_wifi_deauth_sta; + RpcReqWifiStaGetApInfo *req_wifi_sta_get_ap_info; + RpcReqWifiSetProtocol *req_wifi_set_protocol; + RpcReqWifiGetProtocol *req_wifi_get_protocol; + RpcReqWifiSetBandwidth *req_wifi_set_bandwidth; + RpcReqWifiGetBandwidth *req_wifi_get_bandwidth; + RpcReqWifiSetChannel *req_wifi_set_channel; + RpcReqWifiGetChannel *req_wifi_get_channel; + RpcReqWifiSetCountry *req_wifi_set_country; + RpcReqWifiGetCountry *req_wifi_get_country; + RpcReqWifiApGetStaList *req_wifi_ap_get_sta_list; + RpcReqWifiApGetStaAid *req_wifi_ap_get_sta_aid; + RpcReqWifiSetStorage *req_wifi_set_storage; + RpcReqWifiSetCountryCode *req_wifi_set_country_code; + RpcReqWifiGetCountryCode *req_wifi_get_country_code; + RpcReqWifiStaGetAid *req_wifi_sta_get_aid; + RpcReqWifiStaGetNegotiatedPhymode *req_wifi_sta_get_negotiated_phymode; + RpcReqWifiStaGetRssi *req_wifi_sta_get_rssi; + RpcReqWifiSetProtocols *req_wifi_set_protocols; + RpcReqWifiGetProtocols *req_wifi_get_protocols; + RpcReqWifiSetBandwidths *req_wifi_set_bandwidths; + RpcReqWifiGetBandwidths *req_wifi_get_bandwidths; + RpcReqWifiSetBand *req_wifi_set_band; + RpcReqWifiGetBand *req_wifi_get_band; + RpcReqWifiSetBandMode *req_wifi_set_bandmode; + RpcReqWifiGetBandMode *req_wifi_get_bandmode; + RpcReqGetCoprocessorFwVersion *req_get_coprocessor_fwversion; + RpcReqWifiScanGetApRecord *req_wifi_scan_get_ap_record; + /* + ** Responses * + */ + RpcRespGetMacAddress *resp_get_mac_address; + RpcRespSetMacAddress *resp_set_mac_address; + RpcRespGetMode *resp_get_wifi_mode; + RpcRespSetMode *resp_set_wifi_mode; + RpcRespSetPs *resp_wifi_set_ps; + RpcRespGetPs *resp_wifi_get_ps; + RpcRespOTABegin *resp_ota_begin; + RpcRespOTAWrite *resp_ota_write; + RpcRespOTAEnd *resp_ota_end; + RpcRespWifiSetMaxTxPower *resp_set_wifi_max_tx_power; + RpcRespWifiGetMaxTxPower *resp_get_wifi_max_tx_power; + RpcRespConfigHeartbeat *resp_config_heartbeat; + RpcRespWifiInit *resp_wifi_init; + RpcRespWifiDeinit *resp_wifi_deinit; + RpcRespWifiStart *resp_wifi_start; + RpcRespWifiStop *resp_wifi_stop; + RpcRespWifiConnect *resp_wifi_connect; + RpcRespWifiDisconnect *resp_wifi_disconnect; + RpcRespWifiSetConfig *resp_wifi_set_config; + RpcRespWifiGetConfig *resp_wifi_get_config; + RpcRespWifiScanStart *resp_wifi_scan_start; + RpcRespWifiScanStop *resp_wifi_scan_stop; + RpcRespWifiScanGetApNum *resp_wifi_scan_get_ap_num; + RpcRespWifiScanGetApRecords *resp_wifi_scan_get_ap_records; + RpcRespWifiClearApList *resp_wifi_clear_ap_list; + RpcRespWifiRestore *resp_wifi_restore; + RpcRespWifiClearFastConnect *resp_wifi_clear_fast_connect; + RpcRespWifiDeauthSta *resp_wifi_deauth_sta; + RpcRespWifiStaGetApInfo *resp_wifi_sta_get_ap_info; + RpcRespWifiSetProtocol *resp_wifi_set_protocol; + RpcRespWifiGetProtocol *resp_wifi_get_protocol; + RpcRespWifiSetBandwidth *resp_wifi_set_bandwidth; + RpcRespWifiGetBandwidth *resp_wifi_get_bandwidth; + RpcRespWifiSetChannel *resp_wifi_set_channel; + RpcRespWifiGetChannel *resp_wifi_get_channel; + RpcRespWifiSetCountry *resp_wifi_set_country; + RpcRespWifiGetCountry *resp_wifi_get_country; + RpcRespWifiApGetStaList *resp_wifi_ap_get_sta_list; + RpcRespWifiApGetStaAid *resp_wifi_ap_get_sta_aid; + RpcRespWifiSetStorage *resp_wifi_set_storage; + RpcRespWifiSetCountryCode *resp_wifi_set_country_code; + RpcRespWifiGetCountryCode *resp_wifi_get_country_code; + RpcRespWifiStaGetAid *resp_wifi_sta_get_aid; + RpcRespWifiStaGetNegotiatedPhymode *resp_wifi_sta_get_negotiated_phymode; + RpcRespWifiStaGetRssi *resp_wifi_sta_get_rssi; + RpcRespWifiSetProtocols *resp_wifi_set_protocols; + RpcRespWifiGetProtocols *resp_wifi_get_protocols; + RpcRespWifiSetBandwidths *resp_wifi_set_bandwidths; + RpcRespWifiGetBandwidths *resp_wifi_get_bandwidths; + RpcRespWifiSetBand *resp_wifi_set_band; + RpcRespWifiGetBand *resp_wifi_get_band; + RpcRespWifiSetBandMode *resp_wifi_set_bandmode; + RpcRespWifiGetBandMode *resp_wifi_get_bandmode; + RpcRespGetCoprocessorFwVersion *resp_get_coprocessor_fwversion; + RpcRespWifiScanGetApRecord *resp_wifi_scan_get_ap_record; + /* + ** Notifications * + */ + RpcEventESPInit *event_esp_init; + RpcEventHeartbeat *event_heartbeat; + RpcEventAPStaConnected *event_ap_sta_connected; + RpcEventAPStaDisconnected *event_ap_sta_disconnected; + RpcEventWifiEventNoArgs *event_wifi_event_no_args; + RpcEventStaScanDone *event_sta_scan_done; + RpcEventStaConnected *event_sta_connected; + RpcEventStaDisconnected *event_sta_disconnected; + }; +}; +#define RPC__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__descriptor) \ + , RPC_TYPE__MsgType_Invalid, RPC_ID__MsgId_Invalid, 0, RPC__PAYLOAD__NOT_SET, {0} } + + +/* WifiInitConfig methods */ +void wifi_init_config__init + (WifiInitConfig *message); +size_t wifi_init_config__get_packed_size + (const WifiInitConfig *message); +size_t wifi_init_config__pack + (const WifiInitConfig *message, + uint8_t *out); +size_t wifi_init_config__pack_to_buffer + (const WifiInitConfig *message, + ProtobufCBuffer *buffer); +WifiInitConfig * + wifi_init_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_init_config__free_unpacked + (WifiInitConfig *message, + ProtobufCAllocator *allocator); +/* WifiCountry methods */ +void wifi_country__init + (WifiCountry *message); +size_t wifi_country__get_packed_size + (const WifiCountry *message); +size_t wifi_country__pack + (const WifiCountry *message, + uint8_t *out); +size_t wifi_country__pack_to_buffer + (const WifiCountry *message, + ProtobufCBuffer *buffer); +WifiCountry * + wifi_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_country__free_unpacked + (WifiCountry *message, + ProtobufCAllocator *allocator); +/* WifiActiveScanTime methods */ +void wifi_active_scan_time__init + (WifiActiveScanTime *message); +size_t wifi_active_scan_time__get_packed_size + (const WifiActiveScanTime *message); +size_t wifi_active_scan_time__pack + (const WifiActiveScanTime *message, + uint8_t *out); +size_t wifi_active_scan_time__pack_to_buffer + (const WifiActiveScanTime *message, + ProtobufCBuffer *buffer); +WifiActiveScanTime * + wifi_active_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_active_scan_time__free_unpacked + (WifiActiveScanTime *message, + ProtobufCAllocator *allocator); +/* WifiScanTime methods */ +void wifi_scan_time__init + (WifiScanTime *message); +size_t wifi_scan_time__get_packed_size + (const WifiScanTime *message); +size_t wifi_scan_time__pack + (const WifiScanTime *message, + uint8_t *out); +size_t wifi_scan_time__pack_to_buffer + (const WifiScanTime *message, + ProtobufCBuffer *buffer); +WifiScanTime * + wifi_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_time__free_unpacked + (WifiScanTime *message, + ProtobufCAllocator *allocator); +/* WifiScanConfig methods */ +void wifi_scan_config__init + (WifiScanConfig *message); +size_t wifi_scan_config__get_packed_size + (const WifiScanConfig *message); +size_t wifi_scan_config__pack + (const WifiScanConfig *message, + uint8_t *out); +size_t wifi_scan_config__pack_to_buffer + (const WifiScanConfig *message, + ProtobufCBuffer *buffer); +WifiScanConfig * + wifi_scan_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_config__free_unpacked + (WifiScanConfig *message, + ProtobufCAllocator *allocator); +/* WifiHeApInfo methods */ +void wifi_he_ap_info__init + (WifiHeApInfo *message); +size_t wifi_he_ap_info__get_packed_size + (const WifiHeApInfo *message); +size_t wifi_he_ap_info__pack + (const WifiHeApInfo *message, + uint8_t *out); +size_t wifi_he_ap_info__pack_to_buffer + (const WifiHeApInfo *message, + ProtobufCBuffer *buffer); +WifiHeApInfo * + wifi_he_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_he_ap_info__free_unpacked + (WifiHeApInfo *message, + ProtobufCAllocator *allocator); +/* WifiApRecord methods */ +void wifi_ap_record__init + (WifiApRecord *message); +size_t wifi_ap_record__get_packed_size + (const WifiApRecord *message); +size_t wifi_ap_record__pack + (const WifiApRecord *message, + uint8_t *out); +size_t wifi_ap_record__pack_to_buffer + (const WifiApRecord *message, + ProtobufCBuffer *buffer); +WifiApRecord * + wifi_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ap_record__free_unpacked + (WifiApRecord *message, + ProtobufCAllocator *allocator); +/* WifiScanThreshold methods */ +void wifi_scan_threshold__init + (WifiScanThreshold *message); +size_t wifi_scan_threshold__get_packed_size + (const WifiScanThreshold *message); +size_t wifi_scan_threshold__pack + (const WifiScanThreshold *message, + uint8_t *out); +size_t wifi_scan_threshold__pack_to_buffer + (const WifiScanThreshold *message, + ProtobufCBuffer *buffer); +WifiScanThreshold * + wifi_scan_threshold__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_threshold__free_unpacked + (WifiScanThreshold *message, + ProtobufCAllocator *allocator); +/* WifiPmfConfig methods */ +void wifi_pmf_config__init + (WifiPmfConfig *message); +size_t wifi_pmf_config__get_packed_size + (const WifiPmfConfig *message); +size_t wifi_pmf_config__pack + (const WifiPmfConfig *message, + uint8_t *out); +size_t wifi_pmf_config__pack_to_buffer + (const WifiPmfConfig *message, + ProtobufCBuffer *buffer); +WifiPmfConfig * + wifi_pmf_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_pmf_config__free_unpacked + (WifiPmfConfig *message, + ProtobufCAllocator *allocator); +/* WifiApConfig methods */ +void wifi_ap_config__init + (WifiApConfig *message); +size_t wifi_ap_config__get_packed_size + (const WifiApConfig *message); +size_t wifi_ap_config__pack + (const WifiApConfig *message, + uint8_t *out); +size_t wifi_ap_config__pack_to_buffer + (const WifiApConfig *message, + ProtobufCBuffer *buffer); +WifiApConfig * + wifi_ap_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ap_config__free_unpacked + (WifiApConfig *message, + ProtobufCAllocator *allocator); +/* WifiStaConfig methods */ +void wifi_sta_config__init + (WifiStaConfig *message); +size_t wifi_sta_config__get_packed_size + (const WifiStaConfig *message); +size_t wifi_sta_config__pack + (const WifiStaConfig *message, + uint8_t *out); +size_t wifi_sta_config__pack_to_buffer + (const WifiStaConfig *message, + ProtobufCBuffer *buffer); +WifiStaConfig * + wifi_sta_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_sta_config__free_unpacked + (WifiStaConfig *message, + ProtobufCAllocator *allocator); +/* WifiConfig methods */ +void wifi_config__init + (WifiConfig *message); +size_t wifi_config__get_packed_size + (const WifiConfig *message); +size_t wifi_config__pack + (const WifiConfig *message, + uint8_t *out); +size_t wifi_config__pack_to_buffer + (const WifiConfig *message, + ProtobufCBuffer *buffer); +WifiConfig * + wifi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_config__free_unpacked + (WifiConfig *message, + ProtobufCAllocator *allocator); +/* WifiStaInfo methods */ +void wifi_sta_info__init + (WifiStaInfo *message); +size_t wifi_sta_info__get_packed_size + (const WifiStaInfo *message); +size_t wifi_sta_info__pack + (const WifiStaInfo *message, + uint8_t *out); +size_t wifi_sta_info__pack_to_buffer + (const WifiStaInfo *message, + ProtobufCBuffer *buffer); +WifiStaInfo * + wifi_sta_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_sta_info__free_unpacked + (WifiStaInfo *message, + ProtobufCAllocator *allocator); +/* WifiStaList methods */ +void wifi_sta_list__init + (WifiStaList *message); +size_t wifi_sta_list__get_packed_size + (const WifiStaList *message); +size_t wifi_sta_list__pack + (const WifiStaList *message, + uint8_t *out); +size_t wifi_sta_list__pack_to_buffer + (const WifiStaList *message, + ProtobufCBuffer *buffer); +WifiStaList * + wifi_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_sta_list__free_unpacked + (WifiStaList *message, + ProtobufCAllocator *allocator); +/* WifiPktRxCtrl methods */ +void wifi_pkt_rx_ctrl__init + (WifiPktRxCtrl *message); +size_t wifi_pkt_rx_ctrl__get_packed_size + (const WifiPktRxCtrl *message); +size_t wifi_pkt_rx_ctrl__pack + (const WifiPktRxCtrl *message, + uint8_t *out); +size_t wifi_pkt_rx_ctrl__pack_to_buffer + (const WifiPktRxCtrl *message, + ProtobufCBuffer *buffer); +WifiPktRxCtrl * + wifi_pkt_rx_ctrl__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_pkt_rx_ctrl__free_unpacked + (WifiPktRxCtrl *message, + ProtobufCAllocator *allocator); +/* WifiPromiscuousPkt methods */ +void wifi_promiscuous_pkt__init + (WifiPromiscuousPkt *message); +size_t wifi_promiscuous_pkt__get_packed_size + (const WifiPromiscuousPkt *message); +size_t wifi_promiscuous_pkt__pack + (const WifiPromiscuousPkt *message, + uint8_t *out); +size_t wifi_promiscuous_pkt__pack_to_buffer + (const WifiPromiscuousPkt *message, + ProtobufCBuffer *buffer); +WifiPromiscuousPkt * + wifi_promiscuous_pkt__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_promiscuous_pkt__free_unpacked + (WifiPromiscuousPkt *message, + ProtobufCAllocator *allocator); +/* WifiPromiscuousFilter methods */ +void wifi_promiscuous_filter__init + (WifiPromiscuousFilter *message); +size_t wifi_promiscuous_filter__get_packed_size + (const WifiPromiscuousFilter *message); +size_t wifi_promiscuous_filter__pack + (const WifiPromiscuousFilter *message, + uint8_t *out); +size_t wifi_promiscuous_filter__pack_to_buffer + (const WifiPromiscuousFilter *message, + ProtobufCBuffer *buffer); +WifiPromiscuousFilter * + wifi_promiscuous_filter__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_promiscuous_filter__free_unpacked + (WifiPromiscuousFilter *message, + ProtobufCAllocator *allocator); +/* WifiCsiConfig methods */ +void wifi_csi_config__init + (WifiCsiConfig *message); +size_t wifi_csi_config__get_packed_size + (const WifiCsiConfig *message); +size_t wifi_csi_config__pack + (const WifiCsiConfig *message, + uint8_t *out); +size_t wifi_csi_config__pack_to_buffer + (const WifiCsiConfig *message, + ProtobufCBuffer *buffer); +WifiCsiConfig * + wifi_csi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_csi_config__free_unpacked + (WifiCsiConfig *message, + ProtobufCAllocator *allocator); +/* WifiCsiInfo methods */ +void wifi_csi_info__init + (WifiCsiInfo *message); +size_t wifi_csi_info__get_packed_size + (const WifiCsiInfo *message); +size_t wifi_csi_info__pack + (const WifiCsiInfo *message, + uint8_t *out); +size_t wifi_csi_info__pack_to_buffer + (const WifiCsiInfo *message, + ProtobufCBuffer *buffer); +WifiCsiInfo * + wifi_csi_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_csi_info__free_unpacked + (WifiCsiInfo *message, + ProtobufCAllocator *allocator); +/* WifiAntGpio methods */ +void wifi_ant_gpio__init + (WifiAntGpio *message); +size_t wifi_ant_gpio__get_packed_size + (const WifiAntGpio *message); +size_t wifi_ant_gpio__pack + (const WifiAntGpio *message, + uint8_t *out); +size_t wifi_ant_gpio__pack_to_buffer + (const WifiAntGpio *message, + ProtobufCBuffer *buffer); +WifiAntGpio * + wifi_ant_gpio__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ant_gpio__free_unpacked + (WifiAntGpio *message, + ProtobufCAllocator *allocator); +/* WifiAntGpioConfig methods */ +void wifi_ant_gpio_config__init + (WifiAntGpioConfig *message); +size_t wifi_ant_gpio_config__get_packed_size + (const WifiAntGpioConfig *message); +size_t wifi_ant_gpio_config__pack + (const WifiAntGpioConfig *message, + uint8_t *out); +size_t wifi_ant_gpio_config__pack_to_buffer + (const WifiAntGpioConfig *message, + ProtobufCBuffer *buffer); +WifiAntGpioConfig * + wifi_ant_gpio_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ant_gpio_config__free_unpacked + (WifiAntGpioConfig *message, + ProtobufCAllocator *allocator); +/* WifiAntConfig methods */ +void wifi_ant_config__init + (WifiAntConfig *message); +size_t wifi_ant_config__get_packed_size + (const WifiAntConfig *message); +size_t wifi_ant_config__pack + (const WifiAntConfig *message, + uint8_t *out); +size_t wifi_ant_config__pack_to_buffer + (const WifiAntConfig *message, + ProtobufCBuffer *buffer); +WifiAntConfig * + wifi_ant_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ant_config__free_unpacked + (WifiAntConfig *message, + ProtobufCAllocator *allocator); +/* WifiActionTxReq methods */ +void wifi_action_tx_req__init + (WifiActionTxReq *message); +size_t wifi_action_tx_req__get_packed_size + (const WifiActionTxReq *message); +size_t wifi_action_tx_req__pack + (const WifiActionTxReq *message, + uint8_t *out); +size_t wifi_action_tx_req__pack_to_buffer + (const WifiActionTxReq *message, + ProtobufCBuffer *buffer); +WifiActionTxReq * + wifi_action_tx_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_action_tx_req__free_unpacked + (WifiActionTxReq *message, + ProtobufCAllocator *allocator); +/* WifiFtmInitiatorCfg methods */ +void wifi_ftm_initiator_cfg__init + (WifiFtmInitiatorCfg *message); +size_t wifi_ftm_initiator_cfg__get_packed_size + (const WifiFtmInitiatorCfg *message); +size_t wifi_ftm_initiator_cfg__pack + (const WifiFtmInitiatorCfg *message, + uint8_t *out); +size_t wifi_ftm_initiator_cfg__pack_to_buffer + (const WifiFtmInitiatorCfg *message, + ProtobufCBuffer *buffer); +WifiFtmInitiatorCfg * + wifi_ftm_initiator_cfg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ftm_initiator_cfg__free_unpacked + (WifiFtmInitiatorCfg *message, + ProtobufCAllocator *allocator); +/* WifiEventStaScanDone methods */ +void wifi_event_sta_scan_done__init + (WifiEventStaScanDone *message); +size_t wifi_event_sta_scan_done__get_packed_size + (const WifiEventStaScanDone *message); +size_t wifi_event_sta_scan_done__pack + (const WifiEventStaScanDone *message, + uint8_t *out); +size_t wifi_event_sta_scan_done__pack_to_buffer + (const WifiEventStaScanDone *message, + ProtobufCBuffer *buffer); +WifiEventStaScanDone * + wifi_event_sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_scan_done__free_unpacked + (WifiEventStaScanDone *message, + ProtobufCAllocator *allocator); +/* WifiEventStaConnected methods */ +void wifi_event_sta_connected__init + (WifiEventStaConnected *message); +size_t wifi_event_sta_connected__get_packed_size + (const WifiEventStaConnected *message); +size_t wifi_event_sta_connected__pack + (const WifiEventStaConnected *message, + uint8_t *out); +size_t wifi_event_sta_connected__pack_to_buffer + (const WifiEventStaConnected *message, + ProtobufCBuffer *buffer); +WifiEventStaConnected * + wifi_event_sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_connected__free_unpacked + (WifiEventStaConnected *message, + ProtobufCAllocator *allocator); +/* WifiEventStaDisconnected methods */ +void wifi_event_sta_disconnected__init + (WifiEventStaDisconnected *message); +size_t wifi_event_sta_disconnected__get_packed_size + (const WifiEventStaDisconnected *message); +size_t wifi_event_sta_disconnected__pack + (const WifiEventStaDisconnected *message, + uint8_t *out); +size_t wifi_event_sta_disconnected__pack_to_buffer + (const WifiEventStaDisconnected *message, + ProtobufCBuffer *buffer); +WifiEventStaDisconnected * + wifi_event_sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_disconnected__free_unpacked + (WifiEventStaDisconnected *message, + ProtobufCAllocator *allocator); +/* WifiEventStaAuthmodeChange methods */ +void wifi_event_sta_authmode_change__init + (WifiEventStaAuthmodeChange *message); +size_t wifi_event_sta_authmode_change__get_packed_size + (const WifiEventStaAuthmodeChange *message); +size_t wifi_event_sta_authmode_change__pack + (const WifiEventStaAuthmodeChange *message, + uint8_t *out); +size_t wifi_event_sta_authmode_change__pack_to_buffer + (const WifiEventStaAuthmodeChange *message, + ProtobufCBuffer *buffer); +WifiEventStaAuthmodeChange * + wifi_event_sta_authmode_change__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_authmode_change__free_unpacked + (WifiEventStaAuthmodeChange *message, + ProtobufCAllocator *allocator); +/* WifiEventStaWpsErPin methods */ +void wifi_event_sta_wps_er_pin__init + (WifiEventStaWpsErPin *message); +size_t wifi_event_sta_wps_er_pin__get_packed_size + (const WifiEventStaWpsErPin *message); +size_t wifi_event_sta_wps_er_pin__pack + (const WifiEventStaWpsErPin *message, + uint8_t *out); +size_t wifi_event_sta_wps_er_pin__pack_to_buffer + (const WifiEventStaWpsErPin *message, + ProtobufCBuffer *buffer); +WifiEventStaWpsErPin * + wifi_event_sta_wps_er_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_wps_er_pin__free_unpacked + (WifiEventStaWpsErPin *message, + ProtobufCAllocator *allocator); +/* ApCred methods */ +void ap_cred__init + (ApCred *message); +size_t ap_cred__get_packed_size + (const ApCred *message); +size_t ap_cred__pack + (const ApCred *message, + uint8_t *out); +size_t ap_cred__pack_to_buffer + (const ApCred *message, + ProtobufCBuffer *buffer); +ApCred * + ap_cred__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ap_cred__free_unpacked + (ApCred *message, + ProtobufCAllocator *allocator); +/* WifiEventStaWpsErSuccess methods */ +void wifi_event_sta_wps_er_success__init + (WifiEventStaWpsErSuccess *message); +size_t wifi_event_sta_wps_er_success__get_packed_size + (const WifiEventStaWpsErSuccess *message); +size_t wifi_event_sta_wps_er_success__pack + (const WifiEventStaWpsErSuccess *message, + uint8_t *out); +size_t wifi_event_sta_wps_er_success__pack_to_buffer + (const WifiEventStaWpsErSuccess *message, + ProtobufCBuffer *buffer); +WifiEventStaWpsErSuccess * + wifi_event_sta_wps_er_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_wps_er_success__free_unpacked + (WifiEventStaWpsErSuccess *message, + ProtobufCAllocator *allocator); +/* WifiEventApProbeReqRx methods */ +void wifi_event_ap_probe_req_rx__init + (WifiEventApProbeReqRx *message); +size_t wifi_event_ap_probe_req_rx__get_packed_size + (const WifiEventApProbeReqRx *message); +size_t wifi_event_ap_probe_req_rx__pack + (const WifiEventApProbeReqRx *message, + uint8_t *out); +size_t wifi_event_ap_probe_req_rx__pack_to_buffer + (const WifiEventApProbeReqRx *message, + ProtobufCBuffer *buffer); +WifiEventApProbeReqRx * + wifi_event_ap_probe_req_rx__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_probe_req_rx__free_unpacked + (WifiEventApProbeReqRx *message, + ProtobufCAllocator *allocator); +/* WifiEventBssRssiLow methods */ +void wifi_event_bss_rssi_low__init + (WifiEventBssRssiLow *message); +size_t wifi_event_bss_rssi_low__get_packed_size + (const WifiEventBssRssiLow *message); +size_t wifi_event_bss_rssi_low__pack + (const WifiEventBssRssiLow *message, + uint8_t *out); +size_t wifi_event_bss_rssi_low__pack_to_buffer + (const WifiEventBssRssiLow *message, + ProtobufCBuffer *buffer); +WifiEventBssRssiLow * + wifi_event_bss_rssi_low__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_bss_rssi_low__free_unpacked + (WifiEventBssRssiLow *message, + ProtobufCAllocator *allocator); +/* WifiFtmReportEntry methods */ +void wifi_ftm_report_entry__init + (WifiFtmReportEntry *message); +size_t wifi_ftm_report_entry__get_packed_size + (const WifiFtmReportEntry *message); +size_t wifi_ftm_report_entry__pack + (const WifiFtmReportEntry *message, + uint8_t *out); +size_t wifi_ftm_report_entry__pack_to_buffer + (const WifiFtmReportEntry *message, + ProtobufCBuffer *buffer); +WifiFtmReportEntry * + wifi_ftm_report_entry__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ftm_report_entry__free_unpacked + (WifiFtmReportEntry *message, + ProtobufCAllocator *allocator); +/* WifiEventFtmReport methods */ +void wifi_event_ftm_report__init + (WifiEventFtmReport *message); +size_t wifi_event_ftm_report__get_packed_size + (const WifiEventFtmReport *message); +size_t wifi_event_ftm_report__pack + (const WifiEventFtmReport *message, + uint8_t *out); +size_t wifi_event_ftm_report__pack_to_buffer + (const WifiEventFtmReport *message, + ProtobufCBuffer *buffer); +WifiEventFtmReport * + wifi_event_ftm_report__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ftm_report__free_unpacked + (WifiEventFtmReport *message, + ProtobufCAllocator *allocator); +/* WifiEventActionTxStatus methods */ +void wifi_event_action_tx_status__init + (WifiEventActionTxStatus *message); +size_t wifi_event_action_tx_status__get_packed_size + (const WifiEventActionTxStatus *message); +size_t wifi_event_action_tx_status__pack + (const WifiEventActionTxStatus *message, + uint8_t *out); +size_t wifi_event_action_tx_status__pack_to_buffer + (const WifiEventActionTxStatus *message, + ProtobufCBuffer *buffer); +WifiEventActionTxStatus * + wifi_event_action_tx_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_action_tx_status__free_unpacked + (WifiEventActionTxStatus *message, + ProtobufCAllocator *allocator); +/* WifiEventRocDone methods */ +void wifi_event_roc_done__init + (WifiEventRocDone *message); +size_t wifi_event_roc_done__get_packed_size + (const WifiEventRocDone *message); +size_t wifi_event_roc_done__pack + (const WifiEventRocDone *message, + uint8_t *out); +size_t wifi_event_roc_done__pack_to_buffer + (const WifiEventRocDone *message, + ProtobufCBuffer *buffer); +WifiEventRocDone * + wifi_event_roc_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_roc_done__free_unpacked + (WifiEventRocDone *message, + ProtobufCAllocator *allocator); +/* WifiEventApWpsRgPin methods */ +void wifi_event_ap_wps_rg_pin__init + (WifiEventApWpsRgPin *message); +size_t wifi_event_ap_wps_rg_pin__get_packed_size + (const WifiEventApWpsRgPin *message); +size_t wifi_event_ap_wps_rg_pin__pack + (const WifiEventApWpsRgPin *message, + uint8_t *out); +size_t wifi_event_ap_wps_rg_pin__pack_to_buffer + (const WifiEventApWpsRgPin *message, + ProtobufCBuffer *buffer); +WifiEventApWpsRgPin * + wifi_event_ap_wps_rg_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_wps_rg_pin__free_unpacked + (WifiEventApWpsRgPin *message, + ProtobufCAllocator *allocator); +/* WifiEventApWpsRgFailReason methods */ +void wifi_event_ap_wps_rg_fail_reason__init + (WifiEventApWpsRgFailReason *message); +size_t wifi_event_ap_wps_rg_fail_reason__get_packed_size + (const WifiEventApWpsRgFailReason *message); +size_t wifi_event_ap_wps_rg_fail_reason__pack + (const WifiEventApWpsRgFailReason *message, + uint8_t *out); +size_t wifi_event_ap_wps_rg_fail_reason__pack_to_buffer + (const WifiEventApWpsRgFailReason *message, + ProtobufCBuffer *buffer); +WifiEventApWpsRgFailReason * + wifi_event_ap_wps_rg_fail_reason__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_wps_rg_fail_reason__free_unpacked + (WifiEventApWpsRgFailReason *message, + ProtobufCAllocator *allocator); +/* WifiEventApWpsRgSuccess methods */ +void wifi_event_ap_wps_rg_success__init + (WifiEventApWpsRgSuccess *message); +size_t wifi_event_ap_wps_rg_success__get_packed_size + (const WifiEventApWpsRgSuccess *message); +size_t wifi_event_ap_wps_rg_success__pack + (const WifiEventApWpsRgSuccess *message, + uint8_t *out); +size_t wifi_event_ap_wps_rg_success__pack_to_buffer + (const WifiEventApWpsRgSuccess *message, + ProtobufCBuffer *buffer); +WifiEventApWpsRgSuccess * + wifi_event_ap_wps_rg_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_wps_rg_success__free_unpacked + (WifiEventApWpsRgSuccess *message, + ProtobufCAllocator *allocator); +/* WifiProtocols methods */ +void wifi_protocols__init + (WifiProtocols *message); +size_t wifi_protocols__get_packed_size + (const WifiProtocols *message); +size_t wifi_protocols__pack + (const WifiProtocols *message, + uint8_t *out); +size_t wifi_protocols__pack_to_buffer + (const WifiProtocols *message, + ProtobufCBuffer *buffer); +WifiProtocols * + wifi_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_protocols__free_unpacked + (WifiProtocols *message, + ProtobufCAllocator *allocator); +/* WifiBandwidths methods */ +void wifi_bandwidths__init + (WifiBandwidths *message); +size_t wifi_bandwidths__get_packed_size + (const WifiBandwidths *message); +size_t wifi_bandwidths__pack + (const WifiBandwidths *message, + uint8_t *out); +size_t wifi_bandwidths__pack_to_buffer + (const WifiBandwidths *message, + ProtobufCBuffer *buffer); +WifiBandwidths * + wifi_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_bandwidths__free_unpacked + (WifiBandwidths *message, + ProtobufCAllocator *allocator); +/* ConnectedSTAList methods */ +void connected_stalist__init + (ConnectedSTAList *message); +size_t connected_stalist__get_packed_size + (const ConnectedSTAList *message); +size_t connected_stalist__pack + (const ConnectedSTAList *message, + uint8_t *out); +size_t connected_stalist__pack_to_buffer + (const ConnectedSTAList *message, + ProtobufCBuffer *buffer); +ConnectedSTAList * + connected_stalist__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void connected_stalist__free_unpacked + (ConnectedSTAList *message, + ProtobufCAllocator *allocator); +/* RpcReqGetMacAddress methods */ +void rpc__req__get_mac_address__init + (RpcReqGetMacAddress *message); +size_t rpc__req__get_mac_address__get_packed_size + (const RpcReqGetMacAddress *message); +size_t rpc__req__get_mac_address__pack + (const RpcReqGetMacAddress *message, + uint8_t *out); +size_t rpc__req__get_mac_address__pack_to_buffer + (const RpcReqGetMacAddress *message, + ProtobufCBuffer *buffer); +RpcReqGetMacAddress * + rpc__req__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_mac_address__free_unpacked + (RpcReqGetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcRespGetMacAddress methods */ +void rpc__resp__get_mac_address__init + (RpcRespGetMacAddress *message); +size_t rpc__resp__get_mac_address__get_packed_size + (const RpcRespGetMacAddress *message); +size_t rpc__resp__get_mac_address__pack + (const RpcRespGetMacAddress *message, + uint8_t *out); +size_t rpc__resp__get_mac_address__pack_to_buffer + (const RpcRespGetMacAddress *message, + ProtobufCBuffer *buffer); +RpcRespGetMacAddress * + rpc__resp__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_mac_address__free_unpacked + (RpcRespGetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcReqGetMode methods */ +void rpc__req__get_mode__init + (RpcReqGetMode *message); +size_t rpc__req__get_mode__get_packed_size + (const RpcReqGetMode *message); +size_t rpc__req__get_mode__pack + (const RpcReqGetMode *message, + uint8_t *out); +size_t rpc__req__get_mode__pack_to_buffer + (const RpcReqGetMode *message, + ProtobufCBuffer *buffer); +RpcReqGetMode * + rpc__req__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_mode__free_unpacked + (RpcReqGetMode *message, + ProtobufCAllocator *allocator); +/* RpcRespGetMode methods */ +void rpc__resp__get_mode__init + (RpcRespGetMode *message); +size_t rpc__resp__get_mode__get_packed_size + (const RpcRespGetMode *message); +size_t rpc__resp__get_mode__pack + (const RpcRespGetMode *message, + uint8_t *out); +size_t rpc__resp__get_mode__pack_to_buffer + (const RpcRespGetMode *message, + ProtobufCBuffer *buffer); +RpcRespGetMode * + rpc__resp__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_mode__free_unpacked + (RpcRespGetMode *message, + ProtobufCAllocator *allocator); +/* RpcReqSetMode methods */ +void rpc__req__set_mode__init + (RpcReqSetMode *message); +size_t rpc__req__set_mode__get_packed_size + (const RpcReqSetMode *message); +size_t rpc__req__set_mode__pack + (const RpcReqSetMode *message, + uint8_t *out); +size_t rpc__req__set_mode__pack_to_buffer + (const RpcReqSetMode *message, + ProtobufCBuffer *buffer); +RpcReqSetMode * + rpc__req__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_mode__free_unpacked + (RpcReqSetMode *message, + ProtobufCAllocator *allocator); +/* RpcRespSetMode methods */ +void rpc__resp__set_mode__init + (RpcRespSetMode *message); +size_t rpc__resp__set_mode__get_packed_size + (const RpcRespSetMode *message); +size_t rpc__resp__set_mode__pack + (const RpcRespSetMode *message, + uint8_t *out); +size_t rpc__resp__set_mode__pack_to_buffer + (const RpcRespSetMode *message, + ProtobufCBuffer *buffer); +RpcRespSetMode * + rpc__resp__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_mode__free_unpacked + (RpcRespSetMode *message, + ProtobufCAllocator *allocator); +/* RpcReqGetPs methods */ +void rpc__req__get_ps__init + (RpcReqGetPs *message); +size_t rpc__req__get_ps__get_packed_size + (const RpcReqGetPs *message); +size_t rpc__req__get_ps__pack + (const RpcReqGetPs *message, + uint8_t *out); +size_t rpc__req__get_ps__pack_to_buffer + (const RpcReqGetPs *message, + ProtobufCBuffer *buffer); +RpcReqGetPs * + rpc__req__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_ps__free_unpacked + (RpcReqGetPs *message, + ProtobufCAllocator *allocator); +/* RpcRespGetPs methods */ +void rpc__resp__get_ps__init + (RpcRespGetPs *message); +size_t rpc__resp__get_ps__get_packed_size + (const RpcRespGetPs *message); +size_t rpc__resp__get_ps__pack + (const RpcRespGetPs *message, + uint8_t *out); +size_t rpc__resp__get_ps__pack_to_buffer + (const RpcRespGetPs *message, + ProtobufCBuffer *buffer); +RpcRespGetPs * + rpc__resp__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_ps__free_unpacked + (RpcRespGetPs *message, + ProtobufCAllocator *allocator); +/* RpcReqSetPs methods */ +void rpc__req__set_ps__init + (RpcReqSetPs *message); +size_t rpc__req__set_ps__get_packed_size + (const RpcReqSetPs *message); +size_t rpc__req__set_ps__pack + (const RpcReqSetPs *message, + uint8_t *out); +size_t rpc__req__set_ps__pack_to_buffer + (const RpcReqSetPs *message, + ProtobufCBuffer *buffer); +RpcReqSetPs * + rpc__req__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_ps__free_unpacked + (RpcReqSetPs *message, + ProtobufCAllocator *allocator); +/* RpcRespSetPs methods */ +void rpc__resp__set_ps__init + (RpcRespSetPs *message); +size_t rpc__resp__set_ps__get_packed_size + (const RpcRespSetPs *message); +size_t rpc__resp__set_ps__pack + (const RpcRespSetPs *message, + uint8_t *out); +size_t rpc__resp__set_ps__pack_to_buffer + (const RpcRespSetPs *message, + ProtobufCBuffer *buffer); +RpcRespSetPs * + rpc__resp__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_ps__free_unpacked + (RpcRespSetPs *message, + ProtobufCAllocator *allocator); +/* RpcReqSetMacAddress methods */ +void rpc__req__set_mac_address__init + (RpcReqSetMacAddress *message); +size_t rpc__req__set_mac_address__get_packed_size + (const RpcReqSetMacAddress *message); +size_t rpc__req__set_mac_address__pack + (const RpcReqSetMacAddress *message, + uint8_t *out); +size_t rpc__req__set_mac_address__pack_to_buffer + (const RpcReqSetMacAddress *message, + ProtobufCBuffer *buffer); +RpcReqSetMacAddress * + rpc__req__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_mac_address__free_unpacked + (RpcReqSetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcRespSetMacAddress methods */ +void rpc__resp__set_mac_address__init + (RpcRespSetMacAddress *message); +size_t rpc__resp__set_mac_address__get_packed_size + (const RpcRespSetMacAddress *message); +size_t rpc__resp__set_mac_address__pack + (const RpcRespSetMacAddress *message, + uint8_t *out); +size_t rpc__resp__set_mac_address__pack_to_buffer + (const RpcRespSetMacAddress *message, + ProtobufCBuffer *buffer); +RpcRespSetMacAddress * + rpc__resp__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_mac_address__free_unpacked + (RpcRespSetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcReqOTABegin methods */ +void rpc__req__otabegin__init + (RpcReqOTABegin *message); +size_t rpc__req__otabegin__get_packed_size + (const RpcReqOTABegin *message); +size_t rpc__req__otabegin__pack + (const RpcReqOTABegin *message, + uint8_t *out); +size_t rpc__req__otabegin__pack_to_buffer + (const RpcReqOTABegin *message, + ProtobufCBuffer *buffer); +RpcReqOTABegin * + rpc__req__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__otabegin__free_unpacked + (RpcReqOTABegin *message, + ProtobufCAllocator *allocator); +/* RpcRespOTABegin methods */ +void rpc__resp__otabegin__init + (RpcRespOTABegin *message); +size_t rpc__resp__otabegin__get_packed_size + (const RpcRespOTABegin *message); +size_t rpc__resp__otabegin__pack + (const RpcRespOTABegin *message, + uint8_t *out); +size_t rpc__resp__otabegin__pack_to_buffer + (const RpcRespOTABegin *message, + ProtobufCBuffer *buffer); +RpcRespOTABegin * + rpc__resp__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__otabegin__free_unpacked + (RpcRespOTABegin *message, + ProtobufCAllocator *allocator); +/* RpcReqOTAWrite methods */ +void rpc__req__otawrite__init + (RpcReqOTAWrite *message); +size_t rpc__req__otawrite__get_packed_size + (const RpcReqOTAWrite *message); +size_t rpc__req__otawrite__pack + (const RpcReqOTAWrite *message, + uint8_t *out); +size_t rpc__req__otawrite__pack_to_buffer + (const RpcReqOTAWrite *message, + ProtobufCBuffer *buffer); +RpcReqOTAWrite * + rpc__req__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__otawrite__free_unpacked + (RpcReqOTAWrite *message, + ProtobufCAllocator *allocator); +/* RpcRespOTAWrite methods */ +void rpc__resp__otawrite__init + (RpcRespOTAWrite *message); +size_t rpc__resp__otawrite__get_packed_size + (const RpcRespOTAWrite *message); +size_t rpc__resp__otawrite__pack + (const RpcRespOTAWrite *message, + uint8_t *out); +size_t rpc__resp__otawrite__pack_to_buffer + (const RpcRespOTAWrite *message, + ProtobufCBuffer *buffer); +RpcRespOTAWrite * + rpc__resp__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__otawrite__free_unpacked + (RpcRespOTAWrite *message, + ProtobufCAllocator *allocator); +/* RpcReqOTAEnd methods */ +void rpc__req__otaend__init + (RpcReqOTAEnd *message); +size_t rpc__req__otaend__get_packed_size + (const RpcReqOTAEnd *message); +size_t rpc__req__otaend__pack + (const RpcReqOTAEnd *message, + uint8_t *out); +size_t rpc__req__otaend__pack_to_buffer + (const RpcReqOTAEnd *message, + ProtobufCBuffer *buffer); +RpcReqOTAEnd * + rpc__req__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__otaend__free_unpacked + (RpcReqOTAEnd *message, + ProtobufCAllocator *allocator); +/* RpcRespOTAEnd methods */ +void rpc__resp__otaend__init + (RpcRespOTAEnd *message); +size_t rpc__resp__otaend__get_packed_size + (const RpcRespOTAEnd *message); +size_t rpc__resp__otaend__pack + (const RpcRespOTAEnd *message, + uint8_t *out); +size_t rpc__resp__otaend__pack_to_buffer + (const RpcRespOTAEnd *message, + ProtobufCBuffer *buffer); +RpcRespOTAEnd * + rpc__resp__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__otaend__free_unpacked + (RpcRespOTAEnd *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetMaxTxPower methods */ +void rpc__req__wifi_set_max_tx_power__init + (RpcReqWifiSetMaxTxPower *message); +size_t rpc__req__wifi_set_max_tx_power__get_packed_size + (const RpcReqWifiSetMaxTxPower *message); +size_t rpc__req__wifi_set_max_tx_power__pack + (const RpcReqWifiSetMaxTxPower *message, + uint8_t *out); +size_t rpc__req__wifi_set_max_tx_power__pack_to_buffer + (const RpcReqWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetMaxTxPower * + rpc__req__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_max_tx_power__free_unpacked + (RpcReqWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetMaxTxPower methods */ +void rpc__resp__wifi_set_max_tx_power__init + (RpcRespWifiSetMaxTxPower *message); +size_t rpc__resp__wifi_set_max_tx_power__get_packed_size + (const RpcRespWifiSetMaxTxPower *message); +size_t rpc__resp__wifi_set_max_tx_power__pack + (const RpcRespWifiSetMaxTxPower *message, + uint8_t *out); +size_t rpc__resp__wifi_set_max_tx_power__pack_to_buffer + (const RpcRespWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetMaxTxPower * + rpc__resp__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_max_tx_power__free_unpacked + (RpcRespWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetMaxTxPower methods */ +void rpc__req__wifi_get_max_tx_power__init + (RpcReqWifiGetMaxTxPower *message); +size_t rpc__req__wifi_get_max_tx_power__get_packed_size + (const RpcReqWifiGetMaxTxPower *message); +size_t rpc__req__wifi_get_max_tx_power__pack + (const RpcReqWifiGetMaxTxPower *message, + uint8_t *out); +size_t rpc__req__wifi_get_max_tx_power__pack_to_buffer + (const RpcReqWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetMaxTxPower * + rpc__req__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_max_tx_power__free_unpacked + (RpcReqWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetMaxTxPower methods */ +void rpc__resp__wifi_get_max_tx_power__init + (RpcRespWifiGetMaxTxPower *message); +size_t rpc__resp__wifi_get_max_tx_power__get_packed_size + (const RpcRespWifiGetMaxTxPower *message); +size_t rpc__resp__wifi_get_max_tx_power__pack + (const RpcRespWifiGetMaxTxPower *message, + uint8_t *out); +size_t rpc__resp__wifi_get_max_tx_power__pack_to_buffer + (const RpcRespWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetMaxTxPower * + rpc__resp__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_max_tx_power__free_unpacked + (RpcRespWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcReqConfigHeartbeat methods */ +void rpc__req__config_heartbeat__init + (RpcReqConfigHeartbeat *message); +size_t rpc__req__config_heartbeat__get_packed_size + (const RpcReqConfigHeartbeat *message); +size_t rpc__req__config_heartbeat__pack + (const RpcReqConfigHeartbeat *message, + uint8_t *out); +size_t rpc__req__config_heartbeat__pack_to_buffer + (const RpcReqConfigHeartbeat *message, + ProtobufCBuffer *buffer); +RpcReqConfigHeartbeat * + rpc__req__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__config_heartbeat__free_unpacked + (RpcReqConfigHeartbeat *message, + ProtobufCAllocator *allocator); +/* RpcRespConfigHeartbeat methods */ +void rpc__resp__config_heartbeat__init + (RpcRespConfigHeartbeat *message); +size_t rpc__resp__config_heartbeat__get_packed_size + (const RpcRespConfigHeartbeat *message); +size_t rpc__resp__config_heartbeat__pack + (const RpcRespConfigHeartbeat *message, + uint8_t *out); +size_t rpc__resp__config_heartbeat__pack_to_buffer + (const RpcRespConfigHeartbeat *message, + ProtobufCBuffer *buffer); +RpcRespConfigHeartbeat * + rpc__resp__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__config_heartbeat__free_unpacked + (RpcRespConfigHeartbeat *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiInit methods */ +void rpc__req__wifi_init__init + (RpcReqWifiInit *message); +size_t rpc__req__wifi_init__get_packed_size + (const RpcReqWifiInit *message); +size_t rpc__req__wifi_init__pack + (const RpcReqWifiInit *message, + uint8_t *out); +size_t rpc__req__wifi_init__pack_to_buffer + (const RpcReqWifiInit *message, + ProtobufCBuffer *buffer); +RpcReqWifiInit * + rpc__req__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_init__free_unpacked + (RpcReqWifiInit *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiInit methods */ +void rpc__resp__wifi_init__init + (RpcRespWifiInit *message); +size_t rpc__resp__wifi_init__get_packed_size + (const RpcRespWifiInit *message); +size_t rpc__resp__wifi_init__pack + (const RpcRespWifiInit *message, + uint8_t *out); +size_t rpc__resp__wifi_init__pack_to_buffer + (const RpcRespWifiInit *message, + ProtobufCBuffer *buffer); +RpcRespWifiInit * + rpc__resp__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_init__free_unpacked + (RpcRespWifiInit *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiDeinit methods */ +void rpc__req__wifi_deinit__init + (RpcReqWifiDeinit *message); +size_t rpc__req__wifi_deinit__get_packed_size + (const RpcReqWifiDeinit *message); +size_t rpc__req__wifi_deinit__pack + (const RpcReqWifiDeinit *message, + uint8_t *out); +size_t rpc__req__wifi_deinit__pack_to_buffer + (const RpcReqWifiDeinit *message, + ProtobufCBuffer *buffer); +RpcReqWifiDeinit * + rpc__req__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_deinit__free_unpacked + (RpcReqWifiDeinit *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiDeinit methods */ +void rpc__resp__wifi_deinit__init + (RpcRespWifiDeinit *message); +size_t rpc__resp__wifi_deinit__get_packed_size + (const RpcRespWifiDeinit *message); +size_t rpc__resp__wifi_deinit__pack + (const RpcRespWifiDeinit *message, + uint8_t *out); +size_t rpc__resp__wifi_deinit__pack_to_buffer + (const RpcRespWifiDeinit *message, + ProtobufCBuffer *buffer); +RpcRespWifiDeinit * + rpc__resp__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_deinit__free_unpacked + (RpcRespWifiDeinit *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetConfig methods */ +void rpc__req__wifi_set_config__init + (RpcReqWifiSetConfig *message); +size_t rpc__req__wifi_set_config__get_packed_size + (const RpcReqWifiSetConfig *message); +size_t rpc__req__wifi_set_config__pack + (const RpcReqWifiSetConfig *message, + uint8_t *out); +size_t rpc__req__wifi_set_config__pack_to_buffer + (const RpcReqWifiSetConfig *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetConfig * + rpc__req__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_config__free_unpacked + (RpcReqWifiSetConfig *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetConfig methods */ +void rpc__resp__wifi_set_config__init + (RpcRespWifiSetConfig *message); +size_t rpc__resp__wifi_set_config__get_packed_size + (const RpcRespWifiSetConfig *message); +size_t rpc__resp__wifi_set_config__pack + (const RpcRespWifiSetConfig *message, + uint8_t *out); +size_t rpc__resp__wifi_set_config__pack_to_buffer + (const RpcRespWifiSetConfig *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetConfig * + rpc__resp__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_config__free_unpacked + (RpcRespWifiSetConfig *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetConfig methods */ +void rpc__req__wifi_get_config__init + (RpcReqWifiGetConfig *message); +size_t rpc__req__wifi_get_config__get_packed_size + (const RpcReqWifiGetConfig *message); +size_t rpc__req__wifi_get_config__pack + (const RpcReqWifiGetConfig *message, + uint8_t *out); +size_t rpc__req__wifi_get_config__pack_to_buffer + (const RpcReqWifiGetConfig *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetConfig * + rpc__req__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_config__free_unpacked + (RpcReqWifiGetConfig *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetConfig methods */ +void rpc__resp__wifi_get_config__init + (RpcRespWifiGetConfig *message); +size_t rpc__resp__wifi_get_config__get_packed_size + (const RpcRespWifiGetConfig *message); +size_t rpc__resp__wifi_get_config__pack + (const RpcRespWifiGetConfig *message, + uint8_t *out); +size_t rpc__resp__wifi_get_config__pack_to_buffer + (const RpcRespWifiGetConfig *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetConfig * + rpc__resp__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_config__free_unpacked + (RpcRespWifiGetConfig *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiConnect methods */ +void rpc__req__wifi_connect__init + (RpcReqWifiConnect *message); +size_t rpc__req__wifi_connect__get_packed_size + (const RpcReqWifiConnect *message); +size_t rpc__req__wifi_connect__pack + (const RpcReqWifiConnect *message, + uint8_t *out); +size_t rpc__req__wifi_connect__pack_to_buffer + (const RpcReqWifiConnect *message, + ProtobufCBuffer *buffer); +RpcReqWifiConnect * + rpc__req__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_connect__free_unpacked + (RpcReqWifiConnect *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiConnect methods */ +void rpc__resp__wifi_connect__init + (RpcRespWifiConnect *message); +size_t rpc__resp__wifi_connect__get_packed_size + (const RpcRespWifiConnect *message); +size_t rpc__resp__wifi_connect__pack + (const RpcRespWifiConnect *message, + uint8_t *out); +size_t rpc__resp__wifi_connect__pack_to_buffer + (const RpcRespWifiConnect *message, + ProtobufCBuffer *buffer); +RpcRespWifiConnect * + rpc__resp__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_connect__free_unpacked + (RpcRespWifiConnect *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiDisconnect methods */ +void rpc__req__wifi_disconnect__init + (RpcReqWifiDisconnect *message); +size_t rpc__req__wifi_disconnect__get_packed_size + (const RpcReqWifiDisconnect *message); +size_t rpc__req__wifi_disconnect__pack + (const RpcReqWifiDisconnect *message, + uint8_t *out); +size_t rpc__req__wifi_disconnect__pack_to_buffer + (const RpcReqWifiDisconnect *message, + ProtobufCBuffer *buffer); +RpcReqWifiDisconnect * + rpc__req__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_disconnect__free_unpacked + (RpcReqWifiDisconnect *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiDisconnect methods */ +void rpc__resp__wifi_disconnect__init + (RpcRespWifiDisconnect *message); +size_t rpc__resp__wifi_disconnect__get_packed_size + (const RpcRespWifiDisconnect *message); +size_t rpc__resp__wifi_disconnect__pack + (const RpcRespWifiDisconnect *message, + uint8_t *out); +size_t rpc__resp__wifi_disconnect__pack_to_buffer + (const RpcRespWifiDisconnect *message, + ProtobufCBuffer *buffer); +RpcRespWifiDisconnect * + rpc__resp__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_disconnect__free_unpacked + (RpcRespWifiDisconnect *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStart methods */ +void rpc__req__wifi_start__init + (RpcReqWifiStart *message); +size_t rpc__req__wifi_start__get_packed_size + (const RpcReqWifiStart *message); +size_t rpc__req__wifi_start__pack + (const RpcReqWifiStart *message, + uint8_t *out); +size_t rpc__req__wifi_start__pack_to_buffer + (const RpcReqWifiStart *message, + ProtobufCBuffer *buffer); +RpcReqWifiStart * + rpc__req__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_start__free_unpacked + (RpcReqWifiStart *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStart methods */ +void rpc__resp__wifi_start__init + (RpcRespWifiStart *message); +size_t rpc__resp__wifi_start__get_packed_size + (const RpcRespWifiStart *message); +size_t rpc__resp__wifi_start__pack + (const RpcRespWifiStart *message, + uint8_t *out); +size_t rpc__resp__wifi_start__pack_to_buffer + (const RpcRespWifiStart *message, + ProtobufCBuffer *buffer); +RpcRespWifiStart * + rpc__resp__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_start__free_unpacked + (RpcRespWifiStart *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStop methods */ +void rpc__req__wifi_stop__init + (RpcReqWifiStop *message); +size_t rpc__req__wifi_stop__get_packed_size + (const RpcReqWifiStop *message); +size_t rpc__req__wifi_stop__pack + (const RpcReqWifiStop *message, + uint8_t *out); +size_t rpc__req__wifi_stop__pack_to_buffer + (const RpcReqWifiStop *message, + ProtobufCBuffer *buffer); +RpcReqWifiStop * + rpc__req__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_stop__free_unpacked + (RpcReqWifiStop *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStop methods */ +void rpc__resp__wifi_stop__init + (RpcRespWifiStop *message); +size_t rpc__resp__wifi_stop__get_packed_size + (const RpcRespWifiStop *message); +size_t rpc__resp__wifi_stop__pack + (const RpcRespWifiStop *message, + uint8_t *out); +size_t rpc__resp__wifi_stop__pack_to_buffer + (const RpcRespWifiStop *message, + ProtobufCBuffer *buffer); +RpcRespWifiStop * + rpc__resp__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_stop__free_unpacked + (RpcRespWifiStop *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanStart methods */ +void rpc__req__wifi_scan_start__init + (RpcReqWifiScanStart *message); +size_t rpc__req__wifi_scan_start__get_packed_size + (const RpcReqWifiScanStart *message); +size_t rpc__req__wifi_scan_start__pack + (const RpcReqWifiScanStart *message, + uint8_t *out); +size_t rpc__req__wifi_scan_start__pack_to_buffer + (const RpcReqWifiScanStart *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanStart * + rpc__req__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_start__free_unpacked + (RpcReqWifiScanStart *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanStart methods */ +void rpc__resp__wifi_scan_start__init + (RpcRespWifiScanStart *message); +size_t rpc__resp__wifi_scan_start__get_packed_size + (const RpcRespWifiScanStart *message); +size_t rpc__resp__wifi_scan_start__pack + (const RpcRespWifiScanStart *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_start__pack_to_buffer + (const RpcRespWifiScanStart *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanStart * + rpc__resp__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_start__free_unpacked + (RpcRespWifiScanStart *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanStop methods */ +void rpc__req__wifi_scan_stop__init + (RpcReqWifiScanStop *message); +size_t rpc__req__wifi_scan_stop__get_packed_size + (const RpcReqWifiScanStop *message); +size_t rpc__req__wifi_scan_stop__pack + (const RpcReqWifiScanStop *message, + uint8_t *out); +size_t rpc__req__wifi_scan_stop__pack_to_buffer + (const RpcReqWifiScanStop *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanStop * + rpc__req__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_stop__free_unpacked + (RpcReqWifiScanStop *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanStop methods */ +void rpc__resp__wifi_scan_stop__init + (RpcRespWifiScanStop *message); +size_t rpc__resp__wifi_scan_stop__get_packed_size + (const RpcRespWifiScanStop *message); +size_t rpc__resp__wifi_scan_stop__pack + (const RpcRespWifiScanStop *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_stop__pack_to_buffer + (const RpcRespWifiScanStop *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanStop * + rpc__resp__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_stop__free_unpacked + (RpcRespWifiScanStop *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanGetApNum methods */ +void rpc__req__wifi_scan_get_ap_num__init + (RpcReqWifiScanGetApNum *message); +size_t rpc__req__wifi_scan_get_ap_num__get_packed_size + (const RpcReqWifiScanGetApNum *message); +size_t rpc__req__wifi_scan_get_ap_num__pack + (const RpcReqWifiScanGetApNum *message, + uint8_t *out); +size_t rpc__req__wifi_scan_get_ap_num__pack_to_buffer + (const RpcReqWifiScanGetApNum *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanGetApNum * + rpc__req__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_get_ap_num__free_unpacked + (RpcReqWifiScanGetApNum *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanGetApNum methods */ +void rpc__resp__wifi_scan_get_ap_num__init + (RpcRespWifiScanGetApNum *message); +size_t rpc__resp__wifi_scan_get_ap_num__get_packed_size + (const RpcRespWifiScanGetApNum *message); +size_t rpc__resp__wifi_scan_get_ap_num__pack + (const RpcRespWifiScanGetApNum *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_get_ap_num__pack_to_buffer + (const RpcRespWifiScanGetApNum *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanGetApNum * + rpc__resp__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_get_ap_num__free_unpacked + (RpcRespWifiScanGetApNum *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanGetApRecords methods */ +void rpc__req__wifi_scan_get_ap_records__init + (RpcReqWifiScanGetApRecords *message); +size_t rpc__req__wifi_scan_get_ap_records__get_packed_size + (const RpcReqWifiScanGetApRecords *message); +size_t rpc__req__wifi_scan_get_ap_records__pack + (const RpcReqWifiScanGetApRecords *message, + uint8_t *out); +size_t rpc__req__wifi_scan_get_ap_records__pack_to_buffer + (const RpcReqWifiScanGetApRecords *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanGetApRecords * + rpc__req__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_get_ap_records__free_unpacked + (RpcReqWifiScanGetApRecords *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanGetApRecords methods */ +void rpc__resp__wifi_scan_get_ap_records__init + (RpcRespWifiScanGetApRecords *message); +size_t rpc__resp__wifi_scan_get_ap_records__get_packed_size + (const RpcRespWifiScanGetApRecords *message); +size_t rpc__resp__wifi_scan_get_ap_records__pack + (const RpcRespWifiScanGetApRecords *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_get_ap_records__pack_to_buffer + (const RpcRespWifiScanGetApRecords *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanGetApRecords * + rpc__resp__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_get_ap_records__free_unpacked + (RpcRespWifiScanGetApRecords *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanGetApRecord methods */ +void rpc__req__wifi_scan_get_ap_record__init + (RpcReqWifiScanGetApRecord *message); +size_t rpc__req__wifi_scan_get_ap_record__get_packed_size + (const RpcReqWifiScanGetApRecord *message); +size_t rpc__req__wifi_scan_get_ap_record__pack + (const RpcReqWifiScanGetApRecord *message, + uint8_t *out); +size_t rpc__req__wifi_scan_get_ap_record__pack_to_buffer + (const RpcReqWifiScanGetApRecord *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanGetApRecord * + rpc__req__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_get_ap_record__free_unpacked + (RpcReqWifiScanGetApRecord *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanGetApRecord methods */ +void rpc__resp__wifi_scan_get_ap_record__init + (RpcRespWifiScanGetApRecord *message); +size_t rpc__resp__wifi_scan_get_ap_record__get_packed_size + (const RpcRespWifiScanGetApRecord *message); +size_t rpc__resp__wifi_scan_get_ap_record__pack + (const RpcRespWifiScanGetApRecord *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_get_ap_record__pack_to_buffer + (const RpcRespWifiScanGetApRecord *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanGetApRecord * + rpc__resp__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_get_ap_record__free_unpacked + (RpcRespWifiScanGetApRecord *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiClearApList methods */ +void rpc__req__wifi_clear_ap_list__init + (RpcReqWifiClearApList *message); +size_t rpc__req__wifi_clear_ap_list__get_packed_size + (const RpcReqWifiClearApList *message); +size_t rpc__req__wifi_clear_ap_list__pack + (const RpcReqWifiClearApList *message, + uint8_t *out); +size_t rpc__req__wifi_clear_ap_list__pack_to_buffer + (const RpcReqWifiClearApList *message, + ProtobufCBuffer *buffer); +RpcReqWifiClearApList * + rpc__req__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_clear_ap_list__free_unpacked + (RpcReqWifiClearApList *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiClearApList methods */ +void rpc__resp__wifi_clear_ap_list__init + (RpcRespWifiClearApList *message); +size_t rpc__resp__wifi_clear_ap_list__get_packed_size + (const RpcRespWifiClearApList *message); +size_t rpc__resp__wifi_clear_ap_list__pack + (const RpcRespWifiClearApList *message, + uint8_t *out); +size_t rpc__resp__wifi_clear_ap_list__pack_to_buffer + (const RpcRespWifiClearApList *message, + ProtobufCBuffer *buffer); +RpcRespWifiClearApList * + rpc__resp__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_clear_ap_list__free_unpacked + (RpcRespWifiClearApList *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiRestore methods */ +void rpc__req__wifi_restore__init + (RpcReqWifiRestore *message); +size_t rpc__req__wifi_restore__get_packed_size + (const RpcReqWifiRestore *message); +size_t rpc__req__wifi_restore__pack + (const RpcReqWifiRestore *message, + uint8_t *out); +size_t rpc__req__wifi_restore__pack_to_buffer + (const RpcReqWifiRestore *message, + ProtobufCBuffer *buffer); +RpcReqWifiRestore * + rpc__req__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_restore__free_unpacked + (RpcReqWifiRestore *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiRestore methods */ +void rpc__resp__wifi_restore__init + (RpcRespWifiRestore *message); +size_t rpc__resp__wifi_restore__get_packed_size + (const RpcRespWifiRestore *message); +size_t rpc__resp__wifi_restore__pack + (const RpcRespWifiRestore *message, + uint8_t *out); +size_t rpc__resp__wifi_restore__pack_to_buffer + (const RpcRespWifiRestore *message, + ProtobufCBuffer *buffer); +RpcRespWifiRestore * + rpc__resp__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_restore__free_unpacked + (RpcRespWifiRestore *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiClearFastConnect methods */ +void rpc__req__wifi_clear_fast_connect__init + (RpcReqWifiClearFastConnect *message); +size_t rpc__req__wifi_clear_fast_connect__get_packed_size + (const RpcReqWifiClearFastConnect *message); +size_t rpc__req__wifi_clear_fast_connect__pack + (const RpcReqWifiClearFastConnect *message, + uint8_t *out); +size_t rpc__req__wifi_clear_fast_connect__pack_to_buffer + (const RpcReqWifiClearFastConnect *message, + ProtobufCBuffer *buffer); +RpcReqWifiClearFastConnect * + rpc__req__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_clear_fast_connect__free_unpacked + (RpcReqWifiClearFastConnect *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiClearFastConnect methods */ +void rpc__resp__wifi_clear_fast_connect__init + (RpcRespWifiClearFastConnect *message); +size_t rpc__resp__wifi_clear_fast_connect__get_packed_size + (const RpcRespWifiClearFastConnect *message); +size_t rpc__resp__wifi_clear_fast_connect__pack + (const RpcRespWifiClearFastConnect *message, + uint8_t *out); +size_t rpc__resp__wifi_clear_fast_connect__pack_to_buffer + (const RpcRespWifiClearFastConnect *message, + ProtobufCBuffer *buffer); +RpcRespWifiClearFastConnect * + rpc__resp__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_clear_fast_connect__free_unpacked + (RpcRespWifiClearFastConnect *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiDeauthSta methods */ +void rpc__req__wifi_deauth_sta__init + (RpcReqWifiDeauthSta *message); +size_t rpc__req__wifi_deauth_sta__get_packed_size + (const RpcReqWifiDeauthSta *message); +size_t rpc__req__wifi_deauth_sta__pack + (const RpcReqWifiDeauthSta *message, + uint8_t *out); +size_t rpc__req__wifi_deauth_sta__pack_to_buffer + (const RpcReqWifiDeauthSta *message, + ProtobufCBuffer *buffer); +RpcReqWifiDeauthSta * + rpc__req__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_deauth_sta__free_unpacked + (RpcReqWifiDeauthSta *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiDeauthSta methods */ +void rpc__resp__wifi_deauth_sta__init + (RpcRespWifiDeauthSta *message); +size_t rpc__resp__wifi_deauth_sta__get_packed_size + (const RpcRespWifiDeauthSta *message); +size_t rpc__resp__wifi_deauth_sta__pack + (const RpcRespWifiDeauthSta *message, + uint8_t *out); +size_t rpc__resp__wifi_deauth_sta__pack_to_buffer + (const RpcRespWifiDeauthSta *message, + ProtobufCBuffer *buffer); +RpcRespWifiDeauthSta * + rpc__resp__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_deauth_sta__free_unpacked + (RpcRespWifiDeauthSta *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetApInfo methods */ +void rpc__req__wifi_sta_get_ap_info__init + (RpcReqWifiStaGetApInfo *message); +size_t rpc__req__wifi_sta_get_ap_info__get_packed_size + (const RpcReqWifiStaGetApInfo *message); +size_t rpc__req__wifi_sta_get_ap_info__pack + (const RpcReqWifiStaGetApInfo *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_ap_info__pack_to_buffer + (const RpcReqWifiStaGetApInfo *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetApInfo * + rpc__req__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_ap_info__free_unpacked + (RpcReqWifiStaGetApInfo *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetApInfo methods */ +void rpc__resp__wifi_sta_get_ap_info__init + (RpcRespWifiStaGetApInfo *message); +size_t rpc__resp__wifi_sta_get_ap_info__get_packed_size + (const RpcRespWifiStaGetApInfo *message); +size_t rpc__resp__wifi_sta_get_ap_info__pack + (const RpcRespWifiStaGetApInfo *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_ap_info__pack_to_buffer + (const RpcRespWifiStaGetApInfo *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetApInfo * + rpc__resp__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_ap_info__free_unpacked + (RpcRespWifiStaGetApInfo *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetProtocol methods */ +void rpc__req__wifi_set_protocol__init + (RpcReqWifiSetProtocol *message); +size_t rpc__req__wifi_set_protocol__get_packed_size + (const RpcReqWifiSetProtocol *message); +size_t rpc__req__wifi_set_protocol__pack + (const RpcReqWifiSetProtocol *message, + uint8_t *out); +size_t rpc__req__wifi_set_protocol__pack_to_buffer + (const RpcReqWifiSetProtocol *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetProtocol * + rpc__req__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_protocol__free_unpacked + (RpcReqWifiSetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetProtocol methods */ +void rpc__resp__wifi_set_protocol__init + (RpcRespWifiSetProtocol *message); +size_t rpc__resp__wifi_set_protocol__get_packed_size + (const RpcRespWifiSetProtocol *message); +size_t rpc__resp__wifi_set_protocol__pack + (const RpcRespWifiSetProtocol *message, + uint8_t *out); +size_t rpc__resp__wifi_set_protocol__pack_to_buffer + (const RpcRespWifiSetProtocol *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetProtocol * + rpc__resp__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_protocol__free_unpacked + (RpcRespWifiSetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetProtocol methods */ +void rpc__req__wifi_get_protocol__init + (RpcReqWifiGetProtocol *message); +size_t rpc__req__wifi_get_protocol__get_packed_size + (const RpcReqWifiGetProtocol *message); +size_t rpc__req__wifi_get_protocol__pack + (const RpcReqWifiGetProtocol *message, + uint8_t *out); +size_t rpc__req__wifi_get_protocol__pack_to_buffer + (const RpcReqWifiGetProtocol *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetProtocol * + rpc__req__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_protocol__free_unpacked + (RpcReqWifiGetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetProtocol methods */ +void rpc__resp__wifi_get_protocol__init + (RpcRespWifiGetProtocol *message); +size_t rpc__resp__wifi_get_protocol__get_packed_size + (const RpcRespWifiGetProtocol *message); +size_t rpc__resp__wifi_get_protocol__pack + (const RpcRespWifiGetProtocol *message, + uint8_t *out); +size_t rpc__resp__wifi_get_protocol__pack_to_buffer + (const RpcRespWifiGetProtocol *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetProtocol * + rpc__resp__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_protocol__free_unpacked + (RpcRespWifiGetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBandwidth methods */ +void rpc__req__wifi_set_bandwidth__init + (RpcReqWifiSetBandwidth *message); +size_t rpc__req__wifi_set_bandwidth__get_packed_size + (const RpcReqWifiSetBandwidth *message); +size_t rpc__req__wifi_set_bandwidth__pack + (const RpcReqWifiSetBandwidth *message, + uint8_t *out); +size_t rpc__req__wifi_set_bandwidth__pack_to_buffer + (const RpcReqWifiSetBandwidth *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBandwidth * + rpc__req__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_bandwidth__free_unpacked + (RpcReqWifiSetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBandwidth methods */ +void rpc__resp__wifi_set_bandwidth__init + (RpcRespWifiSetBandwidth *message); +size_t rpc__resp__wifi_set_bandwidth__get_packed_size + (const RpcRespWifiSetBandwidth *message); +size_t rpc__resp__wifi_set_bandwidth__pack + (const RpcRespWifiSetBandwidth *message, + uint8_t *out); +size_t rpc__resp__wifi_set_bandwidth__pack_to_buffer + (const RpcRespWifiSetBandwidth *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBandwidth * + rpc__resp__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_bandwidth__free_unpacked + (RpcRespWifiSetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBandwidth methods */ +void rpc__req__wifi_get_bandwidth__init + (RpcReqWifiGetBandwidth *message); +size_t rpc__req__wifi_get_bandwidth__get_packed_size + (const RpcReqWifiGetBandwidth *message); +size_t rpc__req__wifi_get_bandwidth__pack + (const RpcReqWifiGetBandwidth *message, + uint8_t *out); +size_t rpc__req__wifi_get_bandwidth__pack_to_buffer + (const RpcReqWifiGetBandwidth *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBandwidth * + rpc__req__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_bandwidth__free_unpacked + (RpcReqWifiGetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBandwidth methods */ +void rpc__resp__wifi_get_bandwidth__init + (RpcRespWifiGetBandwidth *message); +size_t rpc__resp__wifi_get_bandwidth__get_packed_size + (const RpcRespWifiGetBandwidth *message); +size_t rpc__resp__wifi_get_bandwidth__pack + (const RpcRespWifiGetBandwidth *message, + uint8_t *out); +size_t rpc__resp__wifi_get_bandwidth__pack_to_buffer + (const RpcRespWifiGetBandwidth *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBandwidth * + rpc__resp__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_bandwidth__free_unpacked + (RpcRespWifiGetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetChannel methods */ +void rpc__req__wifi_set_channel__init + (RpcReqWifiSetChannel *message); +size_t rpc__req__wifi_set_channel__get_packed_size + (const RpcReqWifiSetChannel *message); +size_t rpc__req__wifi_set_channel__pack + (const RpcReqWifiSetChannel *message, + uint8_t *out); +size_t rpc__req__wifi_set_channel__pack_to_buffer + (const RpcReqWifiSetChannel *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetChannel * + rpc__req__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_channel__free_unpacked + (RpcReqWifiSetChannel *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetChannel methods */ +void rpc__resp__wifi_set_channel__init + (RpcRespWifiSetChannel *message); +size_t rpc__resp__wifi_set_channel__get_packed_size + (const RpcRespWifiSetChannel *message); +size_t rpc__resp__wifi_set_channel__pack + (const RpcRespWifiSetChannel *message, + uint8_t *out); +size_t rpc__resp__wifi_set_channel__pack_to_buffer + (const RpcRespWifiSetChannel *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetChannel * + rpc__resp__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_channel__free_unpacked + (RpcRespWifiSetChannel *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetChannel methods */ +void rpc__req__wifi_get_channel__init + (RpcReqWifiGetChannel *message); +size_t rpc__req__wifi_get_channel__get_packed_size + (const RpcReqWifiGetChannel *message); +size_t rpc__req__wifi_get_channel__pack + (const RpcReqWifiGetChannel *message, + uint8_t *out); +size_t rpc__req__wifi_get_channel__pack_to_buffer + (const RpcReqWifiGetChannel *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetChannel * + rpc__req__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_channel__free_unpacked + (RpcReqWifiGetChannel *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetChannel methods */ +void rpc__resp__wifi_get_channel__init + (RpcRespWifiGetChannel *message); +size_t rpc__resp__wifi_get_channel__get_packed_size + (const RpcRespWifiGetChannel *message); +size_t rpc__resp__wifi_get_channel__pack + (const RpcRespWifiGetChannel *message, + uint8_t *out); +size_t rpc__resp__wifi_get_channel__pack_to_buffer + (const RpcRespWifiGetChannel *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetChannel * + rpc__resp__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_channel__free_unpacked + (RpcRespWifiGetChannel *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetStorage methods */ +void rpc__req__wifi_set_storage__init + (RpcReqWifiSetStorage *message); +size_t rpc__req__wifi_set_storage__get_packed_size + (const RpcReqWifiSetStorage *message); +size_t rpc__req__wifi_set_storage__pack + (const RpcReqWifiSetStorage *message, + uint8_t *out); +size_t rpc__req__wifi_set_storage__pack_to_buffer + (const RpcReqWifiSetStorage *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetStorage * + rpc__req__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_storage__free_unpacked + (RpcReqWifiSetStorage *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetStorage methods */ +void rpc__resp__wifi_set_storage__init + (RpcRespWifiSetStorage *message); +size_t rpc__resp__wifi_set_storage__get_packed_size + (const RpcRespWifiSetStorage *message); +size_t rpc__resp__wifi_set_storage__pack + (const RpcRespWifiSetStorage *message, + uint8_t *out); +size_t rpc__resp__wifi_set_storage__pack_to_buffer + (const RpcRespWifiSetStorage *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetStorage * + rpc__resp__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_storage__free_unpacked + (RpcRespWifiSetStorage *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetCountryCode methods */ +void rpc__req__wifi_set_country_code__init + (RpcReqWifiSetCountryCode *message); +size_t rpc__req__wifi_set_country_code__get_packed_size + (const RpcReqWifiSetCountryCode *message); +size_t rpc__req__wifi_set_country_code__pack + (const RpcReqWifiSetCountryCode *message, + uint8_t *out); +size_t rpc__req__wifi_set_country_code__pack_to_buffer + (const RpcReqWifiSetCountryCode *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetCountryCode * + rpc__req__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_country_code__free_unpacked + (RpcReqWifiSetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetCountryCode methods */ +void rpc__resp__wifi_set_country_code__init + (RpcRespWifiSetCountryCode *message); +size_t rpc__resp__wifi_set_country_code__get_packed_size + (const RpcRespWifiSetCountryCode *message); +size_t rpc__resp__wifi_set_country_code__pack + (const RpcRespWifiSetCountryCode *message, + uint8_t *out); +size_t rpc__resp__wifi_set_country_code__pack_to_buffer + (const RpcRespWifiSetCountryCode *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetCountryCode * + rpc__resp__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_country_code__free_unpacked + (RpcRespWifiSetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetCountryCode methods */ +void rpc__req__wifi_get_country_code__init + (RpcReqWifiGetCountryCode *message); +size_t rpc__req__wifi_get_country_code__get_packed_size + (const RpcReqWifiGetCountryCode *message); +size_t rpc__req__wifi_get_country_code__pack + (const RpcReqWifiGetCountryCode *message, + uint8_t *out); +size_t rpc__req__wifi_get_country_code__pack_to_buffer + (const RpcReqWifiGetCountryCode *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetCountryCode * + rpc__req__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_country_code__free_unpacked + (RpcReqWifiGetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetCountryCode methods */ +void rpc__resp__wifi_get_country_code__init + (RpcRespWifiGetCountryCode *message); +size_t rpc__resp__wifi_get_country_code__get_packed_size + (const RpcRespWifiGetCountryCode *message); +size_t rpc__resp__wifi_get_country_code__pack + (const RpcRespWifiGetCountryCode *message, + uint8_t *out); +size_t rpc__resp__wifi_get_country_code__pack_to_buffer + (const RpcRespWifiGetCountryCode *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetCountryCode * + rpc__resp__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_country_code__free_unpacked + (RpcRespWifiGetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetCountry methods */ +void rpc__req__wifi_set_country__init + (RpcReqWifiSetCountry *message); +size_t rpc__req__wifi_set_country__get_packed_size + (const RpcReqWifiSetCountry *message); +size_t rpc__req__wifi_set_country__pack + (const RpcReqWifiSetCountry *message, + uint8_t *out); +size_t rpc__req__wifi_set_country__pack_to_buffer + (const RpcReqWifiSetCountry *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetCountry * + rpc__req__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_country__free_unpacked + (RpcReqWifiSetCountry *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetCountry methods */ +void rpc__resp__wifi_set_country__init + (RpcRespWifiSetCountry *message); +size_t rpc__resp__wifi_set_country__get_packed_size + (const RpcRespWifiSetCountry *message); +size_t rpc__resp__wifi_set_country__pack + (const RpcRespWifiSetCountry *message, + uint8_t *out); +size_t rpc__resp__wifi_set_country__pack_to_buffer + (const RpcRespWifiSetCountry *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetCountry * + rpc__resp__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_country__free_unpacked + (RpcRespWifiSetCountry *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetCountry methods */ +void rpc__req__wifi_get_country__init + (RpcReqWifiGetCountry *message); +size_t rpc__req__wifi_get_country__get_packed_size + (const RpcReqWifiGetCountry *message); +size_t rpc__req__wifi_get_country__pack + (const RpcReqWifiGetCountry *message, + uint8_t *out); +size_t rpc__req__wifi_get_country__pack_to_buffer + (const RpcReqWifiGetCountry *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetCountry * + rpc__req__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_country__free_unpacked + (RpcReqWifiGetCountry *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetCountry methods */ +void rpc__resp__wifi_get_country__init + (RpcRespWifiGetCountry *message); +size_t rpc__resp__wifi_get_country__get_packed_size + (const RpcRespWifiGetCountry *message); +size_t rpc__resp__wifi_get_country__pack + (const RpcRespWifiGetCountry *message, + uint8_t *out); +size_t rpc__resp__wifi_get_country__pack_to_buffer + (const RpcRespWifiGetCountry *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetCountry * + rpc__resp__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_country__free_unpacked + (RpcRespWifiGetCountry *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiApGetStaList methods */ +void rpc__req__wifi_ap_get_sta_list__init + (RpcReqWifiApGetStaList *message); +size_t rpc__req__wifi_ap_get_sta_list__get_packed_size + (const RpcReqWifiApGetStaList *message); +size_t rpc__req__wifi_ap_get_sta_list__pack + (const RpcReqWifiApGetStaList *message, + uint8_t *out); +size_t rpc__req__wifi_ap_get_sta_list__pack_to_buffer + (const RpcReqWifiApGetStaList *message, + ProtobufCBuffer *buffer); +RpcReqWifiApGetStaList * + rpc__req__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_ap_get_sta_list__free_unpacked + (RpcReqWifiApGetStaList *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiApGetStaList methods */ +void rpc__resp__wifi_ap_get_sta_list__init + (RpcRespWifiApGetStaList *message); +size_t rpc__resp__wifi_ap_get_sta_list__get_packed_size + (const RpcRespWifiApGetStaList *message); +size_t rpc__resp__wifi_ap_get_sta_list__pack + (const RpcRespWifiApGetStaList *message, + uint8_t *out); +size_t rpc__resp__wifi_ap_get_sta_list__pack_to_buffer + (const RpcRespWifiApGetStaList *message, + ProtobufCBuffer *buffer); +RpcRespWifiApGetStaList * + rpc__resp__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_ap_get_sta_list__free_unpacked + (RpcRespWifiApGetStaList *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiApGetStaAid methods */ +void rpc__req__wifi_ap_get_sta_aid__init + (RpcReqWifiApGetStaAid *message); +size_t rpc__req__wifi_ap_get_sta_aid__get_packed_size + (const RpcReqWifiApGetStaAid *message); +size_t rpc__req__wifi_ap_get_sta_aid__pack + (const RpcReqWifiApGetStaAid *message, + uint8_t *out); +size_t rpc__req__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcReqWifiApGetStaAid *message, + ProtobufCBuffer *buffer); +RpcReqWifiApGetStaAid * + rpc__req__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_ap_get_sta_aid__free_unpacked + (RpcReqWifiApGetStaAid *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetNegotiatedPhymode methods */ +void rpc__req__wifi_sta_get_negotiated_phymode__init + (RpcReqWifiStaGetNegotiatedPhymode *message); +size_t rpc__req__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcReqWifiStaGetNegotiatedPhymode *message); +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack + (const RpcReqWifiStaGetNegotiatedPhymode *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetNegotiatedPhymode * + rpc__req__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetNegotiatedPhymode methods */ +void rpc__resp__wifi_sta_get_negotiated_phymode__init + (RpcRespWifiStaGetNegotiatedPhymode *message); +size_t rpc__resp__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcRespWifiStaGetNegotiatedPhymode *message); +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack + (const RpcRespWifiStaGetNegotiatedPhymode *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetNegotiatedPhymode * + rpc__resp__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiApGetStaAid methods */ +void rpc__resp__wifi_ap_get_sta_aid__init + (RpcRespWifiApGetStaAid *message); +size_t rpc__resp__wifi_ap_get_sta_aid__get_packed_size + (const RpcRespWifiApGetStaAid *message); +size_t rpc__resp__wifi_ap_get_sta_aid__pack + (const RpcRespWifiApGetStaAid *message, + uint8_t *out); +size_t rpc__resp__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcRespWifiApGetStaAid *message, + ProtobufCBuffer *buffer); +RpcRespWifiApGetStaAid * + rpc__resp__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_ap_get_sta_aid__free_unpacked + (RpcRespWifiApGetStaAid *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetRssi methods */ +void rpc__req__wifi_sta_get_rssi__init + (RpcReqWifiStaGetRssi *message); +size_t rpc__req__wifi_sta_get_rssi__get_packed_size + (const RpcReqWifiStaGetRssi *message); +size_t rpc__req__wifi_sta_get_rssi__pack + (const RpcReqWifiStaGetRssi *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_rssi__pack_to_buffer + (const RpcReqWifiStaGetRssi *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetRssi * + rpc__req__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_rssi__free_unpacked + (RpcReqWifiStaGetRssi *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetRssi methods */ +void rpc__resp__wifi_sta_get_rssi__init + (RpcRespWifiStaGetRssi *message); +size_t rpc__resp__wifi_sta_get_rssi__get_packed_size + (const RpcRespWifiStaGetRssi *message); +size_t rpc__resp__wifi_sta_get_rssi__pack + (const RpcRespWifiStaGetRssi *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_rssi__pack_to_buffer + (const RpcRespWifiStaGetRssi *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetRssi * + rpc__resp__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_rssi__free_unpacked + (RpcRespWifiStaGetRssi *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetAid methods */ +void rpc__req__wifi_sta_get_aid__init + (RpcReqWifiStaGetAid *message); +size_t rpc__req__wifi_sta_get_aid__get_packed_size + (const RpcReqWifiStaGetAid *message); +size_t rpc__req__wifi_sta_get_aid__pack + (const RpcReqWifiStaGetAid *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_aid__pack_to_buffer + (const RpcReqWifiStaGetAid *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetAid * + rpc__req__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_aid__free_unpacked + (RpcReqWifiStaGetAid *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetAid methods */ +void rpc__resp__wifi_sta_get_aid__init + (RpcRespWifiStaGetAid *message); +size_t rpc__resp__wifi_sta_get_aid__get_packed_size + (const RpcRespWifiStaGetAid *message); +size_t rpc__resp__wifi_sta_get_aid__pack + (const RpcRespWifiStaGetAid *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_aid__pack_to_buffer + (const RpcRespWifiStaGetAid *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetAid * + rpc__resp__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_aid__free_unpacked + (RpcRespWifiStaGetAid *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetProtocols methods */ +void rpc__req__wifi_set_protocols__init + (RpcReqWifiSetProtocols *message); +size_t rpc__req__wifi_set_protocols__get_packed_size + (const RpcReqWifiSetProtocols *message); +size_t rpc__req__wifi_set_protocols__pack + (const RpcReqWifiSetProtocols *message, + uint8_t *out); +size_t rpc__req__wifi_set_protocols__pack_to_buffer + (const RpcReqWifiSetProtocols *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetProtocols * + rpc__req__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_protocols__free_unpacked + (RpcReqWifiSetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetProtocols methods */ +void rpc__resp__wifi_set_protocols__init + (RpcRespWifiSetProtocols *message); +size_t rpc__resp__wifi_set_protocols__get_packed_size + (const RpcRespWifiSetProtocols *message); +size_t rpc__resp__wifi_set_protocols__pack + (const RpcRespWifiSetProtocols *message, + uint8_t *out); +size_t rpc__resp__wifi_set_protocols__pack_to_buffer + (const RpcRespWifiSetProtocols *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetProtocols * + rpc__resp__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_protocols__free_unpacked + (RpcRespWifiSetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetProtocols methods */ +void rpc__req__wifi_get_protocols__init + (RpcReqWifiGetProtocols *message); +size_t rpc__req__wifi_get_protocols__get_packed_size + (const RpcReqWifiGetProtocols *message); +size_t rpc__req__wifi_get_protocols__pack + (const RpcReqWifiGetProtocols *message, + uint8_t *out); +size_t rpc__req__wifi_get_protocols__pack_to_buffer + (const RpcReqWifiGetProtocols *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetProtocols * + rpc__req__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_protocols__free_unpacked + (RpcReqWifiGetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetProtocols methods */ +void rpc__resp__wifi_get_protocols__init + (RpcRespWifiGetProtocols *message); +size_t rpc__resp__wifi_get_protocols__get_packed_size + (const RpcRespWifiGetProtocols *message); +size_t rpc__resp__wifi_get_protocols__pack + (const RpcRespWifiGetProtocols *message, + uint8_t *out); +size_t rpc__resp__wifi_get_protocols__pack_to_buffer + (const RpcRespWifiGetProtocols *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetProtocols * + rpc__resp__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_protocols__free_unpacked + (RpcRespWifiGetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBandwidths methods */ +void rpc__req__wifi_set_bandwidths__init + (RpcReqWifiSetBandwidths *message); +size_t rpc__req__wifi_set_bandwidths__get_packed_size + (const RpcReqWifiSetBandwidths *message); +size_t rpc__req__wifi_set_bandwidths__pack + (const RpcReqWifiSetBandwidths *message, + uint8_t *out); +size_t rpc__req__wifi_set_bandwidths__pack_to_buffer + (const RpcReqWifiSetBandwidths *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBandwidths * + rpc__req__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_bandwidths__free_unpacked + (RpcReqWifiSetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBandwidths methods */ +void rpc__resp__wifi_set_bandwidths__init + (RpcRespWifiSetBandwidths *message); +size_t rpc__resp__wifi_set_bandwidths__get_packed_size + (const RpcRespWifiSetBandwidths *message); +size_t rpc__resp__wifi_set_bandwidths__pack + (const RpcRespWifiSetBandwidths *message, + uint8_t *out); +size_t rpc__resp__wifi_set_bandwidths__pack_to_buffer + (const RpcRespWifiSetBandwidths *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBandwidths * + rpc__resp__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_bandwidths__free_unpacked + (RpcRespWifiSetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBandwidths methods */ +void rpc__req__wifi_get_bandwidths__init + (RpcReqWifiGetBandwidths *message); +size_t rpc__req__wifi_get_bandwidths__get_packed_size + (const RpcReqWifiGetBandwidths *message); +size_t rpc__req__wifi_get_bandwidths__pack + (const RpcReqWifiGetBandwidths *message, + uint8_t *out); +size_t rpc__req__wifi_get_bandwidths__pack_to_buffer + (const RpcReqWifiGetBandwidths *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBandwidths * + rpc__req__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_bandwidths__free_unpacked + (RpcReqWifiGetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBandwidths methods */ +void rpc__resp__wifi_get_bandwidths__init + (RpcRespWifiGetBandwidths *message); +size_t rpc__resp__wifi_get_bandwidths__get_packed_size + (const RpcRespWifiGetBandwidths *message); +size_t rpc__resp__wifi_get_bandwidths__pack + (const RpcRespWifiGetBandwidths *message, + uint8_t *out); +size_t rpc__resp__wifi_get_bandwidths__pack_to_buffer + (const RpcRespWifiGetBandwidths *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBandwidths * + rpc__resp__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_bandwidths__free_unpacked + (RpcRespWifiGetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBand methods */ +void rpc__req__wifi_set_band__init + (RpcReqWifiSetBand *message); +size_t rpc__req__wifi_set_band__get_packed_size + (const RpcReqWifiSetBand *message); +size_t rpc__req__wifi_set_band__pack + (const RpcReqWifiSetBand *message, + uint8_t *out); +size_t rpc__req__wifi_set_band__pack_to_buffer + (const RpcReqWifiSetBand *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBand * + rpc__req__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_band__free_unpacked + (RpcReqWifiSetBand *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBand methods */ +void rpc__resp__wifi_set_band__init + (RpcRespWifiSetBand *message); +size_t rpc__resp__wifi_set_band__get_packed_size + (const RpcRespWifiSetBand *message); +size_t rpc__resp__wifi_set_band__pack + (const RpcRespWifiSetBand *message, + uint8_t *out); +size_t rpc__resp__wifi_set_band__pack_to_buffer + (const RpcRespWifiSetBand *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBand * + rpc__resp__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_band__free_unpacked + (RpcRespWifiSetBand *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBand methods */ +void rpc__req__wifi_get_band__init + (RpcReqWifiGetBand *message); +size_t rpc__req__wifi_get_band__get_packed_size + (const RpcReqWifiGetBand *message); +size_t rpc__req__wifi_get_band__pack + (const RpcReqWifiGetBand *message, + uint8_t *out); +size_t rpc__req__wifi_get_band__pack_to_buffer + (const RpcReqWifiGetBand *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBand * + rpc__req__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_band__free_unpacked + (RpcReqWifiGetBand *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBand methods */ +void rpc__resp__wifi_get_band__init + (RpcRespWifiGetBand *message); +size_t rpc__resp__wifi_get_band__get_packed_size + (const RpcRespWifiGetBand *message); +size_t rpc__resp__wifi_get_band__pack + (const RpcRespWifiGetBand *message, + uint8_t *out); +size_t rpc__resp__wifi_get_band__pack_to_buffer + (const RpcRespWifiGetBand *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBand * + rpc__resp__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_band__free_unpacked + (RpcRespWifiGetBand *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBandMode methods */ +void rpc__req__wifi_set_band_mode__init + (RpcReqWifiSetBandMode *message); +size_t rpc__req__wifi_set_band_mode__get_packed_size + (const RpcReqWifiSetBandMode *message); +size_t rpc__req__wifi_set_band_mode__pack + (const RpcReqWifiSetBandMode *message, + uint8_t *out); +size_t rpc__req__wifi_set_band_mode__pack_to_buffer + (const RpcReqWifiSetBandMode *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBandMode * + rpc__req__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_band_mode__free_unpacked + (RpcReqWifiSetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBandMode methods */ +void rpc__resp__wifi_set_band_mode__init + (RpcRespWifiSetBandMode *message); +size_t rpc__resp__wifi_set_band_mode__get_packed_size + (const RpcRespWifiSetBandMode *message); +size_t rpc__resp__wifi_set_band_mode__pack + (const RpcRespWifiSetBandMode *message, + uint8_t *out); +size_t rpc__resp__wifi_set_band_mode__pack_to_buffer + (const RpcRespWifiSetBandMode *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBandMode * + rpc__resp__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_band_mode__free_unpacked + (RpcRespWifiSetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBandMode methods */ +void rpc__req__wifi_get_band_mode__init + (RpcReqWifiGetBandMode *message); +size_t rpc__req__wifi_get_band_mode__get_packed_size + (const RpcReqWifiGetBandMode *message); +size_t rpc__req__wifi_get_band_mode__pack + (const RpcReqWifiGetBandMode *message, + uint8_t *out); +size_t rpc__req__wifi_get_band_mode__pack_to_buffer + (const RpcReqWifiGetBandMode *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBandMode * + rpc__req__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_band_mode__free_unpacked + (RpcReqWifiGetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBandMode methods */ +void rpc__resp__wifi_get_band_mode__init + (RpcRespWifiGetBandMode *message); +size_t rpc__resp__wifi_get_band_mode__get_packed_size + (const RpcRespWifiGetBandMode *message); +size_t rpc__resp__wifi_get_band_mode__pack + (const RpcRespWifiGetBandMode *message, + uint8_t *out); +size_t rpc__resp__wifi_get_band_mode__pack_to_buffer + (const RpcRespWifiGetBandMode *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBandMode * + rpc__resp__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_band_mode__free_unpacked + (RpcRespWifiGetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcReqGetCoprocessorFwVersion methods */ +void rpc__req__get_coprocessor_fw_version__init + (RpcReqGetCoprocessorFwVersion *message); +size_t rpc__req__get_coprocessor_fw_version__get_packed_size + (const RpcReqGetCoprocessorFwVersion *message); +size_t rpc__req__get_coprocessor_fw_version__pack + (const RpcReqGetCoprocessorFwVersion *message, + uint8_t *out); +size_t rpc__req__get_coprocessor_fw_version__pack_to_buffer + (const RpcReqGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer); +RpcReqGetCoprocessorFwVersion * + rpc__req__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_coprocessor_fw_version__free_unpacked + (RpcReqGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator); +/* RpcRespGetCoprocessorFwVersion methods */ +void rpc__resp__get_coprocessor_fw_version__init + (RpcRespGetCoprocessorFwVersion *message); +size_t rpc__resp__get_coprocessor_fw_version__get_packed_size + (const RpcRespGetCoprocessorFwVersion *message); +size_t rpc__resp__get_coprocessor_fw_version__pack + (const RpcRespGetCoprocessorFwVersion *message, + uint8_t *out); +size_t rpc__resp__get_coprocessor_fw_version__pack_to_buffer + (const RpcRespGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer); +RpcRespGetCoprocessorFwVersion * + rpc__resp__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_coprocessor_fw_version__free_unpacked + (RpcRespGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator); +/* RpcEventWifiEventNoArgs methods */ +void rpc__event__wifi_event_no_args__init + (RpcEventWifiEventNoArgs *message); +size_t rpc__event__wifi_event_no_args__get_packed_size + (const RpcEventWifiEventNoArgs *message); +size_t rpc__event__wifi_event_no_args__pack + (const RpcEventWifiEventNoArgs *message, + uint8_t *out); +size_t rpc__event__wifi_event_no_args__pack_to_buffer + (const RpcEventWifiEventNoArgs *message, + ProtobufCBuffer *buffer); +RpcEventWifiEventNoArgs * + rpc__event__wifi_event_no_args__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__wifi_event_no_args__free_unpacked + (RpcEventWifiEventNoArgs *message, + ProtobufCAllocator *allocator); +/* RpcEventESPInit methods */ +void rpc__event__espinit__init + (RpcEventESPInit *message); +size_t rpc__event__espinit__get_packed_size + (const RpcEventESPInit *message); +size_t rpc__event__espinit__pack + (const RpcEventESPInit *message, + uint8_t *out); +size_t rpc__event__espinit__pack_to_buffer + (const RpcEventESPInit *message, + ProtobufCBuffer *buffer); +RpcEventESPInit * + rpc__event__espinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__espinit__free_unpacked + (RpcEventESPInit *message, + ProtobufCAllocator *allocator); +/* RpcEventHeartbeat methods */ +void rpc__event__heartbeat__init + (RpcEventHeartbeat *message); +size_t rpc__event__heartbeat__get_packed_size + (const RpcEventHeartbeat *message); +size_t rpc__event__heartbeat__pack + (const RpcEventHeartbeat *message, + uint8_t *out); +size_t rpc__event__heartbeat__pack_to_buffer + (const RpcEventHeartbeat *message, + ProtobufCBuffer *buffer); +RpcEventHeartbeat * + rpc__event__heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__heartbeat__free_unpacked + (RpcEventHeartbeat *message, + ProtobufCAllocator *allocator); +/* RpcEventAPStaDisconnected methods */ +void rpc__event__ap__sta_disconnected__init + (RpcEventAPStaDisconnected *message); +size_t rpc__event__ap__sta_disconnected__get_packed_size + (const RpcEventAPStaDisconnected *message); +size_t rpc__event__ap__sta_disconnected__pack + (const RpcEventAPStaDisconnected *message, + uint8_t *out); +size_t rpc__event__ap__sta_disconnected__pack_to_buffer + (const RpcEventAPStaDisconnected *message, + ProtobufCBuffer *buffer); +RpcEventAPStaDisconnected * + rpc__event__ap__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__ap__sta_disconnected__free_unpacked + (RpcEventAPStaDisconnected *message, + ProtobufCAllocator *allocator); +/* RpcEventAPStaConnected methods */ +void rpc__event__ap__sta_connected__init + (RpcEventAPStaConnected *message); +size_t rpc__event__ap__sta_connected__get_packed_size + (const RpcEventAPStaConnected *message); +size_t rpc__event__ap__sta_connected__pack + (const RpcEventAPStaConnected *message, + uint8_t *out); +size_t rpc__event__ap__sta_connected__pack_to_buffer + (const RpcEventAPStaConnected *message, + ProtobufCBuffer *buffer); +RpcEventAPStaConnected * + rpc__event__ap__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__ap__sta_connected__free_unpacked + (RpcEventAPStaConnected *message, + ProtobufCAllocator *allocator); +/* RpcEventStaScanDone methods */ +void rpc__event__sta_scan_done__init + (RpcEventStaScanDone *message); +size_t rpc__event__sta_scan_done__get_packed_size + (const RpcEventStaScanDone *message); +size_t rpc__event__sta_scan_done__pack + (const RpcEventStaScanDone *message, + uint8_t *out); +size_t rpc__event__sta_scan_done__pack_to_buffer + (const RpcEventStaScanDone *message, + ProtobufCBuffer *buffer); +RpcEventStaScanDone * + rpc__event__sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_scan_done__free_unpacked + (RpcEventStaScanDone *message, + ProtobufCAllocator *allocator); +/* RpcEventStaConnected methods */ +void rpc__event__sta_connected__init + (RpcEventStaConnected *message); +size_t rpc__event__sta_connected__get_packed_size + (const RpcEventStaConnected *message); +size_t rpc__event__sta_connected__pack + (const RpcEventStaConnected *message, + uint8_t *out); +size_t rpc__event__sta_connected__pack_to_buffer + (const RpcEventStaConnected *message, + ProtobufCBuffer *buffer); +RpcEventStaConnected * + rpc__event__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_connected__free_unpacked + (RpcEventStaConnected *message, + ProtobufCAllocator *allocator); +/* RpcEventStaDisconnected methods */ +void rpc__event__sta_disconnected__init + (RpcEventStaDisconnected *message); +size_t rpc__event__sta_disconnected__get_packed_size + (const RpcEventStaDisconnected *message); +size_t rpc__event__sta_disconnected__pack + (const RpcEventStaDisconnected *message, + uint8_t *out); +size_t rpc__event__sta_disconnected__pack_to_buffer + (const RpcEventStaDisconnected *message, + ProtobufCBuffer *buffer); +RpcEventStaDisconnected * + rpc__event__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_disconnected__free_unpacked + (RpcEventStaDisconnected *message, + ProtobufCAllocator *allocator); +/* Rpc methods */ +void rpc__init + (Rpc *message); +size_t rpc__get_packed_size + (const Rpc *message); +size_t rpc__pack + (const Rpc *message, + uint8_t *out); +size_t rpc__pack_to_buffer + (const Rpc *message, + ProtobufCBuffer *buffer); +Rpc * + rpc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__free_unpacked + (Rpc *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*WifiInitConfig_Closure) + (const WifiInitConfig *message, + void *closure_data); +typedef void (*WifiCountry_Closure) + (const WifiCountry *message, + void *closure_data); +typedef void (*WifiActiveScanTime_Closure) + (const WifiActiveScanTime *message, + void *closure_data); +typedef void (*WifiScanTime_Closure) + (const WifiScanTime *message, + void *closure_data); +typedef void (*WifiScanConfig_Closure) + (const WifiScanConfig *message, + void *closure_data); +typedef void (*WifiHeApInfo_Closure) + (const WifiHeApInfo *message, + void *closure_data); +typedef void (*WifiApRecord_Closure) + (const WifiApRecord *message, + void *closure_data); +typedef void (*WifiScanThreshold_Closure) + (const WifiScanThreshold *message, + void *closure_data); +typedef void (*WifiPmfConfig_Closure) + (const WifiPmfConfig *message, + void *closure_data); +typedef void (*WifiApConfig_Closure) + (const WifiApConfig *message, + void *closure_data); +typedef void (*WifiStaConfig_Closure) + (const WifiStaConfig *message, + void *closure_data); +typedef void (*WifiConfig_Closure) + (const WifiConfig *message, + void *closure_data); +typedef void (*WifiStaInfo_Closure) + (const WifiStaInfo *message, + void *closure_data); +typedef void (*WifiStaList_Closure) + (const WifiStaList *message, + void *closure_data); +typedef void (*WifiPktRxCtrl_Closure) + (const WifiPktRxCtrl *message, + void *closure_data); +typedef void (*WifiPromiscuousPkt_Closure) + (const WifiPromiscuousPkt *message, + void *closure_data); +typedef void (*WifiPromiscuousFilter_Closure) + (const WifiPromiscuousFilter *message, + void *closure_data); +typedef void (*WifiCsiConfig_Closure) + (const WifiCsiConfig *message, + void *closure_data); +typedef void (*WifiCsiInfo_Closure) + (const WifiCsiInfo *message, + void *closure_data); +typedef void (*WifiAntGpio_Closure) + (const WifiAntGpio *message, + void *closure_data); +typedef void (*WifiAntGpioConfig_Closure) + (const WifiAntGpioConfig *message, + void *closure_data); +typedef void (*WifiAntConfig_Closure) + (const WifiAntConfig *message, + void *closure_data); +typedef void (*WifiActionTxReq_Closure) + (const WifiActionTxReq *message, + void *closure_data); +typedef void (*WifiFtmInitiatorCfg_Closure) + (const WifiFtmInitiatorCfg *message, + void *closure_data); +typedef void (*WifiEventStaScanDone_Closure) + (const WifiEventStaScanDone *message, + void *closure_data); +typedef void (*WifiEventStaConnected_Closure) + (const WifiEventStaConnected *message, + void *closure_data); +typedef void (*WifiEventStaDisconnected_Closure) + (const WifiEventStaDisconnected *message, + void *closure_data); +typedef void (*WifiEventStaAuthmodeChange_Closure) + (const WifiEventStaAuthmodeChange *message, + void *closure_data); +typedef void (*WifiEventStaWpsErPin_Closure) + (const WifiEventStaWpsErPin *message, + void *closure_data); +typedef void (*ApCred_Closure) + (const ApCred *message, + void *closure_data); +typedef void (*WifiEventStaWpsErSuccess_Closure) + (const WifiEventStaWpsErSuccess *message, + void *closure_data); +typedef void (*WifiEventApProbeReqRx_Closure) + (const WifiEventApProbeReqRx *message, + void *closure_data); +typedef void (*WifiEventBssRssiLow_Closure) + (const WifiEventBssRssiLow *message, + void *closure_data); +typedef void (*WifiFtmReportEntry_Closure) + (const WifiFtmReportEntry *message, + void *closure_data); +typedef void (*WifiEventFtmReport_Closure) + (const WifiEventFtmReport *message, + void *closure_data); +typedef void (*WifiEventActionTxStatus_Closure) + (const WifiEventActionTxStatus *message, + void *closure_data); +typedef void (*WifiEventRocDone_Closure) + (const WifiEventRocDone *message, + void *closure_data); +typedef void (*WifiEventApWpsRgPin_Closure) + (const WifiEventApWpsRgPin *message, + void *closure_data); +typedef void (*WifiEventApWpsRgFailReason_Closure) + (const WifiEventApWpsRgFailReason *message, + void *closure_data); +typedef void (*WifiEventApWpsRgSuccess_Closure) + (const WifiEventApWpsRgSuccess *message, + void *closure_data); +typedef void (*WifiProtocols_Closure) + (const WifiProtocols *message, + void *closure_data); +typedef void (*WifiBandwidths_Closure) + (const WifiBandwidths *message, + void *closure_data); +typedef void (*ConnectedSTAList_Closure) + (const ConnectedSTAList *message, + void *closure_data); +typedef void (*RpcReqGetMacAddress_Closure) + (const RpcReqGetMacAddress *message, + void *closure_data); +typedef void (*RpcRespGetMacAddress_Closure) + (const RpcRespGetMacAddress *message, + void *closure_data); +typedef void (*RpcReqGetMode_Closure) + (const RpcReqGetMode *message, + void *closure_data); +typedef void (*RpcRespGetMode_Closure) + (const RpcRespGetMode *message, + void *closure_data); +typedef void (*RpcReqSetMode_Closure) + (const RpcReqSetMode *message, + void *closure_data); +typedef void (*RpcRespSetMode_Closure) + (const RpcRespSetMode *message, + void *closure_data); +typedef void (*RpcReqGetPs_Closure) + (const RpcReqGetPs *message, + void *closure_data); +typedef void (*RpcRespGetPs_Closure) + (const RpcRespGetPs *message, + void *closure_data); +typedef void (*RpcReqSetPs_Closure) + (const RpcReqSetPs *message, + void *closure_data); +typedef void (*RpcRespSetPs_Closure) + (const RpcRespSetPs *message, + void *closure_data); +typedef void (*RpcReqSetMacAddress_Closure) + (const RpcReqSetMacAddress *message, + void *closure_data); +typedef void (*RpcRespSetMacAddress_Closure) + (const RpcRespSetMacAddress *message, + void *closure_data); +typedef void (*RpcReqOTABegin_Closure) + (const RpcReqOTABegin *message, + void *closure_data); +typedef void (*RpcRespOTABegin_Closure) + (const RpcRespOTABegin *message, + void *closure_data); +typedef void (*RpcReqOTAWrite_Closure) + (const RpcReqOTAWrite *message, + void *closure_data); +typedef void (*RpcRespOTAWrite_Closure) + (const RpcRespOTAWrite *message, + void *closure_data); +typedef void (*RpcReqOTAEnd_Closure) + (const RpcReqOTAEnd *message, + void *closure_data); +typedef void (*RpcRespOTAEnd_Closure) + (const RpcRespOTAEnd *message, + void *closure_data); +typedef void (*RpcReqWifiSetMaxTxPower_Closure) + (const RpcReqWifiSetMaxTxPower *message, + void *closure_data); +typedef void (*RpcRespWifiSetMaxTxPower_Closure) + (const RpcRespWifiSetMaxTxPower *message, + void *closure_data); +typedef void (*RpcReqWifiGetMaxTxPower_Closure) + (const RpcReqWifiGetMaxTxPower *message, + void *closure_data); +typedef void (*RpcRespWifiGetMaxTxPower_Closure) + (const RpcRespWifiGetMaxTxPower *message, + void *closure_data); +typedef void (*RpcReqConfigHeartbeat_Closure) + (const RpcReqConfigHeartbeat *message, + void *closure_data); +typedef void (*RpcRespConfigHeartbeat_Closure) + (const RpcRespConfigHeartbeat *message, + void *closure_data); +typedef void (*RpcReqWifiInit_Closure) + (const RpcReqWifiInit *message, + void *closure_data); +typedef void (*RpcRespWifiInit_Closure) + (const RpcRespWifiInit *message, + void *closure_data); +typedef void (*RpcReqWifiDeinit_Closure) + (const RpcReqWifiDeinit *message, + void *closure_data); +typedef void (*RpcRespWifiDeinit_Closure) + (const RpcRespWifiDeinit *message, + void *closure_data); +typedef void (*RpcReqWifiSetConfig_Closure) + (const RpcReqWifiSetConfig *message, + void *closure_data); +typedef void (*RpcRespWifiSetConfig_Closure) + (const RpcRespWifiSetConfig *message, + void *closure_data); +typedef void (*RpcReqWifiGetConfig_Closure) + (const RpcReqWifiGetConfig *message, + void *closure_data); +typedef void (*RpcRespWifiGetConfig_Closure) + (const RpcRespWifiGetConfig *message, + void *closure_data); +typedef void (*RpcReqWifiConnect_Closure) + (const RpcReqWifiConnect *message, + void *closure_data); +typedef void (*RpcRespWifiConnect_Closure) + (const RpcRespWifiConnect *message, + void *closure_data); +typedef void (*RpcReqWifiDisconnect_Closure) + (const RpcReqWifiDisconnect *message, + void *closure_data); +typedef void (*RpcRespWifiDisconnect_Closure) + (const RpcRespWifiDisconnect *message, + void *closure_data); +typedef void (*RpcReqWifiStart_Closure) + (const RpcReqWifiStart *message, + void *closure_data); +typedef void (*RpcRespWifiStart_Closure) + (const RpcRespWifiStart *message, + void *closure_data); +typedef void (*RpcReqWifiStop_Closure) + (const RpcReqWifiStop *message, + void *closure_data); +typedef void (*RpcRespWifiStop_Closure) + (const RpcRespWifiStop *message, + void *closure_data); +typedef void (*RpcReqWifiScanStart_Closure) + (const RpcReqWifiScanStart *message, + void *closure_data); +typedef void (*RpcRespWifiScanStart_Closure) + (const RpcRespWifiScanStart *message, + void *closure_data); +typedef void (*RpcReqWifiScanStop_Closure) + (const RpcReqWifiScanStop *message, + void *closure_data); +typedef void (*RpcRespWifiScanStop_Closure) + (const RpcRespWifiScanStop *message, + void *closure_data); +typedef void (*RpcReqWifiScanGetApNum_Closure) + (const RpcReqWifiScanGetApNum *message, + void *closure_data); +typedef void (*RpcRespWifiScanGetApNum_Closure) + (const RpcRespWifiScanGetApNum *message, + void *closure_data); +typedef void (*RpcReqWifiScanGetApRecords_Closure) + (const RpcReqWifiScanGetApRecords *message, + void *closure_data); +typedef void (*RpcRespWifiScanGetApRecords_Closure) + (const RpcRespWifiScanGetApRecords *message, + void *closure_data); +typedef void (*RpcReqWifiScanGetApRecord_Closure) + (const RpcReqWifiScanGetApRecord *message, + void *closure_data); +typedef void (*RpcRespWifiScanGetApRecord_Closure) + (const RpcRespWifiScanGetApRecord *message, + void *closure_data); +typedef void (*RpcReqWifiClearApList_Closure) + (const RpcReqWifiClearApList *message, + void *closure_data); +typedef void (*RpcRespWifiClearApList_Closure) + (const RpcRespWifiClearApList *message, + void *closure_data); +typedef void (*RpcReqWifiRestore_Closure) + (const RpcReqWifiRestore *message, + void *closure_data); +typedef void (*RpcRespWifiRestore_Closure) + (const RpcRespWifiRestore *message, + void *closure_data); +typedef void (*RpcReqWifiClearFastConnect_Closure) + (const RpcReqWifiClearFastConnect *message, + void *closure_data); +typedef void (*RpcRespWifiClearFastConnect_Closure) + (const RpcRespWifiClearFastConnect *message, + void *closure_data); +typedef void (*RpcReqWifiDeauthSta_Closure) + (const RpcReqWifiDeauthSta *message, + void *closure_data); +typedef void (*RpcRespWifiDeauthSta_Closure) + (const RpcRespWifiDeauthSta *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetApInfo_Closure) + (const RpcReqWifiStaGetApInfo *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetApInfo_Closure) + (const RpcRespWifiStaGetApInfo *message, + void *closure_data); +typedef void (*RpcReqWifiSetProtocol_Closure) + (const RpcReqWifiSetProtocol *message, + void *closure_data); +typedef void (*RpcRespWifiSetProtocol_Closure) + (const RpcRespWifiSetProtocol *message, + void *closure_data); +typedef void (*RpcReqWifiGetProtocol_Closure) + (const RpcReqWifiGetProtocol *message, + void *closure_data); +typedef void (*RpcRespWifiGetProtocol_Closure) + (const RpcRespWifiGetProtocol *message, + void *closure_data); +typedef void (*RpcReqWifiSetBandwidth_Closure) + (const RpcReqWifiSetBandwidth *message, + void *closure_data); +typedef void (*RpcRespWifiSetBandwidth_Closure) + (const RpcRespWifiSetBandwidth *message, + void *closure_data); +typedef void (*RpcReqWifiGetBandwidth_Closure) + (const RpcReqWifiGetBandwidth *message, + void *closure_data); +typedef void (*RpcRespWifiGetBandwidth_Closure) + (const RpcRespWifiGetBandwidth *message, + void *closure_data); +typedef void (*RpcReqWifiSetChannel_Closure) + (const RpcReqWifiSetChannel *message, + void *closure_data); +typedef void (*RpcRespWifiSetChannel_Closure) + (const RpcRespWifiSetChannel *message, + void *closure_data); +typedef void (*RpcReqWifiGetChannel_Closure) + (const RpcReqWifiGetChannel *message, + void *closure_data); +typedef void (*RpcRespWifiGetChannel_Closure) + (const RpcRespWifiGetChannel *message, + void *closure_data); +typedef void (*RpcReqWifiSetStorage_Closure) + (const RpcReqWifiSetStorage *message, + void *closure_data); +typedef void (*RpcRespWifiSetStorage_Closure) + (const RpcRespWifiSetStorage *message, + void *closure_data); +typedef void (*RpcReqWifiSetCountryCode_Closure) + (const RpcReqWifiSetCountryCode *message, + void *closure_data); +typedef void (*RpcRespWifiSetCountryCode_Closure) + (const RpcRespWifiSetCountryCode *message, + void *closure_data); +typedef void (*RpcReqWifiGetCountryCode_Closure) + (const RpcReqWifiGetCountryCode *message, + void *closure_data); +typedef void (*RpcRespWifiGetCountryCode_Closure) + (const RpcRespWifiGetCountryCode *message, + void *closure_data); +typedef void (*RpcReqWifiSetCountry_Closure) + (const RpcReqWifiSetCountry *message, + void *closure_data); +typedef void (*RpcRespWifiSetCountry_Closure) + (const RpcRespWifiSetCountry *message, + void *closure_data); +typedef void (*RpcReqWifiGetCountry_Closure) + (const RpcReqWifiGetCountry *message, + void *closure_data); +typedef void (*RpcRespWifiGetCountry_Closure) + (const RpcRespWifiGetCountry *message, + void *closure_data); +typedef void (*RpcReqWifiApGetStaList_Closure) + (const RpcReqWifiApGetStaList *message, + void *closure_data); +typedef void (*RpcRespWifiApGetStaList_Closure) + (const RpcRespWifiApGetStaList *message, + void *closure_data); +typedef void (*RpcReqWifiApGetStaAid_Closure) + (const RpcReqWifiApGetStaAid *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetNegotiatedPhymode_Closure) + (const RpcReqWifiStaGetNegotiatedPhymode *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetNegotiatedPhymode_Closure) + (const RpcRespWifiStaGetNegotiatedPhymode *message, + void *closure_data); +typedef void (*RpcRespWifiApGetStaAid_Closure) + (const RpcRespWifiApGetStaAid *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetRssi_Closure) + (const RpcReqWifiStaGetRssi *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetRssi_Closure) + (const RpcRespWifiStaGetRssi *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetAid_Closure) + (const RpcReqWifiStaGetAid *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetAid_Closure) + (const RpcRespWifiStaGetAid *message, + void *closure_data); +typedef void (*RpcReqWifiSetProtocols_Closure) + (const RpcReqWifiSetProtocols *message, + void *closure_data); +typedef void (*RpcRespWifiSetProtocols_Closure) + (const RpcRespWifiSetProtocols *message, + void *closure_data); +typedef void (*RpcReqWifiGetProtocols_Closure) + (const RpcReqWifiGetProtocols *message, + void *closure_data); +typedef void (*RpcRespWifiGetProtocols_Closure) + (const RpcRespWifiGetProtocols *message, + void *closure_data); +typedef void (*RpcReqWifiSetBandwidths_Closure) + (const RpcReqWifiSetBandwidths *message, + void *closure_data); +typedef void (*RpcRespWifiSetBandwidths_Closure) + (const RpcRespWifiSetBandwidths *message, + void *closure_data); +typedef void (*RpcReqWifiGetBandwidths_Closure) + (const RpcReqWifiGetBandwidths *message, + void *closure_data); +typedef void (*RpcRespWifiGetBandwidths_Closure) + (const RpcRespWifiGetBandwidths *message, + void *closure_data); +typedef void (*RpcReqWifiSetBand_Closure) + (const RpcReqWifiSetBand *message, + void *closure_data); +typedef void (*RpcRespWifiSetBand_Closure) + (const RpcRespWifiSetBand *message, + void *closure_data); +typedef void (*RpcReqWifiGetBand_Closure) + (const RpcReqWifiGetBand *message, + void *closure_data); +typedef void (*RpcRespWifiGetBand_Closure) + (const RpcRespWifiGetBand *message, + void *closure_data); +typedef void (*RpcReqWifiSetBandMode_Closure) + (const RpcReqWifiSetBandMode *message, + void *closure_data); +typedef void (*RpcRespWifiSetBandMode_Closure) + (const RpcRespWifiSetBandMode *message, + void *closure_data); +typedef void (*RpcReqWifiGetBandMode_Closure) + (const RpcReqWifiGetBandMode *message, + void *closure_data); +typedef void (*RpcRespWifiGetBandMode_Closure) + (const RpcRespWifiGetBandMode *message, + void *closure_data); +typedef void (*RpcReqGetCoprocessorFwVersion_Closure) + (const RpcReqGetCoprocessorFwVersion *message, + void *closure_data); +typedef void (*RpcRespGetCoprocessorFwVersion_Closure) + (const RpcRespGetCoprocessorFwVersion *message, + void *closure_data); +typedef void (*RpcEventWifiEventNoArgs_Closure) + (const RpcEventWifiEventNoArgs *message, + void *closure_data); +typedef void (*RpcEventESPInit_Closure) + (const RpcEventESPInit *message, + void *closure_data); +typedef void (*RpcEventHeartbeat_Closure) + (const RpcEventHeartbeat *message, + void *closure_data); +typedef void (*RpcEventAPStaDisconnected_Closure) + (const RpcEventAPStaDisconnected *message, + void *closure_data); +typedef void (*RpcEventAPStaConnected_Closure) + (const RpcEventAPStaConnected *message, + void *closure_data); +typedef void (*RpcEventStaScanDone_Closure) + (const RpcEventStaScanDone *message, + void *closure_data); +typedef void (*RpcEventStaConnected_Closure) + (const RpcEventStaConnected *message, + void *closure_data); +typedef void (*RpcEventStaDisconnected_Closure) + (const RpcEventStaDisconnected *message, + void *closure_data); +typedef void (*Rpc_Closure) + (const Rpc *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor rpc__wifi_bw__descriptor; +extern const ProtobufCEnumDescriptor rpc__wifi_power_save__descriptor; +extern const ProtobufCEnumDescriptor rpc__wifi_sec_prot__descriptor; +extern const ProtobufCEnumDescriptor rpc__status__descriptor; +extern const ProtobufCEnumDescriptor rpc_type__descriptor; +extern const ProtobufCEnumDescriptor rpc_id__descriptor; +extern const ProtobufCMessageDescriptor wifi_init_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_country__descriptor; +extern const ProtobufCMessageDescriptor wifi_active_scan_time__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_time__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_he_ap_info__descriptor; +extern const ProtobufCMessageDescriptor wifi_ap_record__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_threshold__descriptor; +extern const ProtobufCMessageDescriptor wifi_pmf_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_ap_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_sta_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_sta_info__descriptor; +extern const ProtobufCMessageDescriptor wifi_sta_list__descriptor; +extern const ProtobufCMessageDescriptor wifi_pkt_rx_ctrl__descriptor; +extern const ProtobufCMessageDescriptor wifi_promiscuous_pkt__descriptor; +extern const ProtobufCMessageDescriptor wifi_promiscuous_filter__descriptor; +extern const ProtobufCMessageDescriptor wifi_csi_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_csi_info__descriptor; +extern const ProtobufCMessageDescriptor wifi_ant_gpio__descriptor; +extern const ProtobufCMessageDescriptor wifi_ant_gpio_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_ant_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_action_tx_req__descriptor; +extern const ProtobufCMessageDescriptor wifi_ftm_initiator_cfg__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_scan_done__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_connected__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_disconnected__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_authmode_change__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_wps_er_pin__descriptor; +extern const ProtobufCMessageDescriptor ap_cred__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_wps_er_success__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_probe_req_rx__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_bss_rssi_low__descriptor; +extern const ProtobufCMessageDescriptor wifi_ftm_report_entry__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ftm_report__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_action_tx_status__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_roc_done__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_pin__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_fail_reason__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_success__descriptor; +extern const ProtobufCMessageDescriptor wifi_protocols__descriptor; +extern const ProtobufCMessageDescriptor wifi_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor connected_stalist__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__otabegin__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__otabegin__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__otawrite__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__otawrite__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__otaend__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__otaend__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__config_heartbeat__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__config_heartbeat__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_init__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_init__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_deinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_deinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_disconnect__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_disconnect__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_num__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_num__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_records__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_records__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_record__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_record__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_clear_ap_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_clear_ap_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_restore__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_restore__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_clear_fast_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_clear_fast_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_deauth_sta__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_deauth_sta__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_ap_info__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_ap_info__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_storage__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_storage__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_negotiated_phymode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_rssi__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_rssi__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_coprocessor_fw_version__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_coprocessor_fw_version__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__wifi_event_no_args__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__espinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__heartbeat__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__ap__sta_disconnected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__ap__sta_connected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_scan_done__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_connected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_disconnected__descriptor; +extern const ProtobufCMessageDescriptor rpc__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED */ diff --git a/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.proto b/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.proto new file mode 100644 index 0000000..db37ac4 --- /dev/null +++ b/resources/espressif__esp_hosted/common/proto/esp_hosted_rpc.proto @@ -0,0 +1,1830 @@ +/* Copyright (C) 2015-2023 Espressif Systems (Shanghai) PTE LTD */ +/* SPDX-License-Identifier: GPL-2.0-only OR Apache-2.0 */ + +syntax = "proto3"; + +/* Enums similar to ESP IDF */ +//enum Rpc_VendorIEType { +// Beacon = 0; +// Probe_req = 1; +// Probe_resp = 2; +// Assoc_req = 3; +// Assoc_resp = 4; +//} +// +//enum Rpc_VendorIEID { +// ID_0 = 0; +// ID_1 = 1; +//} + + +enum Rpc_WifiBw { + BW_Invalid = 0; + HT20 = 1; + HT40 = 2; +} + +enum Rpc_WifiPowerSave { + PS_Invalid = 0; + MIN_MODEM = 1; + MAX_MODEM = 2; +} + +enum Rpc_WifiSecProt { + Open = 0; + WEP = 1; + WPA_PSK = 2; + WPA2_PSK = 3; + WPA_WPA2_PSK = 4; + WPA2_ENTERPRISE = 5; + WPA3_PSK = 6; + WPA2_WPA3_PSK = 7; +} + +/* enums for Control path */ +enum Rpc_Status { + Connected = 0; + Not_Connected = 1; + No_AP_Found = 2; + Connection_Fail = 3; + Invalid_Argument = 4; + Out_Of_Range = 5; +} + + +enum RpcType { +MsgType_Invalid = 0; + Req = 1; + Resp = 2; + Event = 3; + MsgType_Max = 4; +} +// +//enum Rpc { +// ESP_ERR_WIFI_BASE = 0x3000; +// ESP_ERR_WIFI_NOT_INIT = 0x3001; +// ESP_ERR_WIFI_NOT_STARTED = 0x3002; +// ESP_ERR_WIFI_NOT_STOPPED = 0x3003; +// ESP_ERR_WIFI_IF = 0x3004; +// ESP_ERR_WIFI_MODE = 0x3005; +// ESP_ERR_WIFI_STATE = 0x3006; +// ESP_ERR_WIFI_CONN = 0x3007; +// ESP_ERR_WIFI_NVS = 0x3008; +// ESP_ERR_WIFI_MAC = 0x3009; +// ESP_ERR_WIFI_SSID = 0x300a; +// ESP_ERR_WIFI_PASSWORD = 0x300b; +// ESP_ERR_WIFI_TIMEOUT = 0x300c; +// ESP_ERR_WIFI_WAKE_FAIL = 0x300d; +// ESP_ERR_WIFI_WOULD_BLOCK = 0x300e; +// ESP_ERR_WIFI_NOT_CONNECT = 0x300f; +// /* 0x3010 0x3011 not present intentionally */ +// ESP_ERR_WIFI_POST = 0x3012; +// ESP_ERR_WIFI_INIT_STATE = 0x3013; +// ESP_ERR_WIFI_STOP_STATE = 0x3014; +// ESP_ERR_WIFI_NOT_ASSOC = 0x3015; +// ESP_ERR_WIFI_TX_DISALLOW = 0x3016; +//} + + +//enum ctrl_msg_type { +// invalid = 0; +// req = 1; +// resp = 2; +// event = 3; +// max = 4; +//} +// +//enum ctrl_msg_id { +// invalid = 0; +// req_base = 400; +// req_w_init = 401; +// req_w_deinit = 402; +// req_w_set_mode = 403; +// req_w_get_mode = 404; +// req_w_start = 405; +// req_w_stop = 406; +// req_w_restore = 407; +// req_w_connect = 408; +// req_w_disconnect = 409; +// req_w_clear_fast_connect = 410; +// req_w_deauth_sta = 411; +// req_w_scan_start = 412; +// req_w_scan_stop = 413; +// req_w_scan_get_ap_name = 414; +// req_w_scan_get_ap_records = 415; +// req_w_clear_ap_list = 416; +// req_w_sta_get_ap_info = 417; +// req_w_set_ps = 418; +// req_w_get_ps = 419; +// req_w_set_protocol = 420; +// req_w_get_protocol = 421; +// req_w_set_bandwidth = 422; +// req_w_get_bandwidth = 423; +// req_w_set_channel = 424; +// req_w_get_channel = 425; +// req_w_set_country = 426; +// req_w_get_country = 427; +// req_w_set_mac = 428; +// req_w_get_mac = 429; +// req_w_set_promiscuous_cb = 430; +// req_w_set_promiscuous = 431; +// req_w_get_promiscuous = 432; +// req_w_set_promiscuous_filter = 433; +// req_w_get_promiscuous_filter = 434; +// req_w_set_promiscuous_ctrl_filter = 435; +// req_w_get_promiscuous_ctrl_filter = 436; +// req_w_set_config = 437; +// req_w_get_config = 438; +// req_w_ap_get_sta_list = 439; +// req_w_ap_get_sta_aid = 440; +// req_w_set_storage = 441; +// req_w_set_vendor_ie = 442; +// req_w_set_vendor_ie_cb = 443; +// req_w_set_max_tx_power = 444; +// req_w_get_max_tx_power = 445; +// req_w_set_event_mask = 446; +// req_w_get_event_mask = 447; +// req_w_80211_tx = 448; +// req_w_set_csi_rx_cb = 449; +// req_w_set_csi_config = 450; +// req_w_set_csi = 451; +// req_w_set_ant_gpio = 452; +// req_w_get_ant_gpio = 453; +// req_w_set_ant = 454; +// req_w_get_ant = 455; +// req_w_get_tsf_time = 456; +// req_w_set_inactive_time = 457; +// req_w_get_inactive_time = 458; +// req_w_statis_dump = 459; +// req_w_set_rssi_threshold = 460; +// req_w_ftm_initiate_session = 461; +// req_w_ftm_end_session = 462; +// req_w_ftm_resp_set_offset = 463; +// req_w_config_11b_rate = 464; +// req_w_connectionless_module_set_wake_interval = 465; +// req_w_set_country_code = 466; +// req_w_get_country_code = 467; +// req_w_config_80211_tx_rate = 468; +// req_w_disable_pmf_config = 469; +// +// req_max = 470; +// +// +// rsp_base = 600; +// rsp_w_init = 601; +// rsp_w_deinit = 602; +// rsp_w_set_mode = 603; +// rsp_w_get_mode = 604; +// rsp_w_start = 605; +// rsp_w_stop = 606; +// rsp_w_restore = 607; +// rsp_w_connect = 608; +// rsp_w_disconnect = 609; +// rsp_w_clear_fast_connect = 610; +// rsp_w_deauth_sta = 611; +// rsp_w_scan_start = 612; +// rsp_w_scan_stop = 613; +// rsp_w_scan_get_ap_name = 614; +// rsp_w_scan_get_ap_records = 615; +// rsp_w_clear_ap_list = 616; +// rsp_w_sta_get_ap_info = 617; +// rsp_w_set_ps = 618; +// rsp_w_get_ps = 619; +// rsp_w_set_protocol = 620; +// rsp_w_get_protocol = 621; +// rsp_w_set_bandwidth = 622; +// rsp_w_get_bandwidth = 623; +// rsp_w_set_channel = 624; +// rsp_w_get_channel = 625; +// rsp_w_set_country = 626; +// rsp_w_get_country = 627; +// rsp_w_set_mac = 628; +// rsp_w_get_mac = 629; +// rsp_w_set_promiscuous_cb = 630; +// rsp_w_set_promiscuous = 631; +// rsp_w_get_promiscuous = 632; +// rsp_w_set_promiscuous_filter = 633; +// rsp_w_get_promiscuous_filter = 634; +// rsp_w_set_promiscuous_ctrl_filter = 635; +// rsp_w_get_promiscuous_ctrl_filter = 636; +// rsp_w_set_config = 637; +// rsp_w_get_config = 638; +// rsp_w_ap_get_sta_list = 639; +// rsp_w_ap_get_sta_aid = 640; +// rsp_w_set_storage = 641; +// rsp_w_set_vendor_ie = 642; +// rsp_w_set_vendor_ie_cb = 643; +// rsp_w_set_max_tx_power = 644; +// rsp_w_get_max_tx_power = 645; +// rsp_w_set_event_mask = 646; +// rsp_w_get_event_mask = 647; +// rsp_w_80211_tx = 648; +// rsp_w_set_csi_rx_cb = 649; +// rsp_w_set_csi_config = 650; +// rsp_w_set_csi = 651; +// rsp_w_set_ant_gpio = 652; +// rsp_w_get_ant_gpio = 653; +// rsp_w_set_ant = 654; +// rsp_w_get_ant = 655; +// rsp_w_get_tsf_time = 656; +// rsp_w_set_inactive_time = 657; +// rsp_w_get_inactive_time = 658; +// rsp_w_statis_dump = 659; +// rsp_w_set_rssi_threshold = 660; +// rsp_w_ftm_initiate_session = 661; +// rsp_w_ftm_end_session = 662; +// rsp_w_ftm_resp_set_offset = 663; +// rsp_w_config_11b_rate = 664; +// rsp_w_connectionless_module_set_wake_interval = 665; +// rsp_w_set_country_code = 666; +// rsp_w_get_country_code = 667; +// rsp_w_config_80211_tx_rate = 668; +// rsp_w_disable_pmf_config = 669; +// +// rsp_max = 670; +// +// +// evt_base = 800; +// evt_esp_started = 801; +// evt_heartbeat = 802; +// evt_w_ready = 803; /**< ESP32 WiFi ready */ +// evt_w_scan_done = 804; /**< ESP32 finish scanning AP */ +// evt_w_sta_start = 805; /**< ESP32 station start */ +// evt_w_sta_stop = 806; /**< ESP32 station stop */ +// evt_w_sta_connected = 807; /**< ESP32 station connected to AP */ +// evt_w_sta_disconnected = 808; /**< ESP32 station disconnected from AP */ +// evt_w_sta_authmode_change = 809; /**< the auth mode of AP connected by ESP32 station changed */ +// +// evt_w_sta_wps_er_success = 810; /**< ESP32 station wps succeeds in enrollee mode */ +// evt_w_sta_wps_er_failed = 811; /**< ESP32 station wps fails in enrollee mode */ +// evt_w_sta_wps_er_timeout = 812; /**< ESP32 station wps timeout in enrollee mode */ +// evt_w_sta_wps_er_pin = 813; /**< ESP32 station wps pin code in enrollee mode */ +// evt_w_sta_wps_er_pbc_overlap = 814; /**< ESP32 station wps overlap in enrollee mode */ +// +// evt_w_ap_start = 815; /**< ESP32 soft-AP start */ +// evt_w_ap_stop = 816; /**< ESP32 soft-AP stop */ +// evt_w_ap_staconnected = 817; /**< a station connected to ESP32 soft-AP */ +// evt_w_ap_stadisconnected = 818; /**< a station disconnected from ESP32 soft-AP */ +// evt_w_ap_probereqrecved = 819; /**< Receive probe request packet in soft-AP interface */ +// +// evt_w_ftm_report = 820; /**< Receive report of FTM procedure */ +// +// /* Add next events after this only */ +// evt_w_sta_bss_rssi_low = 821; /**< AP's RSSI crossed configured threshold */ +// evt_w_action_tx_status = 822; /**< Status indication of Action Tx operation */ +// evt_w_roc_done = 823; /**< Remain-on-Channel operation complete */ +// +// evt_w_sta_beacon_timeout = 824; /**< ESP32 station beacon timeout */ +// +// evt_w_connectionless_module_wake_interval_start = 825; /**< ESP32 connectionless module wake interval start */ +// +// evt_w_ap_wps_rg_success = 826; /**< Soft-AP wps succeeds in registrar mode */ +// evt_w_ap_wps_rg_failed = 827; /**< Soft-AP wps fails in registrar mode */ +// evt_w_ap_wps_rg_timeout = 828; /**< Soft-AP wps timeout in registrar mode */ +// evt_w_ap_wps_rg_pin = 829; /**< Soft-AP wps pin code in registrar mode */ +// evt_w_ap_wps_rg_pbc_overlap = 830; /**< Soft-AP wps overlap in registrar mode */ +// +// evt_max = 831; /**< Invalid WiFi event ID */ +// +//} + + +enum RpcId { + MsgId_Invalid = 0; + + /** Request Msgs **/ + Req_Base = 256; //0x100 + + Req_GetMACAddress = 257; //0x101 + Req_SetMacAddress = 258; //0x102 + Req_GetWifiMode = 259; //0x103 + Req_SetWifiMode = 260; //0x104 + + //Req_GetAPScanList = 261; //0x105 + //Req_GetAPConfig = 262; //0x106 + //Req_ConnectAP = 263; //0x107 + //Req_DisconnectAP = 264; //0x108 + + //Req_GetSoftAPConfig = 265; //0x109 + //Req_SetSoftAPVendorSpecificIE = 266; //0x10a + //Req_StartSoftAP = 267; //0x10b + //Req_GetSoftAPConnectedSTAList = 268; //0x10c + //Req_StopSoftAP = 269; //0x10d + + Req_WifiSetPs = 270; //0x10e + Req_WifiGetPs = 271; //0x10f + + Req_OTABegin = 272; //0x110 + Req_OTAWrite = 273; //0x111 + Req_OTAEnd = 274; //0x112 + + Req_WifiSetMaxTxPower = 275; //0x113 + Req_WifiGetMaxTxPower = 276; //0x114 + + Req_ConfigHeartbeat = 277; //0x115 + + Req_WifiInit = 278; //0x116 + Req_WifiDeinit = 279; //0x117 + Req_WifiStart = 280; //0x118 + Req_WifiStop = 281; //0x119 + Req_WifiConnect = 282; //0x11a + Req_WifiDisconnect = 283; //0x11b + Req_WifiSetConfig = 284; //0x11c + Req_WifiGetConfig = 285; //0x11d + + Req_WifiScanStart = 286; //0x11e + Req_WifiScanStop = 287; //0x11f + Req_WifiScanGetApNum = 288; //0x120 + Req_WifiScanGetApRecords = 289; //0x121 + Req_WifiClearApList = 290; //0x122 + + Req_WifiRestore = 291; //0x123 + Req_WifiClearFastConnect = 292; //0x124 + Req_WifiDeauthSta = 293; //0x125 + Req_WifiStaGetApInfo = 294; //0x126 + //Req_WifiSetPs = 295; //0x127 + //Req_WifiGetPs = 296; //0x128 + Req_WifiSetProtocol = 297; //0x129 + Req_WifiGetProtocol = 298; //0x12a + Req_WifiSetBandwidth = 299; //0x12b + Req_WifiGetBandwidth = 300; //0x12c + Req_WifiSetChannel = 301; //0x12d + Req_WifiGetChannel = 302; //0x12e + Req_WifiSetCountry = 303; //0x12f + Req_WifiGetCountry = 304; //0x130 + +// Req_WifiSetPromiscuousRxCb = 305; //0x131 + Req_WifiSetPromiscuous = 305; //0x131 + Req_WifiGetPromiscuous = 306; //0x132 + Req_WifiSetPromiscuousFilter = 307; //0x133 + Req_WifiGetPromiscuousFilter = 308; //0x134 + Req_WifiSetPromiscuousCtrlFilter = 309; //0x135 + Req_WifiGetPromiscuousCtrlFilter = 310; //0x136 + + Req_WifiApGetStaList = 311; //0x137 + Req_WifiApGetStaAid = 312; //0x138 + Req_WifiSetStorage = 313; //0x139 + Req_WifiSetVendorIe = 314; //0x13a +// Req_WifiSetVendorIeCb = 315; //0x13b + Req_WifiSetEventMask = 315; //0x13b + Req_WifiGetEventMask = 316; //0x13c + Req_Wifi80211Tx = 317; //0x13d + +// Req_WifiSetCsiRxCb = 318; //0x13e + Req_WifiSetCsiConfig = 318; //0x13e + Req_WifiSetCsi = 319; //0x13f + + Req_WifiSetAntGpio = 320; //0x140 + Req_WifiGetAntGpio = 321; //0x141 + Req_WifiSetAnt = 322; //0x142 + Req_WifiGetAnt = 323; //0x143 + + Req_WifiGetTsfTime = 324; //0x144 + Req_WifiSetInactiveTime = 325; //0x145 + Req_WifiGetInactiveTime = 326; //0x146 + Req_WifiStatisDump = 327; //0x147 + Req_WifiSetRssiThreshold = 328; //0x148 + + Req_WifiFtmInitiateSession = 329; //0x149 + Req_WifiFtmEndSession = 330; //0x14a + Req_WifiFtmRespSetOffset = 331; //0x14b + + Req_WifiConfig11bRate = 332; //0x14c + Req_WifiConnectionlessModuleSetWakeInterval = 333; //0x14d + Req_WifiSetCountryCode = 334; //0x14e + Req_WifiGetCountryCode = 335; //0x14f + Req_WifiConfig80211TxRate = 336; //0x150 + Req_WifiDisablePmfConfig = 337; //0x151 + Req_WifiStaGetAid = 338; //0x152 + Req_WifiStaGetNegotiatedPhymode = 339; //0x153 + Req_WifiSetDynamicCs = 340; //0x154 + Req_WifiStaGetRssi = 341; //0x155 + + Req_WifiSetProtocols = 342; //0x156 + Req_WifiGetProtocols = 343; //0x157 + Req_WifiSetBandwidths = 344; //0x158 + Req_WifiGetBandwidths = 345; //0x159 + + Req_WifiSetBand = 346; //0x15a + Req_WifiGetBand = 347; //0x15b + Req_WifiSetBandMode = 348; //0x15c + Req_WifiGetBandMode = 349; //0x15d + + Req_GetCoprocessorFwVersion = 350; //0x15e + + Req_WifiScanGetApRecord = 351; //0x15f + +/* Add new control path command response before Req_Max + * and update Req_Max */ + Req_Max = 352; //0x160 + + /** Response Msgs **/ + Resp_Base = 512; + + Resp_GetMACAddress = 513; + Resp_SetMacAddress = 514; + Resp_GetWifiMode = 515; + Resp_SetWifiMode = 516; + + //Resp_GetAPScanList = 517; + //Resp_GetAPConfig = 518; + //Resp_ConnectAP = 519; + //Resp_DisconnectAP = 520; + + //Resp_GetSoftAPConfig = 521; + //Resp_SetSoftAPVendorSpecificIE = 522; + //Resp_StartSoftAP = 523; + //Resp_GetSoftAPConnectedSTAList = 524; + //Resp_StopSoftAP = 525; + + Resp_WifiSetPs = 526; + Resp_WifiGetPs = 527; + + Resp_OTABegin = 528; + Resp_OTAWrite = 529; + Resp_OTAEnd = 530; + + Resp_WifiSetMaxTxPower = 531; + Resp_WifiGetMaxTxPower = 532; + + Resp_ConfigHeartbeat = 533; + + Resp_WifiInit = 534; + Resp_WifiDeinit = 535; + Resp_WifiStart = 536; + Resp_WifiStop = 537; + Resp_WifiConnect = 538; + Resp_WifiDisconnect = 539; + Resp_WifiSetConfig = 540; + Resp_WifiGetConfig = 541; + + Resp_WifiScanStart = 542; + Resp_WifiScanStop = 543; + Resp_WifiScanGetApNum = 544; + Resp_WifiScanGetApRecords = 545; + Resp_WifiClearApList = 546; + + Resp_WifiRestore = 547; + Resp_WifiClearFastConnect = 548; + Resp_WifiDeauthSta = 549; + Resp_WifiStaGetApInfo = 550; + //Resp_WifiSetPs = 551; + //Resp_WifiGetPs = 552; + Resp_WifiSetProtocol = 553; + Resp_WifiGetProtocol = 554; + Resp_WifiSetBandwidth = 555; + Resp_WifiGetBandwidth = 556; + Resp_WifiSetChannel = 557; + Resp_WifiGetChannel = 558; + Resp_WifiSetCountry = 559; + Resp_WifiGetCountry = 560; + +// Resp_WifiSetPromiscuousRxCb = 561; + Resp_WifiSetPromiscuous = 561; + Resp_WifiGetPromiscuous = 562; + Resp_WifiSetPromiscuousFilter = 563; + Resp_WifiGetPromiscuousFilter = 564; + Resp_WifiSetPromiscuousCtrlFilter = 565; + Resp_WifiGetPromiscuousCtrlFilter = 566; + + Resp_WifiApGetStaList = 567; + Resp_WifiApGetStaAid = 568; + Resp_WifiSetStorage = 569; + Resp_WifiSetVendorIe = 570; +// Resp_WifiSetVendorIeCb = 571; + Resp_WifiSetEventMask = 571; + Resp_WifiGetEventMask = 572; + Resp_Wifi80211Tx = 573; + +// Resp_WifiSetCsiRxCb = 573; + Resp_WifiSetCsiConfig = 574; + Resp_WifiSetCsi = 575; + + Resp_WifiSetAntGpio = 576; + Resp_WifiGetAntGpio = 577; + Resp_WifiSetAnt = 578; + Resp_WifiGetAnt = 579; + + Resp_WifiGetTsfTime = 580; + Resp_WifiSetInactiveTime = 581; + Resp_WifiGetInactiveTime = 582; + Resp_WifiStatisDump = 583; + Resp_WifiSetRssiThreshold = 584; + + Resp_WifiFtmInitiateSession = 585; + Resp_WifiFtmEndSession = 586; + Resp_WifiFtmRespSetOffset = 587; + + Resp_WifiConfig11bRate = 588; + Resp_WifiConnectionlessModuleSetWakeInterval = 589; + Resp_WifiSetCountryCode = 590; + Resp_WifiGetCountryCode = 591; + Resp_WifiConfig80211TxRate = 592; + Resp_WifiDisablePmfConfig = 593; + Resp_WifiStaGetAid = 594; + Resp_WifiStaGetNegotiatedPhymode = 595; + Resp_WifiSetDynamicCs = 596; + Resp_WifiStaGetRssi = 597; + + Resp_WifiSetProtocols = 598; + Resp_WifiGetProtocols = 599; + Resp_WifiSetBandwidths = 600; + Resp_WifiGetBandwidths = 601; + + Resp_WifiSetBand = 602; + Resp_WifiGetBand = 603; + Resp_WifiSetBandMode = 604; + Resp_WifiGetBandMode = 605; + + Resp_GetCoprocessorFwVersion = 606; + + Resp_WifiScanGetApRecord = 607; + + /* Add new control path command response before Resp_Max + * and update Resp_Max */ + Resp_Max = 608; + + /** Event Msgs **/ + Event_Base = 768; + Event_ESPInit = 769; + Event_Heartbeat = 770; + Event_AP_StaConnected = 771; + Event_AP_StaDisconnected = 772; + Event_WifiEventNoArgs = 773; + Event_StaScanDone = 774; + Event_StaConnected = 775; + Event_StaDisconnected = 776; + + /* Add new control path command notification before Event_Max + * and update Event_Max */ + Event_Max = 777; +} + +message wifi_init_config { + int32 static_rx_buf_num = 1; /**< WiFi static RX buffer number */ + int32 dynamic_rx_buf_num = 2; /**< WiFi dynamic RX buffer number */ + int32 tx_buf_type = 3; /**< WiFi TX buffer type */ + int32 static_tx_buf_num = 4; /**< WiFi static TX buffer number */ + int32 dynamic_tx_buf_num = 5; /**< WiFi dynamic TX buffer number */ + int32 cache_tx_buf_num = 6; /**< WiFi TX cache buffer number */ + int32 csi_enable = 7; /**< WiFi channel state information enable flag */ + int32 ampdu_rx_enable = 8; /**< WiFi AMPDU RX feature enable flag */ + int32 ampdu_tx_enable = 9; /**< WiFi AMPDU TX feature enable flag */ + int32 amsdu_tx_enable = 10; /**< WiFi AMSDU TX feature enable flag */ + int32 nvs_enable = 11; /**< WiFi NVS flash enable flag */ + int32 nano_enable = 12; /**< Nano option for printf/scan family enable flag */ + int32 rx_ba_win = 13; /**< WiFi Block Ack RX window size */ + int32 wifi_task_core_id = 14; /**< WiFi Task Core ID */ + int32 beacon_max_len = 15; /**< WiFi softAP maximum length of the beacon */ + int32 mgmt_sbuf_num = 16; /**< WiFi management short buffer number, the minimum value is 6, the maximum value is 32 */ + uint64 feature_caps = 17; /**< Enables additional WiFi features and capabilities */ + bool sta_disconnected_pm = 18; /**< WiFi Power Management for station at disconnected status */ + int32 espnow_max_encrypt_num = 19; /**< Maximum encrypt number of peers supported by espnow */ + int32 magic = 20; /**< WiFi init magic number, it should be the last field */ +} + +message wifi_country { + bytes cc = 1; /**< country code string of 3 chars*/ + uint32 schan = 2; /**< start channel */ + uint32 nchan = 3; /**< total channel number */ + int32 max_tx_power = 4; /**< This field is used for getting WiFi maximum transmitting power, + call esp_wifi_set_max_tx_power to set the maximum transmitting power. */ + int32 policy = 5; /**< country policy */ +} + + +message wifi_active_scan_time { + uint32 min = 1; /**< minimum active scan time per channel, units: millisecond */ + uint32 max = 2; /**< maximum active scan time per channel, units: millisecond, values above 1500ms may + cause station to disconnect from AP and are not recommended. */ +} ; + +message wifi_scan_time { + wifi_active_scan_time active = 1; /**< active scan time per channel, units: millisecond. */ + uint32 passive = 2; /**< passive scan time per channel, units: millisecond, values above 1500ms may + cause station to disconnect from AP and are not recommended. */ +} + +message wifi_scan_config { + bytes ssid = 1; /**< SSID of AP 33char*/ + bytes bssid = 2; /**< MAC address of AP 6char */ + uint32 channel = 3; /**< channel, scan the specific channel */ + bool show_hidden = 4; /**< enable to scan AP whose SSID is hidden */ + int32 scan_type = 5; /**< scan type, active or passive */ + wifi_scan_time scan_time = 6; /**< scan time per channel */ + uint32 home_chan_dwell_time = 7; /**< time spent at home channel between scanning consecutive channels.*/ +} + +message wifi_he_ap_info { + //uint8_t bss_color:6; /**< an unsigned integer whose value is the BSS Color of the BSS corresponding to the AP */ + //uint8_t partial_bss_color:1; /**< indicate if an AID assignment rule based on the BSS color */ + //uint8_t bss_color_disabled:1; /**< indicate if the use of BSS color is disabled */ + uint32 bitmask = 1; /* Manually have to parse for above bits */ + uint32 bssid_index = 2; /**< in M-BSSID set, identifies the nontransmitted BSSID */ +} + +message wifi_ap_record { + bytes bssid = 1; /**< MAC address of AP 6char */ + bytes ssid = 2; /**< SSID of AP 33char */ + uint32 primary = 3; /**< channel of AP */ + int32 second = 4; /**< secondary channel of AP */ + int32 rssi = 5; /**< signal strength of AP */ + int32 authmode = 6; /**< authmode of AP */ + int32 pairwise_cipher = 7; /**< pairwise cipher of AP */ + int32 group_cipher = 8; /**< group cipher of AP */ + int32 ant = 9; /**< antenna used to receive beacon from AP */ + //uint32_t phy_11b:1; /**< bit: 0 flag to identify if 11b mode is enabled or not */ + //uint32_t phy_11g:1; /**< bit: 1 flag to identify if 11g mode is enabled or not */ + //uint32_t phy_11n:1; /**< bit: 2 flag to identify if 11n mode is enabled or not */ + //uint32_t phy_lr:1; /**< bit: 3 flag to identify if low rate is enabled or not */ + //uint32_t wps:1; /**< bit: 4 flag to identify if WPS is supported or not */ + //uint32_t ftm_responder:1; /**< bit: 5 flag to identify if FTM is supported in responder mode */ + //uint32_t ftm_initiator:1; /**< bit: 6 flag to identify if FTM is supported in initiator mode */ + //uint32_t reserved:25; /**< bit: 7..31 reserved */ + uint32 bitmask = 10; /* Manually have to parse for above bits */ + + wifi_country country = 11; /**< country information of AP */ + wifi_he_ap_info he_ap = 12; + uint32 bandwidth = 13; /**< For AP 20 MHz this value is set to 1. For AP 40 MHz this value is set to 2. + For AP 80 MHz this value is set to 3. For AP 160MHz this value is set to 4. + For AP 80+80MHz this value is set to 5*/ + uint32 vht_ch_freq1 = 14; /**< This fields are used only AP bandwidth is 80 and 160 MHz, to transmit the center channel + frequency of the BSS. For AP bandwidth is 80 + 80 MHz, it is the center channel frequency + of the lower frequency segment.*/ + uint32 vht_ch_freq2 = 15; /**< This fields are used only AP bandwidth is 80 + 80 MHz, and is used to transmit the center + channel frequency of the second segment. */ +} + +message wifi_scan_threshold { + int32 rssi = 1; /**< The minimum rssi to accept in the fast scan mode */ + int32 authmode = 2; /**< The weakest authmode to accept in the fast scan mode +Note: Incase this value is not set and password is set as per WPA2 standards(password len >= 8), +it will be defaulted to WPA2 and device won't connect to deprecated WEP/WPA networks. +Please set authmode threshold as WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK to connect to WEP/WPA networks */ +} + +message wifi_pmf_config { + bool capable = 1; /**< Deprecated variable. Device will always connect in PMF mode if other device also advertizes PMF capability. */ + bool required = 2; /**< Advertizes that Protected Management Frame is required. Device will not associate to non-PMF capable devices. */ +} + +message wifi_ap_config { + bytes ssid = 1; /**< SSID of ESP32 soft-AP. If ssid_len field is 0, this must be a Null terminated string. Otherwise, length is set according to ssid_len. 32 char*/ + bytes password = 2; /**< Password of ESP32 soft-AP. 64 char*/ + uint32 ssid_len = 3; /**< Optional length of SSID field. */ + uint32 channel = 4; /**< Channel of ESP32 soft-AP */ + int32 authmode = 5; /**< Auth mode of ESP32 soft-AP. Do not support AUTH_WEP in soft-AP mode */ + uint32 ssid_hidden = 6; /**< Broadcast SSID or not, default 0, broadcast the SSID */ + uint32 max_connection = 7; /**< Max number of stations allowed to connect in */ + uint32 beacon_interval = 8; /**< Beacon interval which should be multiples of 100. Unit: TU(time unit, 1 TU = 1024 us). Range: 100 ~ 60000. Default value: 100 */ + int32 pairwise_cipher = 9; /**< pairwise cipher of SoftAP, group cipher will be derived using this. + cipher values are valid starting from WIFI_CIPHER_TYPE_TKIP, enum values before that will be considered as invalid and default cipher suites(TKIP+CCMP) will be used. + Valid cipher suites in softAP mode are WIFI_CIPHER_TYPE_TKIP, WIFI_CIPHER_TYPE_CCMP and WIFI_CIPHER_TYPE_TKIP_CCMP. */ + bool ftm_responder = 10; /**< Enable FTM Responder mode */ + wifi_pmf_config pmf_cfg = 11; /**< Configuration for Protected Management Frame */ + int32 sae_pwe_h2e = 12; /**< Configuration for SAE PWE derivation method */ +} + +message wifi_sta_config { + bytes ssid = 1; /**< SSID of target AP. 32char */ + bytes password = 2; /**< Password of target AP. 64char */ + int32 scan_method = 3; /**< do all channel scan or fast scan */ + bool bssid_set = 4; /**< whether set MAC address of target AP or not. Generally, station_config.bssid_set needs to be 0, + and it needs to be 1 only when users need to check the MAC address of the AP.*/ + bytes bssid = 5; /**< MAC address of target AP 6char */ + uint32 channel = 6; /**< channel of target AP. Set to 1~13 to scan starting from the specified channel + before connecting to AP. If the channel of AP is unknown, set it to 0.*/ + uint32 listen_interval = 7; /**< Listen interval for ESP32 station to receive beacon when WIFI_PS_MAX_MODEM is set. +Units: AP beacon intervals. Defaults to 3 if set to 0. */ + int32 sort_method = 8; /**< sort the connect AP in the list by rssi or security mode */ + wifi_scan_threshold threshold = 9; /**< When sort_method is set, only APs which have an auth mode that is more secure + than the selected auth mode and a signal stronger than the minimum RSSI will be used. */ + wifi_pmf_config pmf_cfg = 10; /**< Configuration for Protected Management Frame. Will be advertized in RSN Capabilities in RSN IE. */ + //uint32_t rm_enabled:1; /**< Whether Radio Measurements are enabled for the connection */ + //uint32_t btm_enabled:1; /**< Whether BSS Transition Management is enabled for the connection */ + //uint32_t mbo_enabled:1; /**< Whether MBO is enabled for the connection */ + //uint32_t ft_enabled:1; /**< Whether FT is enabled for the connection */ + //uint32_t owe_enabled:1; /**< Whether OWE is enabled for the connection */ + //uint32_t transition_disable:1; /**< Whether to enable transition disable feature */ + //uint32_t reserved:26; /**< Reserved for future feature set */ + uint32 bitmask = 11; + int32 sae_pwe_h2e = 12; /**< Whether SAE hash to element is enabled */ + uint32 failure_retry_cnt = 13; /**< Number of connection retries station will do before moving to next AP. + scan_method should be set as WIFI_ALL_CHANNEL_SCAN to use this config. + Note: Enabling this may cause connection time to increase incase best AP doesn't behave properly. */ + //uint32_t he_dcm_set:1; /**< Whether DCM max.constellation for transmission and reception is set. */ + //uint32_t he_dcm_max_constellation_tx:2; /**< Indicate the max.constellation for DCM in TB PPDU the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. */ + //uint32_t he_dcm_max_constellation_rx:2; /**< Indicate the max.constellation for DCM in both Data field and HE-SIG-B field the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. */ + //uint32_t he_mcs9_enabled:1; /**< Whether to support HE-MCS 0 to 9. The default value is 0. */ + //uint32_t he_su_beamformee_disabled:1; /**< Whether to disable support for operation as an SU beamformee. */ + //uint32_t he_trig_su_bmforming_feedback_disabled:1; /**< Whether to disable support the transmission of SU feedback in an HE TB sounding sequence. */ + //uint32_t he_trig_mu_bmforming_partial_feedback_disabled:1; /**< Whether to disable support the transmission of partial-bandwidth MU feedback in an HE TB sounding sequence. */ + // uint32_t he_trig_cqi_feedback_disabled:1; /**< Whether to disable support the transmission of CQI feedback in an HE TB sounding sequence. */ + // uint32_t he_reserved:22; /**< Reserved for future feature set */ + uint32 he_bitmask = 14; + bytes sae_h2e_identifier = 15; /**< Password identifier for H2E. this needs to be null terminated string. SAE_H2E_IDENTIFIER_LEN chars */ +} + +message wifi_config { + oneof u { + wifi_ap_config ap = 1; /**< configuration of AP */ + wifi_sta_config sta = 2; /**< configuration of STA */ + } +} + +message wifi_sta_info { + bytes mac = 1; /**< mac address 6 char */ + int32 rssi = 2; /**< current average rssi of sta connected */ + //uint32_t phy_11b:1; /**< bit: 0 flag to identify if 11b mode is enabled or not */ + //uint32_t phy_11g:1; /**< bit: 1 flag to identify if 11g mode is enabled or not */ + //uint32_t phy_11n:1; /**< bit: 2 flag to identify if 11n mode is enabled or not */ + //uint32_t phy_lr:1; /**< bit: 3 flag to identify if low rate is enabled or not */ + //uint32_t phy_11x:1; /**< bit: 4 flag to identify identify if 11ax mode is enabled or not */ + //uint32_t is_mesh_child:1; /**< bit: 5 flag to identify mesh child */ + //uint32_t reserved:26; /**< bit: 6..31 reserved */ + uint32 bitmask = 3; +} + +message wifi_sta_list { + repeated wifi_sta_info sta = 1; /**< station list */ + int32 num = 2; /**< number of stations in the list (other entries are invalid) */ +} + +//message vendor_ie_data { +// uint32 element_id = 1; /**< Should be set to WIFI_VENDOR_IE_ELEMENT_ID (0xDD) */ +// uint32 length = 2; /**< Length of all bytes in the element data following this field. Minimum 4. */ +// bytes vendor_oui = 3; /**< Vendor identifier (OUI). 3 chars */ +// uint32 vendor_oui_type = 4; /**< Vendor-specific OUI type. */ +// bytes payload = 5; /**< Payload. Length is equal to value in 'length' field, minus 4. Note: Variable size */ +//} + +message wifi_pkt_rx_ctrl { + int32 rssi = 1; /**< 8bits Received Signal Strength Indicator(RSSI) of packet. unit: dBm */ + uint32 rate = 2; /**< 5bits PHY rate encoding of the packet. Only valid for non HT(11bg) packet */ + //uint32 :1; /**< reserved */ + uint32 sig_mode = 3; /**< 2bits 0: non HT(11bg) packet; 1: HT(11n) packet; 3: VHT(11ac) packet */ + //uint32 :16; /**< reserved */ + uint32 mcs = 4; /**< 7bits Modulation Coding Scheme. If is HT(11n) packet, shows the modulation, range from 0 to 76(MSC0 ~ MCS76) */ + uint32 cwb = 5; /**< 1bit Channel Bandwidth of the packet. 0: 20MHz; 1: 40MHz */ + //uint32 :16; /**< reserved */ + uint32 smoothing = 6; /**< 1bit reserved */ + uint32 not_sounding = 7; /**< 1bit reserved */ + //uint32 :1; /**< reserved */ + uint32 aggregation = 8; /**< 1bit Aggregation. 0: MPDU packet; 1: AMPDU packet */ + uint32 stbc = 9; /**< 2bits Space Time Block Code(STBC). 0: non STBC packet; 1: STBC packet */ + uint32 fec_coding = 10; /**< 1bit Flag is set for 11n packets which are LDPC */ + uint32 sgi = 11; /**< 1bit Short Guide Interval(SGI). 0: Long GI; 1: Short GI */ + int32 noise_floor = 12; /**< 8bits noise floor of Radio Frequency Module(RF). unit: dBm*/ + uint32 ampdu_cnt = 13; /**< 8bits ampdu cnt */ + uint32 channel = 14; /**< 4bits primary channel on which this packet is received */ + uint32 secondary_channel = 15; /**< 4bits secondary channel on which this packet is received. 0: none; 1: above; 2: below */ + //uint32 :8; /**< reserved */ + uint32 timestamp = 16; /**< 32bit timestamp. The local time when this packet is received. It is precise only if modem sleep or light sleep is not enabled. unit: microsecond */ + //uint32 :32; /**< reserved */ + //unsigned :32; /**< reserved */ + //unsigned :31; /**< reserved */ + uint32 ant = 17; /**< 1bit antenna number from which this packet is received. 0: WiFi antenna 0; 1: WiFi antenna 1 */ + uint32 sig_len = 18; /**< 12bits length of packet including Frame Check Sequence(FCS) */ + //unsigned :12; /**< reserved */ + uint32 rx_state = 19; /**< 8bits state of the packet. 0: no error; others: error numbers which are not public */ +} + +message wifi_promiscuous_pkt { + wifi_pkt_rx_ctrl rx_ctrl = 1; /**< metadata header */ + bytes payload = 2; /**< Note: variable length. Data or management payload. Length of payload is described by rx_ctrl.sig_len. Type of content determined by packet type argument of callback. */ +} + +message wifi_promiscuous_filter { + uint32 filter_mask = 1; /**< OR of one or more filter values WIFI_PROMIS_FILTER_* */ +} + +message wifi_csi_config { + bool lltf_en = 1; /**< enable to receive legacy long training field(lltf) data. Default enabled */ + bool htltf_en = 2; /**< enable to receive HT long training field(htltf) data. Default enabled */ + bool stbc_htltf2_en = 3; /**< enable to receive space time block code HT long training field(stbc-htltf2) data. Default enabled */ + bool ltf_merge_en = 4; /**< enable to generate htlft data by averaging lltf and ht_ltf data when receiving HT packet. Otherwise, use ht_ltf data directly. Default enabled */ + bool channel_filter_en = 5; /**< enable to turn on channel filter to smooth adjacent sub-carrier. Disable it to keep independence of adjacent sub-carrier. Default enabled */ + bool manu_scale = 6; /**< manually scale the CSI data by left shifting or automatically scale the CSI data. + If set true, please set the shift bits. false: automatically. true: manually. Default false */ + uint32 shift = 7; /**< manually left shift bits of the scale of the CSI data. The range of the left shift bits is 0~15 */ +} + +message wifi_csi_info { + wifi_pkt_rx_ctrl rx_ctrl = 1; /**< received packet radio metadata header of the CSI data */ + bytes mac = 2; /**< 6bits source MAC address of the CSI data */ + bytes dmac = 3; /**< 6bits destination MAC address of the CSI data */ + bool first_word_invalid = 4; /**< first four bytes of the CSI data is invalid or not */ + bytes buf = 5; /**< Note: variable length. buffer of CSI data */ + uint32 len = 6; /**< length of CSI data */ +} + +message wifi_ant_gpio { + uint32 gpio_select = 1; /**< 1bit Whether this GPIO is connected to external antenna switch */ + uint32 gpio_num = 2; /**< 7bits The GPIO number that connects to external antenna switch */ +} + +message wifi_ant_gpio_config { + repeated wifi_ant_gpio gpio_cfgs = 1; /**< The configurations of GPIOs that connect to external antenna switch */ +} + +message wifi_ant_config { + int32 rx_ant_mode = 1; /**< WiFi antenna mode for receiving */ + int32 rx_ant_default = 2; /**< Default antenna mode for receiving, it's ignored if rx_ant_mode is not WIFI_ANT_MODE_AUTO */ + int32 tx_ant_mode = 3; /**< WiFi antenna mode for transmission, it can be set to WIFI_ANT_MODE_AUTO only if rx_ant_mode is set to WIFI_ANT_MODE_AUTO */ + uint32 enabled_ant0 = 4; /**< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT0 */ + uint32 enabled_ant1 = 5; /**< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT1 */ +} + +message wifi_action_tx_req { + int32 ifx = 1; /**< WiFi interface to send request to */ + bytes dest_mac = 2; /**< 6bits Destination MAC address */ + bool no_ack = 3; /**< Indicates no ack required */ + //TODO + //wifi_action_rx_cb_t rx_cb; /**< Rx Callback to receive any response */ + uint32 data_len = 4; /**< Length of the appended Data */ + bytes data = 5; /**< note: variable length. Appended Data payload */ +} + +message wifi_ftm_initiator_cfg { + bytes resp_mac = 1; /**< 6bits MAC address of the FTM Responder */ + uint32 channel = 2; /**< Primary channel of the FTM Responder */ + uint32 frm_count = 3; /**< No. of FTM frames requested in terms of 4 or 8 bursts (allowed values - 0(No pref), 16, 24, 32, 64) */ + uint32 burst_period = 4; /**< Requested time period between consecutive FTM bursts in 100's of milliseconds (0 - No pref) */ +} + +message wifi_event_sta_scan_done { + uint32 status = 1; /**< status of scanning APs: 0 — success, 1 - failure */ + uint32 number = 2; /**< number of scan results */ + uint32 scan_id = 3; /**< scan sequence number, used for block scan */ +} + +message wifi_event_sta_connected { + bytes ssid = 1; /**< 32bytes SSID of connected AP */ + uint32 ssid_len = 2; /**< SSID length of connected AP */ + bytes bssid = 3; /**< 6bytes BSSID of connected AP*/ + uint32 channel = 4; /**< channel of connected AP*/ + int32 authmode = 5; /**< authentication mode used by AP*/ + int32 aid = 6; /**< authentication id assigned by the connected AP*/ +} + +message wifi_event_sta_disconnected { + bytes ssid = 1; /**< SSID of disconnected AP */ + uint32 ssid_len = 2; /**< SSID length of disconnected AP */ + bytes bssid = 3; /**< BSSID of disconnected AP */ + uint32 reason = 4; /**< reason of disconnection */ + int32 rssi = 5; /**< rssi of disconnection */ +} + +message wifi_event_sta_authmode_change { + int32 old_mode = 1; /**< the old auth mode of AP */ + int32 new_mode = 2; /**< the new auth mode of AP */ +} + +message wifi_event_sta_wps_er_pin { + bytes pin_code = 1; /**< 8bytes PIN code of station in enrollee mode */ +} + +message ap_cred { + bytes ssid = 1; /**< 32bytes SSID of AP */ + bytes passphrase = 2; /**< 64bytes Passphrase for the AP */ +} + +message wifi_event_sta_wps_er_success { + uint32 ap_cred_cnt = 1; /**< Number of AP credentials received */ + repeated ap_cred ap_creds = 2; /**< All AP credentials received from WPS handshake */ +} + +/** Argument structure for WIFI_EVENT_AP_PROBEREQRECVED event */ +message wifi_event_ap_probe_req_rx { + int32 rssi = 1; /**< Received probe request signal strength */ + uint32 mac = 2; /**< MAC address of the station which send probe request */ +} + +/** Argument structure for WIFI_EVENT_STA_BSS_RSSI_LOW event */ +message wifi_event_bss_rssi_low { + int32 rssi = 1; /**< RSSI value of bss */ +} + +message wifi_ftm_report_entry { + uint32 dlog_token = 1; /* *< Dialog Token of the FTM frame */ + int32 rssi = 2; /* *< RSSI of the FTM frame received */ + uint32 rtt = 3; /* *< Round Trip Time in pSec with a peer */ + /* TODO: uint32 is supported by proto? */ + uint64 t1 = 4; /* *< Time of departure of FTM frame from FTM Responder in pSec */ + uint64 t2 = 5; /* *< Time of arrival of FTM frame at FTM Initiator in pSec */ + uint64 t3 = 6; /* *< Time of departure of ACK from FTM Initiator in pSec */ + uint64 t4 = 7; /* *< Time of arrival of ACK at FTM Responder in pSec */ +} + +message wifi_event_ftm_report { + bytes peer_mac = 1; /* *< 6bytes MAC address of the FTM Peer */ + int32 status = 2; /* *< Status of the FTM operation */ + uint32 rtt_raw = 3; /* *< Raw average Round-Trip-Time with peer in Nano-Seconds */ + uint32 rtt_est = 4; /* *< Estimated Round-Trip-Time with peer in Nano-Seconds */ + uint32 dist_est = 5; /* *< Estimated one-way distance in Centi-Meters */ + repeated wifi_ftm_report_entry ftm_report_data = 6; /* *< Note var len Pointer to FTM Report with multiple entries, should be freed after use */ + uint32 ftm_report_num_entries = 7; /* *< Number of entries in the FTM Report data */ +} + +message wifi_event_action_tx_status { + int32 ifx = 1; /**< WiFi interface to send request to */ + uint32 context = 2; /**< Context to identify the request */ + bytes da = 3; /**< 6bytes Destination MAC address */ + uint32 status = 4; /**< Status of the operation */ +} + +message wifi_event_roc_done { + uint32 context = 1; /**< Context to identify the request */ +} + +message wifi_event_ap_wps_rg_pin { + bytes pin_code = 1; /**< 8bytes PIN code of station in enrollee mode */ +} + +message wifi_event_ap_wps_rg_fail_reason { + int32 reason = 1; /**< WPS failure reason wps_fail_reason_t */ + bytes peer_macaddr = 2; /**< 6bytes Enrollee mac address */ +} + +message wifi_event_ap_wps_rg_success { + bytes peer_macaddr = 1; /**< 6bytes Enrollee mac address */ +} + +message wifi_protocols { + uint32 ghz_2g = 1; /**< Represents 2.4 GHz protocol, support 802.11b or 802.11g or 802.11n or 802.11ax or LR mode */ + uint32 ghz_5g = 2; /**< Represents 5 GHz protocol, support 802.11a or 802.11n or 802.11ac or 802.11ax */ +} + +message wifi_bandwidths { + uint32 ghz_2g = 1; /* Represents 2.4 GHz bandwidth */ + uint32 ghz_5g = 2; /* Represents 5 GHz bandwidth */ +} + +/* internal supporting structures for Rpc */ +//message ScanResult { +// bytes bssid = 1; +// bytes ssid = 2; +// uint32 chnl = 3; +// int32 rssi = 4; +// int32 sec_prot = 5; +//} + +message ConnectedSTAList { + bytes mac = 1; + int32 rssi = 2; +} + + +/* Control path structures */ +/** Req/Resp structure **/ +message Rpc_Req_GetMacAddress { + int32 mode = 1; +} + +message Rpc_Resp_GetMacAddress { + bytes mac = 1; + int32 resp = 2; +} + +message Rpc_Req_GetMode { +} + +message Rpc_Resp_GetMode { + int32 mode = 1; + int32 resp = 2; +} + +message Rpc_Req_SetMode { + int32 mode = 1; +} + +message Rpc_Resp_SetMode { + int32 resp = 1; +} + +message Rpc_Req_GetPs { +} + +message Rpc_Resp_GetPs { + int32 resp = 1; + int32 type = 2; +} + +message Rpc_Req_SetPs { + int32 type = 1; +} + +message Rpc_Resp_SetPs { + int32 resp = 1; +} + +message Rpc_Req_SetMacAddress { + bytes mac = 1; + int32 mode = 2; +} + +message Rpc_Resp_SetMacAddress { + int32 resp = 1; +} + + +//message Rpc_Req_GetAPConfig { +//} +// +///* To be deprecated */ +//message Rpc_Resp_GetAPConfig { +// bytes ssid = 1; +// bytes bssid = 2; +// int32 rssi = 3; +// int32 chnl = 4; +// int32 sec_prot = 5; +// int32 resp = 6; +//} + +/* To be deprecated */ +//message Rpc_Req_ConnectAP { +// string ssid = 1; +// string pwd = 2; +// string bssid = 3; +// bool is_wpa3_supported = 4; +// int32 listen_interval = 5; +//} +// +//message Rpc_Resp_ConnectAP { +// int32 resp = 1; +// bytes mac = 2; +//} + +//message Rpc_Req_GetSoftAPConfig { +//} +// +//message Rpc_Resp_GetSoftAPConfig { +// bytes ssid = 1; +// bytes pwd = 2; +// int32 chnl = 3; +// int32 sec_prot = 4; +// int32 max_conn = 5; +// bool ssid_hidden = 6; +// int32 bw = 7; +// int32 resp = 8; +//} + +//message Rpc_Req_StartSoftAP { +// string ssid = 1; +// string pwd = 2; +// int32 chnl = 3; +// int32 sec_prot = 4; +// int32 max_conn = 5; +// bool ssid_hidden = 6; +// int32 bw = 7; +//} +// +//message Rpc_Resp_StartSoftAP { +// int32 resp = 1; +// bytes mac = 2; +//} + +//message Rpc_Req_ScanResult { +//} +// +//message Rpc_Resp_ScanResult { +// uint32 count = 1; +// repeated ScanResult entries = 2; +// int32 resp = 3; +//} + +//message Rpc_Req_SoftAPConnectedSTA { +//} +// +//message Rpc_Resp_SoftAPConnectedSTA { +// uint32 num = 1; +// repeated ConnectedSTAList stations = 2; +// int32 resp = 3; +//} + +message Rpc_Req_OTABegin { +} + +message Rpc_Resp_OTABegin { + int32 resp = 1; +} + +message Rpc_Req_OTAWrite { + bytes ota_data = 1; +} + +message Rpc_Resp_OTAWrite { + int32 resp = 1; +} + +message Rpc_Req_OTAEnd { +} + +message Rpc_Resp_OTAEnd { + int32 resp = 1; +} + +//message Rpc_Req_VendorIEData { +// int32 element_id = 1; +// int32 length = 2; +// bytes vendor_oui = 3; +// int32 vendor_oui_type = 4; +// bytes payload = 5; +//} +// +//message Rpc_Req_SetSoftAPVendorSpecificIE { +// bool enable = 1; +// int32 type = 2; +// int32 idx = 3; +// Rpc_Req_VendorIEData vendor_ie_data = 4; +//} +// +//message Rpc_Resp_SetSoftAPVendorSpecificIE { +// int32 resp = 1; +//} + +message Rpc_Req_WifiSetMaxTxPower { + int32 power = 1; +} + +message Rpc_Resp_WifiSetMaxTxPower { + int32 resp = 1; +} + +message Rpc_Req_WifiGetMaxTxPower { +} + +message Rpc_Resp_WifiGetMaxTxPower { + int32 power = 1; + int32 resp = 2; +} + +message Rpc_Req_ConfigHeartbeat { + bool enable = 1; + int32 duration = 2; +} + +message Rpc_Resp_ConfigHeartbeat { + int32 resp = 1; +} + +message Rpc_Req_WifiInit { + wifi_init_config cfg = 1; +} + +message Rpc_Resp_WifiInit { + int32 resp = 1; +} + +message Rpc_Req_WifiDeinit { +} + +message Rpc_Resp_WifiDeinit { + int32 resp = 1; +} + +message Rpc_Req_WifiSetConfig { + int32 iface = 1; + wifi_config cfg = 2; +} + +message Rpc_Resp_WifiSetConfig { + int32 resp = 1; +} + +message Rpc_Req_WifiGetConfig { + int32 iface = 1; +} + +message Rpc_Resp_WifiGetConfig { + int32 resp = 1; + int32 iface = 2; + wifi_config cfg = 3; +} + +message Rpc_Req_WifiConnect { +} + +message Rpc_Resp_WifiConnect { + int32 resp = 1; +} + +message Rpc_Req_WifiDisconnect { +} + +message Rpc_Resp_WifiDisconnect { + int32 resp = 1; +} + +message Rpc_Req_WifiStart { +} + +message Rpc_Resp_WifiStart { + int32 resp = 1; +} + +message Rpc_Req_WifiStop { +} + +message Rpc_Resp_WifiStop { + int32 resp = 1; +} + +message Rpc_Req_WifiScanStart { + wifi_scan_config config = 1; + bool block = 2; + int32 config_set = 3; +} + +message Rpc_Resp_WifiScanStart { + int32 resp = 1; +} + +message Rpc_Req_WifiScanStop { +} + +message Rpc_Resp_WifiScanStop { + int32 resp = 1; +} + +message Rpc_Req_WifiScanGetApNum { +} + +message Rpc_Resp_WifiScanGetApNum { + int32 resp = 1; + int32 number = 2; +} + +message Rpc_Req_WifiScanGetApRecords { + int32 number = 1; +} + +message Rpc_Resp_WifiScanGetApRecords { + int32 resp = 1; + int32 number = 2; + repeated wifi_ap_record ap_records = 3; +} + +message Rpc_Req_WifiScanGetApRecord { +} + +message Rpc_Resp_WifiScanGetApRecord { + int32 resp = 1; + wifi_ap_record ap_record = 2; +} + +message Rpc_Req_WifiClearApList { +} + +message Rpc_Resp_WifiClearApList { + int32 resp = 1; +} + +message Rpc_Req_WifiRestore { +} + +message Rpc_Resp_WifiRestore { + int32 resp = 1; +} + +message Rpc_Req_WifiClearFastConnect{ +} + +message Rpc_Resp_WifiClearFastConnect { + int32 resp = 1; +} + +message Rpc_Req_WifiDeauthSta { + int32 aid = 1; +} + +message Rpc_Resp_WifiDeauthSta { + int32 resp = 1; + int32 aid = 2; +} + +message Rpc_Req_WifiStaGetApInfo { +} + +message Rpc_Resp_WifiStaGetApInfo { + int32 resp = 1; + wifi_ap_record ap_record = 2; +} + +message Rpc_Req_WifiSetProtocol { + int32 ifx = 1; + int32 protocol_bitmap = 2; +} + +message Rpc_Resp_WifiSetProtocol { + int32 resp = 1; +} + +message Rpc_Req_WifiGetProtocol { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetProtocol { + int32 resp = 1; + int32 protocol_bitmap = 2; +} + +message Rpc_Req_WifiSetBandwidth { + int32 ifx = 1; + int32 bw = 2; +} + +message Rpc_Resp_WifiSetBandwidth { + int32 resp = 1; +} + +message Rpc_Req_WifiGetBandwidth { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetBandwidth { + int32 resp = 1; + int32 bw = 2; +} + +message Rpc_Req_WifiSetChannel { + int32 primary = 1; + int32 second = 2; +} + +message Rpc_Resp_WifiSetChannel { + int32 resp = 1; +} + +message Rpc_Req_WifiGetChannel { +} + +message Rpc_Resp_WifiGetChannel { + int32 resp = 1; + int32 primary = 2; + int32 second = 3; +} + +message Rpc_Req_WifiSetStorage { + int32 storage = 1; +} + +message Rpc_Resp_WifiSetStorage { + int32 resp = 1; +} + +message Rpc_Req_WifiSetCountryCode { + bytes country = 1; + bool ieee80211d_enabled = 2; +} + +message Rpc_Resp_WifiSetCountryCode { + int32 resp = 1; +} + +message Rpc_Req_WifiGetCountryCode { +} + +message Rpc_Resp_WifiGetCountryCode { + int32 resp = 1; + bytes country = 2; +} + +message Rpc_Req_WifiSetCountry { + wifi_country country = 1; +} + +message Rpc_Resp_WifiSetCountry { + int32 resp = 1; +} + +message Rpc_Req_WifiGetCountry { +} + +message Rpc_Resp_WifiGetCountry { + int32 resp = 1; + wifi_country country = 2; +} + +message Rpc_Req_WifiApGetStaList { +} + +message Rpc_Resp_WifiApGetStaList { + int32 resp = 1; + wifi_sta_list sta_list = 2; +} + +message Rpc_Req_WifiApGetStaAid { + bytes mac = 1; +} + +message Rpc_Req_WifiStaGetNegotiatedPhymode { +} + +message Rpc_Resp_WifiStaGetNegotiatedPhymode { + int32 resp = 1; + uint32 phymode = 2; +} + +message Rpc_Resp_WifiApGetStaAid { + int32 resp = 1; + uint32 aid = 2; +} + +message Rpc_Req_WifiStaGetRssi { +} + +message Rpc_Resp_WifiStaGetRssi { + int32 resp = 1; + int32 rssi = 2; +} + +message Rpc_Req_WifiStaGetAid { +} + +message Rpc_Resp_WifiStaGetAid { + int32 resp = 1; + uint32 aid = 2; +} + +message Rpc_Req_WifiSetProtocols { + int32 ifx = 1; + wifi_protocols protocols = 2; +} + +message Rpc_Resp_WifiSetProtocols { + int32 resp = 1; + uint32 ifx = 2; +} + +message Rpc_Req_WifiGetProtocols { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetProtocols { + int32 resp = 1; + int32 ifx = 2; + wifi_protocols protocols = 3; +} + +message Rpc_Req_WifiSetBandwidths { + int32 ifx = 1; + wifi_bandwidths bandwidths = 2; +} + +message Rpc_Resp_WifiSetBandwidths { + int32 resp = 1; + int32 ifx = 2; +} + +message Rpc_Req_WifiGetBandwidths { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetBandwidths { + int32 resp = 1; + int32 ifx = 2; + wifi_bandwidths bandwidths = 3; +} + +message Rpc_Req_WifiSetBand { + uint32 band = 1; +} + +message Rpc_Resp_WifiSetBand { + int32 resp = 1; +} + +message Rpc_Req_WifiGetBand { +} + +message Rpc_Resp_WifiGetBand { + int32 resp = 1; + uint32 band = 2; +} + +message Rpc_Req_WifiSetBandMode { + uint32 bandmode = 1; +} + +message Rpc_Resp_WifiSetBandMode { + int32 resp = 1; +} + +message Rpc_Req_WifiGetBandMode { +} + +message Rpc_Resp_WifiGetBandMode { + int32 resp = 1; + uint32 bandmode = 2; +} + +message Rpc_Req_GetCoprocessorFwVersion { +} + +message Rpc_Resp_GetCoprocessorFwVersion { + int32 resp = 1; + uint32 major1 = 2; + uint32 minor1 = 3; + uint32 patch1 = 4; +} + +/** Event structure **/ + +message Rpc_Event_WifiEventNoArgs { + int32 resp = 1; + int32 event_id = 2; +} + +message Rpc_Event_ESPInit { + bytes init_data = 1; +} + +message Rpc_Event_Heartbeat { + int32 hb_num = 1; +} + +message Rpc_Event_AP_StaDisconnected { + int32 resp = 1; + bytes mac = 2; + uint32 aid = 3; + bool is_mesh_child = 4; + uint32 reason = 5; +} + +message Rpc_Event_AP_StaConnected { + int32 resp = 1; + bytes mac = 2; + uint32 aid = 3; + bool is_mesh_child = 4; +} + +message Rpc_Event_StaScanDone { + int32 resp = 1; + wifi_event_sta_scan_done scan_done = 2; +} + +message Rpc_Event_StaConnected { + int32 resp = 1; + wifi_event_sta_connected sta_connected = 2; +} + +message Rpc_Event_StaDisconnected { + int32 resp = 1; + wifi_event_sta_disconnected sta_disconnected = 2; +} + +message Rpc { + /* msg_type could be req, resp or Event */ + RpcType msg_type = 1; + + /* msg id */ + RpcId msg_id = 2; + + /* UID of message */ + uint32 uid = 3; + + /* union of all msg ids */ + oneof payload { + /** Requests **/ + Rpc_Req_GetMacAddress req_get_mac_address = 257; + Rpc_Req_SetMacAddress req_set_mac_address = 258; + Rpc_Req_GetMode req_get_wifi_mode = 259; + Rpc_Req_SetMode req_set_wifi_mode = 260; + + //Rpc_Req_ScanResult req_scan_ap_list = 261; + //Rpc_Req_GetAPConfig req_get_ap_config = 262; + //Rpc_Req_ConnectAP req_connect_ap = 263; + //Rpc_Req_GetStatus req_disconnect_ap = 264; + + //Rpc_Req_GetSoftAPConfig req_get_softap_config = 265; + //Rpc_Req_SetSoftAPVendorSpecificIE req_set_softap_vendor_specific_ie = 266; + //Rpc_Req_StartSoftAP req_start_softap = 267; + //Rpc_Req_SoftAPConnectedSTA req_softap_connected_stas_list = 268; + //Rpc_Req_GetStatus req_stop_softap = 269; + + Rpc_Req_SetPs req_wifi_set_ps = 270; + Rpc_Req_GetPs req_wifi_get_ps = 271; + + Rpc_Req_OTABegin req_ota_begin = 272; + Rpc_Req_OTAWrite req_ota_write = 273; + Rpc_Req_OTAEnd req_ota_end = 274; + + Rpc_Req_WifiSetMaxTxPower req_set_wifi_max_tx_power = 275; + Rpc_Req_WifiGetMaxTxPower req_get_wifi_max_tx_power = 276; + Rpc_Req_ConfigHeartbeat req_config_heartbeat = 277; + + Rpc_Req_WifiInit req_wifi_init = 278; + Rpc_Req_WifiDeinit req_wifi_deinit = 279; + Rpc_Req_WifiStart req_wifi_start = 280; + Rpc_Req_WifiStop req_wifi_stop = 281; + Rpc_Req_WifiConnect req_wifi_connect = 282; + Rpc_Req_WifiDisconnect req_wifi_disconnect = 283; + Rpc_Req_WifiSetConfig req_wifi_set_config = 284; + Rpc_Req_WifiGetConfig req_wifi_get_config = 285; + + Rpc_Req_WifiScanStart req_wifi_scan_start = 286; + Rpc_Req_WifiScanStop req_wifi_scan_stop = 287; + Rpc_Req_WifiScanGetApNum req_wifi_scan_get_ap_num = 288; + Rpc_Req_WifiScanGetApRecords req_wifi_scan_get_ap_records = 289; + Rpc_Req_WifiClearApList req_wifi_clear_ap_list = 290; + + Rpc_Req_WifiRestore req_wifi_restore = 291; + Rpc_Req_WifiClearFastConnect req_wifi_clear_fast_connect = 292; + Rpc_Req_WifiDeauthSta req_wifi_deauth_sta = 293; + Rpc_Req_WifiStaGetApInfo req_wifi_sta_get_ap_info = 294; + + Rpc_Req_WifiSetProtocol req_wifi_set_protocol = 297; + Rpc_Req_WifiGetProtocol req_wifi_get_protocol = 298; + Rpc_Req_WifiSetBandwidth req_wifi_set_bandwidth = 299; + Rpc_Req_WifiGetBandwidth req_wifi_get_bandwidth = 300; + Rpc_Req_WifiSetChannel req_wifi_set_channel = 301; + Rpc_Req_WifiGetChannel req_wifi_get_channel = 302; + Rpc_Req_WifiSetCountry req_wifi_set_country = 303; + Rpc_Req_WifiGetCountry req_wifi_get_country = 304; + + Rpc_Req_WifiApGetStaList req_wifi_ap_get_sta_list = 311; + Rpc_Req_WifiApGetStaAid req_wifi_ap_get_sta_aid = 312; + Rpc_Req_WifiSetStorage req_wifi_set_storage = 313; + + Rpc_Req_WifiSetCountryCode req_wifi_set_country_code = 334; + Rpc_Req_WifiGetCountryCode req_wifi_get_country_code = 335; + Rpc_Req_WifiStaGetAid req_wifi_sta_get_aid = 338; + Rpc_Req_WifiStaGetNegotiatedPhymode req_wifi_sta_get_negotiated_phymode = 339; + + Rpc_Req_WifiStaGetRssi req_wifi_sta_get_rssi = 341; + + Rpc_Req_WifiSetProtocols req_wifi_set_protocols = 342; + Rpc_Req_WifiGetProtocols req_wifi_get_protocols = 343; + Rpc_Req_WifiSetBandwidths req_wifi_set_bandwidths = 344; + Rpc_Req_WifiGetBandwidths req_wifi_get_bandwidths = 345; + + Rpc_Req_WifiSetBand req_wifi_set_band = 346; + Rpc_Req_WifiGetBand req_wifi_get_band = 347; + Rpc_Req_WifiSetBandMode req_wifi_set_bandmode = 348; + Rpc_Req_WifiGetBandMode req_wifi_get_bandmode = 349; + + Rpc_Req_GetCoprocessorFwVersion req_get_coprocessor_fwversion = 350; + + Rpc_Req_WifiScanGetApRecord req_wifi_scan_get_ap_record = 351; + + /** Responses **/ + Rpc_Resp_GetMacAddress resp_get_mac_address = 513; + Rpc_Resp_SetMacAddress resp_set_mac_address = 514; + Rpc_Resp_GetMode resp_get_wifi_mode = 515; + Rpc_Resp_SetMode resp_set_wifi_mode = 516; + + //Rpc_Resp_ScanResult resp_scan_ap_list = 517; + //Rpc_Resp_GetAPConfig resp_get_ap_config = 518; + //Rpc_Resp_ConnectAP resp_connect_ap = 519; + //Rpc_Resp_GetStatus resp_disconnect_ap = 520; + + //Rpc_Resp_GetSoftAPConfig resp_get_softap_config = 521; + //Rpc_Resp_SetSoftAPVendorSpecificIE resp_set_softap_vendor_specific_ie = 522; + //Rpc_Resp_StartSoftAP resp_start_softap = 523; + //Rpc_Resp_SoftAPConnectedSTA resp_softap_connected_stas_list = 524; + //Rpc_Resp_GetStatus resp_stop_softap = 525; + + Rpc_Resp_SetPs resp_wifi_set_ps = 526; + Rpc_Resp_GetPs resp_wifi_get_ps = 527; + + Rpc_Resp_OTABegin resp_ota_begin = 528; + Rpc_Resp_OTAWrite resp_ota_write = 529; + Rpc_Resp_OTAEnd resp_ota_end = 530; + Rpc_Resp_WifiSetMaxTxPower resp_set_wifi_max_tx_power = 531; + Rpc_Resp_WifiGetMaxTxPower resp_get_wifi_max_tx_power = 532; + Rpc_Resp_ConfigHeartbeat resp_config_heartbeat = 533; + + Rpc_Resp_WifiInit resp_wifi_init = 534; + Rpc_Resp_WifiDeinit resp_wifi_deinit = 535; + Rpc_Resp_WifiStart resp_wifi_start = 536; + Rpc_Resp_WifiStop resp_wifi_stop = 537; + Rpc_Resp_WifiConnect resp_wifi_connect = 538; + Rpc_Resp_WifiDisconnect resp_wifi_disconnect = 539; + Rpc_Resp_WifiSetConfig resp_wifi_set_config = 540; + Rpc_Resp_WifiGetConfig resp_wifi_get_config = 541; + + Rpc_Resp_WifiScanStart resp_wifi_scan_start = 542; + Rpc_Resp_WifiScanStop resp_wifi_scan_stop = 543; + Rpc_Resp_WifiScanGetApNum resp_wifi_scan_get_ap_num = 544; + Rpc_Resp_WifiScanGetApRecords resp_wifi_scan_get_ap_records = 545; + Rpc_Resp_WifiClearApList resp_wifi_clear_ap_list = 546; + + Rpc_Resp_WifiRestore resp_wifi_restore = 547; + Rpc_Resp_WifiClearFastConnect resp_wifi_clear_fast_connect = 548; + Rpc_Resp_WifiDeauthSta resp_wifi_deauth_sta = 549; + Rpc_Resp_WifiStaGetApInfo resp_wifi_sta_get_ap_info = 550; + + Rpc_Resp_WifiSetProtocol resp_wifi_set_protocol = 553; + Rpc_Resp_WifiGetProtocol resp_wifi_get_protocol = 554; + Rpc_Resp_WifiSetBandwidth resp_wifi_set_bandwidth = 555; + Rpc_Resp_WifiGetBandwidth resp_wifi_get_bandwidth = 556; + Rpc_Resp_WifiSetChannel resp_wifi_set_channel = 557; + Rpc_Resp_WifiGetChannel resp_wifi_get_channel = 558; + Rpc_Resp_WifiSetCountry resp_wifi_set_country = 559; + Rpc_Resp_WifiGetCountry resp_wifi_get_country = 560; + + Rpc_Resp_WifiApGetStaList resp_wifi_ap_get_sta_list = 567; + Rpc_Resp_WifiApGetStaAid resp_wifi_ap_get_sta_aid = 568; + Rpc_Resp_WifiSetStorage resp_wifi_set_storage = 569; + + Rpc_Resp_WifiSetCountryCode resp_wifi_set_country_code = 590; + Rpc_Resp_WifiGetCountryCode resp_wifi_get_country_code = 591; + Rpc_Resp_WifiStaGetAid resp_wifi_sta_get_aid = 594; + Rpc_Resp_WifiStaGetNegotiatedPhymode resp_wifi_sta_get_negotiated_phymode = 595; + + Rpc_Resp_WifiStaGetRssi resp_wifi_sta_get_rssi = 597; + + Rpc_Resp_WifiSetProtocols resp_wifi_set_protocols = 598; + Rpc_Resp_WifiGetProtocols resp_wifi_get_protocols = 599; + Rpc_Resp_WifiSetBandwidths resp_wifi_set_bandwidths = 600; + Rpc_Resp_WifiGetBandwidths resp_wifi_get_bandwidths = 601; + + Rpc_Resp_WifiSetBand resp_wifi_set_band = 602; + Rpc_Resp_WifiGetBand resp_wifi_get_band = 603; + Rpc_Resp_WifiSetBandMode resp_wifi_set_bandmode = 604; + Rpc_Resp_WifiGetBandMode resp_wifi_get_bandmode = 605; + + Rpc_Resp_GetCoprocessorFwVersion resp_get_coprocessor_fwversion = 606; + + Rpc_Resp_WifiScanGetApRecord resp_wifi_scan_get_ap_record = 607; + + /** Notifications **/ + Rpc_Event_ESPInit event_esp_init = 769; + Rpc_Event_Heartbeat event_heartbeat = 770; + Rpc_Event_AP_StaConnected event_ap_sta_connected = 771; + Rpc_Event_AP_StaDisconnected event_ap_sta_disconnected = 772; + Rpc_Event_WifiEventNoArgs event_wifi_event_no_args = 773; + Rpc_Event_StaScanDone event_sta_scan_done = 774; + Rpc_Event_StaConnected event_sta_connected = 775; + Rpc_Event_StaDisconnected event_sta_disconnected = 776; + } +} + + +//message req_w_set_config { +// int32 iface = 1; +// wifi_config cfg = 2; +//} +// +//message rsp_w_set_config { +// int32 resp = 1; +//} +// +//message req_w_get_config { +// int32 iface = 1; +//} +// +//message rsp_w_get_config { +// int32 resp = 1; +// wifi_config cfg = 2; +//} +// +//message req_w_start { +//} +// +//message rsp_w_start { +// int32 resp = 1; +//} +// +//message evt_w_sta_connected { +// int32 resp = 1; +//} +// +//message evt_w_sta_disconnected { +// int32 resp = 1; +//} +// +//message evt_w_sta_start { +// int32 resp = 1; +//} +// +//message evt_w_sta_stop { +// int32 resp = 1; +//} +// +//message evt_w_ready { +// int32 resp = 1; +//} + +//message { +// int32 resp = 1; +//} + + + + + + + +//message Rpc_Resp_GetMode { +// int32 mode = 1; +// int32 resp = 2; +//} +// +//message Rpc_Req_SetMode { +//} +// +//message Rpc_Resp_SetMode { +// int32 resp = 1; +//} diff --git a/resources/espressif__esp_hosted/common/protobuf-c/.commit_docs.sh b/resources/espressif__esp_hosted/common/protobuf-c/.commit_docs.sh new file mode 100644 index 0000000..048a81b --- /dev/null +++ b/resources/espressif__esp_hosted/common/protobuf-c/.commit_docs.sh @@ -0,0 +1,75 @@ +#!/bin/bash -e + +# from git-sh-setup.sh +require_clean_work_tree () { + git rev-parse --verify HEAD >/dev/null || exit 1 + git update-index -q --ignore-submodules --refresh + err=0 + + if ! git diff-files --quiet --ignore-submodules + then + echo >&2 "Cannot $0: You have unstaged changes." + err=1 + fi + + if ! git diff-index --cached --quiet --ignore-submodules HEAD -- + then + if [ $err = 0 ] + then + echo >&2 "Cannot $0: Your index contains uncommitted changes." + else + echo >&2 "Additionally, your index contains uncommitted changes." + fi + err=1 + fi + + if [ $err = 1 ] + then + test -n "$2" && echo >&2 "$2" + exit 1 + fi +} + +require_clean_work_tree + +if ! which doxygen >/dev/null; then + echo "Error: doxygen is required" + exit 1 +fi + +DOXYGEN_VERSION="$(doxygen --version)" + +DOC_BRANCH="gh-pages" +ORIG_BRANCH="$(git rev-parse --abbrev-ref HEAD)" +ORIG_COMMIT="$(git describe --match=NeVeRmAtCh --always --abbrev=40 --dirty)" + +TOP="$(pwd)" +export GIT_DIR="$TOP/.git" + +TMPDIR="$(mktemp --tmpdir=$TOP -d)" +HTMLDIR="$TMPDIR/_build/html" +INDEX_FILE="$GIT_DIR/index.${DOC_BRANCH}" + +rm -f "$INDEX_FILE" + +trap "{ cd $TOP; git checkout --force ${ORIG_BRANCH}; rm -f $INDEX_FILE; rm -rf $TMPDIR; }" EXIT + +cd "$TMPDIR" +git reset --hard HEAD + +./autogen.sh +mkdir _build +cd _build +../configure +make html + +if ! git checkout "${DOC_BRANCH}"; then + git checkout --orphan "${DOC_BRANCH}" +fi + +touch "$HTMLDIR/.nojekyll" + +GIT_INDEX_FILE="$INDEX_FILE" GIT_WORK_TREE="$HTMLDIR" \ + git add --no-ignore-removal . +GIT_INDEX_FILE="$INDEX_FILE" GIT_WORK_TREE="$HTMLDIR" \ + git commit -m "Rebuild html documentation from commit ${ORIG_COMMIT} using Doxygen ${DOXYGEN_VERSION}" diff --git a/resources/espressif__esp_hosted/common/protobuf-c/.gitignore b/resources/espressif__esp_hosted/common/protobuf-c/.gitignore new file mode 100644 index 0000000..9733625 --- /dev/null +++ b/resources/espressif__esp_hosted/common/protobuf-c/.gitignore @@ -0,0 +1,43 @@ +*~ +.*swp +*.la +*.gcda +*.gcno +*.lo +*.log +*.o +*.tar.gz +*.trs +.deps/ +.dirstamp +.libs/ +/Doxyfile +/Makefile +/Makefile.in +/aclocal.m4 +/autom4te.cache +/build-aux +/config.* +/configure +/doxygen-doc +/html +/libtool +/protobuf-c-*-coverage.info +/protobuf-c-*-coverage/ +/stamp-h1 +/stamp-html +/test-suite.log +TAGS +protobuf-c/libprotobuf-c.pc +protoc-c/protoc-c +protoc-c/protoc-gen-c +t/generated-code/test-generated-code +t/generated-code2/cxx-generate-packed-data +t/generated-code2/test-full-cxx-output.inc +t/generated-code2/test-generated-code2 +t/generated-code3/test-generated-code3 +t/version/version +*.pb-c.c +*.pb-c.h +*.pb.cc +*.pb.h diff --git a/resources/espressif__esp_hosted/common/protobuf-c/CONTRIBUTING.md b/resources/espressif__esp_hosted/common/protobuf-c/CONTRIBUTING.md new file mode 100644 index 0000000..ceaba8f --- /dev/null +++ b/resources/espressif__esp_hosted/common/protobuf-c/CONTRIBUTING.md @@ -0,0 +1,5 @@ +## Contributing + +The most recently released `protobuf-c` version is kept on the `master` branch, while the `next` branch is used for commits targeted at the next release. Please base patches and pull requests against the `next` branch. __Do not open pull requests against master!__ + +Copyright to all contributions are retained by the original author, but must be licensed under the terms of the [BSD-2-Clause](http://opensource.org/licenses/BSD-2-Clause) license. diff --git a/resources/espressif__esp_hosted/common/protobuf-c/ChangeLog b/resources/espressif__esp_hosted/common/protobuf-c/ChangeLog new file mode 100644 index 0000000..91164dd --- /dev/null +++ b/resources/espressif__esp_hosted/common/protobuf-c/ChangeLog @@ -0,0 +1,564 @@ +protobuf-c (1.4.1) + + [ Robert Edmonds ] + * Release 1.4.1 + + [ Todd C. Miller ] + * Only shift unsigned values to avoid implementation-specific behavior + (#506, #508). + * Fix regression with zero-length messages introduced in protobuf-c PR 500. + * Fix a clang analyzer 14 warning about a possible NULL deref (#512, #514). + + [ steed717 ] + * Fix unsigned integer overflow (#499, #513). + +protobuf-c (1.4.0) + + [ Robert Edmonds ] + * Release 1.4.0. + + [ Ilya Lipnitsky ] + * c_message.cc: Resolve name conflict between certain enums and oneofs + (#427). + * protobuf-c.h: Fix Windows DLL export issue with the + protobuf_c_empty_string symbol (#428). + * Standardize pkg-config for use by autotools and cmake, fix cmake tests + (#425). + * protobuf-c.c: Cast %lu args to unsigned long int (#429). + * protoc-c: Remove leading underscores from structs (#430). + * protoc-c: Fix shared lib build on windows, migrate from Travis CI to + GitHub Actions (#459). + * protobuf-c: Don't use ProtobufCWireType internally (#463). + * protoc-c: Add custom options support (#466). + * protobuf-c.c: Fix packed repeated bool parsing (#467). + + [ Markus Engel ] + * Pack nested messages inline (#431). + + [ Daniel Axtens ] + * Travis CI: Test on other platforms (#438). + + [ Adam Cozzette ] + * Update the generator to fully qualify std::string (#443). + + [ Piotr Pietraszkiewicz ] + * Install MSVC debug symbols alongside the protobuf-c.lib file (#456). + + [ ihsinme ] + * Fix invalid unsigned arithmetic (#455). + + [ Wolfram Rösler ] + * Avoid "unused function parameter" compiler warning (#453). + +protobuf-c (1.3.3) + + [ Robert Edmonds ] + * Release 1.3.3. + + * Fix build failure on protobuf 2.x (#398). + + [ msshapira ] + * CMake: Fix support for MSVC static build (#350). + + [ Adam Cozzette ] + * Fix some test assertions in test-generated-code2.c (#392). + + [ Ilya Lipnitskiy ] + * protobuf-c.c: Make zigzag encoding more compact (#400). + + [ Markus Engel ] + * CMake: Fix endianness check. + +protobuf-c (1.3.2) + + [ Robert Edmonds ] + * Release 1.3.2. + + * Use protobuf 3.7.1 in the Travis-CI environment (#368). + + * Fix test suite build failure on newer versions of protobuf (#369). + + [ Ilya Lipnitskiy ] + * Fix proto3 repeated scalar field default packing behavior (#330, #377). + + [ Adam Cozzette ] + * Fix out-of-bounds read in scan_length_prefixed_data() (#375, #376). + + [ Jurriaan Bremer ] + * Fix -Wdeclaration-after-statement warning in parse_oneof_member() (#360). + + [ Hayri Ugur Koltuk ] + * Fix SIGSEGV in protobuf_c_message_check() on messages with unpopulated + oneof members (#358). + + [ Italo Guerrieri ] + * Do not allow tag values of 0 in protobuf messages, as these are not + allowed by proto2 or proto3 (#299). + +protobuf-c (1.3.1) + + [ Robert Edmonds ] + * Release 1.3.1. + + * Restore protobuf-2.x compatibility (#284, #285). + + * Use xenial and protobuf 3.6.1 in the Travis-CI environment (#332). + + * Convert uses of protobuf's scoped_ptr.h to C++11 std::unique_ptr, needed + to compile against protobuf 3.6.1 (#320, #333). + + * Use AX_CXX_COMPILE_STDCXX macro to enable C++11 support in old compilers + (#312, #317, #327, #334). + + [ Fredrik Gustafsson ] + * Add std:: to some types (#294, #305, #309). + + [ Sam Collinson ] + * Check the return value of int_range_lookup before using as an array index; + it can return -1 (#315). + + [ Matthias Dittrich ] + * Fix compilation on mingw by using explicit protoc --plugin=NAME=PATH syntax + in Makefile.am (#289, #290). + +protobuf-c (1.3.0) + + [ Robert Edmonds ] + * Release 1.3.0. + + * Add test case for the issue in #220 (#254). + + * Fix issue #251, "Bad enums with multiple oneofs" (#256). + + * Add warning flags to my_CFLAGS (#257). + + * Fix namespace errors when compiled with latest protobuf (#280). + + * Bump minimum required header version for proto3 syntax (#282). + + [ Paolo Borelli ] + * Turn the compiler into a protoc plugin (#206). This allows the protobuf-c + compiler to be invoked as "protoc --c_out=...". For backwards + compatibility, we still ship a protoc-c command, but it's a symlink to the + protoc-gen-c binary. + + * proto3 support (#228). + + * Remove leftover FIXME comment (#258). + + * Fix proto3 "is zeroish" evaluation (#264). + + * Small cleanup in oneof handling (#265). + + * Rework is_zeroish one more time (#267). + + * proto3: make strings default to "" instead of NULL (#274). + + [ Tomek Wasilczyk ] + * Fix -Wsign-compare warnings (#213). + + * Fix ISO C90 -Wdeclaration-after-statement warnings (#214). + + * Fix bigendian -Wunused-label warning (#215). + + [ Ilya Lipnitsky ] + * protoc-c/c_message.cc: Force int size on oneof enums (#221). Fixes wrong + enum generation and handling for onceof cases (#220). + + [ Adnan ] + * Fix cmake build if built as part of an external project (#231). + + [ Gregory Detal ] + * Remove .pb.{cc,h} in distdir instead of top_distdir in order to prevent + removing files from other projects when protobuf-c is included as an + autotools subproject (#232). + + [ Ben Farnham ] + * Relax autoconf constraint from v2.64 to v2.63 so that it works on older + Linux distros (#233). + + [ Thomas Köckerbauer ] + * rm argument fix for Solaris (#234). + + * Add 'const' qualifier to 'init_value' variable in generated files (#236). + + [ Richard Kettlewell ] + * Document and extend the effect of passing NULL to ..._free_unpacked + functions (#255). + + [ Alex Milich ] + * CMake: Workaround for static builds that use MSVC (#243). + + [ Josh Junon ] + * CMake: Allow protobuf-c to be included via include_subdirectory (#245). + + [ Alexei Kasatkin ] + * CMake: Windows fixes (#266). + +protobuf-c (1.2.1) + + [ Robert Edmonds ] + * Release 1.2.1. + + [ Paolo Borelli ] + * protoc-c: Generate code that uses the universal zero initializer {0} when + initializing a oneof union (#187, #205). + +protobuf-c (1.2.0) + + [ Robert Edmonds ] + * Release 1.2.0. + + [ Ilya Lipnitsky ] + * Implement the "optimize_for = CODE_SIZE" option (#183). + + * Eliminate undefined behavior in zigzag functions (#198). + + * Pack negative enum values correctly (#199). + + [ Peter Leschev ] + * Fix protobuf_c_message_get_packed_size() on 16-bit systems (#196, #197). + + [ Diego Elio Pettenò ] + * Update link to Autotools Mythbuster to canonical site (#201). + + [ Zex Li ] + * Skip test suite when cross-compiling (#184). + +protobuf-c (1.1.1) + + [ Robert Edmonds ] + * Release 1.1.1. + + * Use protobuf 2.6.1 in the Travis-CI environment. + + [ Ilya Lipnitskiy ] + * Munge C block comment delimiters in protobuf comments, preventing syntax + errors in generated header files (Issue #180, #185). + + * Add static qualifier to ProtobufCEnumValue and ProtobufCEnumValueIndex + variables in generated output. + + [ Oleg Efimov ] + * Fix -Wpointer-sign compiler diagnostics in the test suite. + + * Check for NULL pointers in protobuf_c_message_free_unpacked() + (Issue #177). + + * Exclude protoc-c and downloaded protobuf sources from Coveralls report. + + [ Andrey Myznikov ] + * Fix incorrect 'short_name' field values in ProtobufCServiceDescriptor + variables in generated output. + +protobuf-c (1.1.0) + + [ Robert Edmonds ] + * Release 1.1.0. + + [ Ilya Lipnitskiy ] + * Fix a bug when merging optional byte fields. + + * Documentation updates. + + * Implement oneof support (Issue #174). Protobuf 2.6.0 or newer is now + required to build protobuf-c. + + * Print leading comments for enum, message, and field definitions into + generated header files (Issue #175). + +protobuf-c (1.0.2) + + [ Robert Edmonds ] + * Release 1.0.2. + + [ Ilya Lipnitskiy ] + * Fix a build failure with Protobuf 2.6.0 related to aliased enum constants + (Issue #163). + + * Protobuf 2.5.0 or newer is now required to build protobuf-c (Issue #166). + This is due to the fix for #163. + + [ Alexei Kasatkin ] + * Eliminate void pointer arithmetic (Issue #167). + + * Always define PROTOBUF_C__DEPRECATED, even on compilers that are not GCC + (Issue #167). + + * Work around the lack of the 'inline' keyword in Microsoft compilers + (Issue #167). + + * Add a CMakeLists.txt file as a fallback build system for Windows + (Issue #168). + + [ Natanael Copa ] + * Fix a build failure in the test suite that occurred with a parallel make + running on a system with a large number of CPUs (Issue #156, #169). + +protobuf-c (1.0.1) + + [ Robert Edmonds ] + * Explicitly set the .data field of ProtobufCBinaryData's to NULL when + unpacking a zero length byte string (Issue #157). + +protobuf-c (1.0.0) + + [ Andrei Nigmatulin ] + * Append "u", "ull", and "ll" integer literal suffixes for uint32, uint64, + and int64 default values in generated code, in order to avoid "integer + constant is so large that it is unsigned" compiler warnings. + (Issue #136.) + + * Revert the problematic hash-based required field detection. + (Related to Issue #60, #79, #137.) + + * Replace the 'packed' member of ProtobufCFieldDescriptor with a 'flags' + word. Define flags for packed and deprecated fields. (Issue #138.) + + [ Dave Benson ] + * Treat a "length-prefixed" wire-type message for a repeated field as + packed-repeated whenever it makes sense (for all types other than + messages, strings, and bytes). + + * Switch to New BSD license. + + * Add protobuf_c_message_check(). + + * Compile error in packing 64-bit versions on some platforms + (srobbins99: Issue #68 Comment 1). + + * Fix for memory error if the required-field check fails. See Issue #63 + for demo (w/ nice test case by dror.harari). + + * Add PROTOBUF_C_{MAJOR,MINOR} for compile-time checks and + protobuf_c_{major,minor} for checks about the running library + (Issue #53). + + * Use a small constant-size hash-table instead of alloca() for detecting + required fields, and it also prevents us from using too much stack, etc. + (Related to Issue #60, #79). + + * Add a macro to ensure enums are the size of ints (Issue #69). + + [ Ilya Lipnitskiy ] + * Travis-CI integration. + + * Add source .proto filename to generated files. + + * Add protobuf-c version to protoc-c --version output (Issue #52). + + * For embedded submessage fields, merge multiple instances of the same + field, per the protobuf documentation (Issue #91). + + * Don't print unpack errors by default. + + * Optionally allow running the test suite under valgrind with ./configure + --enable-valgrind-tests. (Based on valgrind-tests.m4 from gnulib.) + + [ Kevin Lyda ] + * Autoconf portability fixes. + + * Add doxygen detection and make targets to the build system. + + * Doxygen documentation for the libprotobuf-c public API (Issue #132). + + [ Nick Galbreath ] + * Prevent possible overflow on 64-bit systems (Issue #106). + + [ Robert Edmonds ] + * Remove CMake (Issue #87). + + * Modernize the build system. + - Don't generate any diagnostics when building the build system with + modern autotools (Issue #89). + + - Use the PKG_CHECK_MODULES macro to locate protobuf. + + - Use the AC_C_BIGENDIAN macro to detect endianness, rather than custom + code. + + - Use the automake silent-rules option so the build output is actually + readable. + + - Generate our own pkg-config .pc files. + + * Reorganize the source tree. This affects the public protobuf-c header + path, which is now . A compatibility symlink from + to has been installed so that existing + code will continue to compile. New code should at some point begin using + the new include path, i.e., "#include " rather + than "#include ". + + * The RPC code has been split out into a separate project, protobuf-c-rpc. + + * Fix a potential use of an unitialized value in protobuf_c_message_unpack() + and several memory leaks in protoc-c, discovered by a commercial static code + analysis tool. + + * Bump the libprotobuf-c SONAME. + + * Begin versioning the library's symbols. (Based on ld-version-script.m4 + from gnulib.) + + * Preserve case in enum value names generated by protoc-c (Issue #129). + Reported by Oleg Efimov. + + * Add library functions protobuf_c_version() and protobuf_c_version_string() + for retrieving the version of the compiled library, and header macros + PROTOBUF_C_VERSION and PROTOBUF_C_VERSION_STRING for retrieving the + version of the header file. This replaces the interfaces for retrieving + the protobuf-c version numbers in Issue #53. + + * Add a version guard that ensures that the output of protoc-c is only + compiled against a protobuf-c header file from the exact same protobuf-c + release. + + * Add a --enable-code-coverage option to configure, which enables a + "make check-code-coverage" build target. This generates a code coverage + report and requires the lcov tool to be installed. + + * Remove the old DocBook documentation in doc/c-code-generator.{html,xml}. + Relevant material has been updated and incorporated into the Doxygen + documentation in the protobuf-c header file. + + * Remove the protobuf_c_default_allocator and protobuf_c_system_allocator + global variables from the exported library interface. All exported library + functions that need to perform dynamic memory allocation receive a + user-provided ProtobufCAllocator* parameter. If this parameter is NULL, + the system's default memory allocator will be used. + + Client code that previously passed "&protobuf_c_system_allocator" to + protobuf-c library functions taking a ProtobufCAllocator* argument should + be updated to pass "NULL" instead. + + Client code that previously overrode protobuf_c_default_allocator with + custom allocation functions and passed NULL as the ProtobufCAllocator* + argument to protobuf-c library functions should be updated to instead + enclose the custom allocation functions in a ProtobufCAllocator struct and + pass this object to protobuf-c library functions taking a + ProtobufCAllocator* parameter. + + * Update copyright and license statements throughout. The original + protobuf code released by Google was relicensed from Apache-2.0 to + BSD-3-Clause. Dave Benson also converted his license from BSD-3-Clause + to BSD-2-Clause. + + [ Tomasz Wasilczyk ] + * Don't export protobuf_c_message_init_generic() as an external symbol. + + * Don't use C++ style comments in C code. + + * Fix -Wcast-align warnings when compiled with clang. + +protobuf-c (0.15) + - make protobuf_c_message_init() into a function (Issue #49, daveb) + - Fix for freeing memory after unpacking bytes w/o a default-value. + (Andrei Nigmatulin) + - minor windows portability issues (use ProtobufC_FD) (Pop Stelian) + - --with-endianness={little,big} (Pop Stelian) + - bug setting up values of has_idle in public dispatch, + make protobuf_c_dispatch_run() use only public members (daveb) + - provide cmake support and some Windows compatibility (Nikita Manovich) + +protobuf-c (0.14) + - build fix (missing dependency in test directory) + - add generation / installation of pkg-config files. (Bobby Powers) + - support for packed repeated fields (Dave Benson) + - bug in protobuf_c_dispatch_close_fd(), which usually only + showed up in later function calls. + - support for deprecated fields -- enable a GCC warning + if a field has the "deprecated" option enabled. (Andrei Nigmatulin) + - hackery to try to avoid touching inttypes.h on windows (Issue #41) + - fix for protobuf_c_message_unpack() to issue error if any + "required" field is missing in input stream. (Andrei Nigmatulin) + +protobuf-c (0.13) + - Fix for when the number of connections gets too great in RPC. + (Leszek Swirski) (issue #32) + - Add --disable-protoc to only build libprotobuf-c (daveb) + - Bug fixes for protobuf_c_enum_descriptor_get_value_by_name() + and protobuf_c_service_descriptor_get_method_by_name() + - if descriptor->message_init != NULL, use it from unpack() + as an optimization (daveb) + - implement protobuf_c_{client,server}_set_error_handler() + +protobuf-c (0.12) + - for field names which are reserved words, use the real name + given in the protobuf-c file, not the mangled name which + is the name of the member in the C structure. (Andrei Nigmatulin) + - add protobuf_c_message_init() function; add virtual function + that implements it efficiently. (Andrei Nigmatulin) + - bug fix for sfixed32, fixed32, float wire-types on + big-endian platforms (Robert Edmonds) + - compile with the latest protobuf (the header file wire_format_inl.h + is now wire_format.h) (Robert Edmonds) + +protobuf-c (0.11) + - allow CFLAGS=-DPRINT_UNPACK_ERRORS=0 to suppress + unpack warnings from being printed at compile time (Andrei Nigmatulin) + - give error if an unknown wire-type is encountered (Andrei Nigmatulin) + - fix technically possible overflows during unpack of very + large messages (Andrei Nigmatulin) + - [UNFINISHED] windows RPC work + - use automake's "foreign" mode from within configure.ac + and add version information to the library (Robert Edmonds) + - ProtobufCServiceDescriptor::method_indices_by_name: missing + const. (Issue 21) + - Update to support new UnknownFields API. (fix by dcreager) (Issue 20) + +protobuf-c (0.10) + - build issue on platforms which don't compute library dependencies + automatically. + - fix for certain types of corrupt messages (Landon Fuller) (issue 16) + +protobuf-c (0.9) + - build issue: needed $(EXEEXT) in dependency lists for cygwin + - bug fix: protobuf_c_service_get_method_by_name() was not correct b/c + the service's methods were not sorted by name (the header file + used to incorrectly state that they were). + Now we correctly implement protobuf_c_service_get_method_by_name() + (using a bsearch indexed by separate array). + - generated source incompatibility: we added a new + member to ProtobufCServiceDescriptor (method_indices_by_name). + You will have to run the latest protobuf + to generate those structures. + - rename rpc-client's "autoretry" mechanism to "autoreconnect". + - bug fixes using TCP clients with the RPC system. + - handle allocation failures more gracefully (Jason Lunz) (issue 15) + +protobuf-c (0.8) + - Destroy function typedef for Services was omitting a "*" + - service_machgen_invoke was broken. (issue 12) + - add RPC system (BETA) + - don't segfault when packing NULL strings and messages. (issue 13) + +protobuf-c (0.7) + - memory leak: unknown fields were not being freed by free_unpacked() + - lowercase field names consistently when composing + default_value names. (issue 11) + - remove spurious semicolon (issue 10) + +protobuf-c (0.6) + - Warning suppression for -Wcast-qual and -Wshadow. + - Support for default values of all types allowed by core protobuf. + - Generate message__init functions, for when the static initializer + isn't convenient. + - add some reserved fields at the end of the various descriptors + +protobuf-c (0.5) + - License now included in major files. + - Use little-endian optimizations; fix a bug therein. + - Include 'make deb' target. + +protobuf-c (0.4) + - Update to work with protobuf 2.0.1. + +protobuf-c (0.2) +protobuf-c (0.3) + - Minor pedantic concerns about generated code. + +protobuf-c (0.1) + - Lots of test code (and bug fixes). + +protobuf-c (0.0) + - Initial release. diff --git a/resources/espressif__esp_hosted/common/protobuf-c/Doxyfile.in b/resources/espressif__esp_hosted/common/protobuf-c/Doxyfile.in new file mode 100644 index 0000000..7d556ec --- /dev/null +++ b/resources/espressif__esp_hosted/common/protobuf-c/Doxyfile.in @@ -0,0 +1,2312 @@ +# Doxyfile 1.8.7 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "@PACKAGE@" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = @PACKAGE_VERSION@ + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = "@PACKAGE_DESCRIPTION@" + +# With the PROJECT_LOGO tag one can specify an logo or icon that is included in +# the documentation. The maximum height of the logo should not exceed 55 pixels +# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo +# to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = YES + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = NO + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = @top_srcdir@ + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a +# new page for each member. If set to NO, the documentation of a member will be +# part of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = YES + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, Javascript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: +# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: +# Fortran. In the later case the parser tries to guess whether the code is fixed +# or free formatted code, this is the default for Fortran type files), VHDL. For +# instance to make doxygen treat .inc files as Fortran files (default is PHP), +# and .f files as C (default is Fortran), use: inc=Fortran f=C. +# +# Note For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by by putting a % sign in front of the word +# or globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = YES + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO these classes will be included in the various overviews. This option has +# no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = NO + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = NO + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the +# todo list. This list is created by putting \todo commands in the +# documentation. +# The default value is: YES. + +GENERATE_TODOLIST = NO + +# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the +# test list. This list is created by putting \test commands in the +# documentation. +# The default value is: YES. + +GENERATE_TESTLIST = NO + +# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = NO + +# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES the list +# will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = NO + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = NO + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = @top_srcdir@/DoxygenLayout.xml + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. Do not use file names with spaces, bibtex cannot handle them. See +# also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = YES + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO doxygen will only warn about wrong or incomplete parameter +# documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = YES + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. +# Note: If this tag is empty the current directory is searched. + +INPUT = @DOXYGEN_INPUT@ + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank the +# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, +# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, +# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, +# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, +# *.qsf, *.as and *.js. + +FILE_PATTERNS = *.h + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = *private* + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER ) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES, then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = NO + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = NO + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- +# defined cascading style sheet that is included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefor more robust against future updates. +# Doxygen will copy the style sheet file to the output directory. For an example +# see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the stylesheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler ( hhc.exe). If non-empty +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated ( +# YES) or that it should be included in the master .chm file ( NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated ( +# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = YES + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = YES + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 0 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side Javascript for the rendering +# instead of using prerendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /