Add RPC support to linux lighting app (project-chip#5866)

* Cleanup RPCs for lighting app

  - Break apart lighting service and buttons.
  - Rename RPCs.
  - Create a common RPC file for Empty message.

Used EFR32 to test, will make changes to other platforms when
we have concensus on the style.

* Add device_common RPC service

A new RPC service which holds common CHIP RPCs.

* Initial prototype of linux RPC in lighting app

This adds RPCs to the lighting app using a server running over a
local socket (port 33000).

* Add lighting app rpc python tool.

This tool has all the protos for the lighting app built in and
can be used instead of pw_hdlc.rpc_console.
  - Added a gn target to install the python tool into venv
    lighting app is compiled with rpcs enabled.
  - Will also bundle a wheel file which can be used to deploy
    without requiring the source

Usage:
To start the console, provide a serial port as the --device argument

  python -m lighting_app.rpc_console --device /dev/ttyUSB0

Alternatively to connect to a linux CHIP device provide the port.

  python -m lighting_app.rpc_console -s localhost:33000

This starts an IPython console for communicating with the connected device. A
few variables are predefined in the interactive console. These include:

    rpcs   - used to invoke RPCs
    device - the serial device used for communication
    client - the pw_rpc.Client
    protos - protocol buffer messages indexed by proto package

An example RPC command:
  rpcs.chip.rpc.DeviceCommon.GetDeviceInfo()

* Cleanup: Use ArraySize in Rpc.cc for task

* Update lighting app RPC build for NRF

Author: rgoliver

config/linux/lib/pw_rpc/BUILD.gn

@@ -0,0 +1,46 @@
+# Copyright (c) 2021 Project CHIP Authors
+#
+# 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.
+
+import("//build_overrides/chip.gni")
+import("//build_overrides/pigweed.gni")
+import("$dir_pw_build/target_types.gni")
+
+config("cpp17") {
+  cflags_cc = [ "-std=gnu++17" ]
+  cflags_c = [ "-std=gnu11" ]
+  cflags_objc = [ "-std=gnu11" ]
+  cflags_objcc = [ "-std=gnu++17" ]
+}
+
+config("std_cpp17") {
+  configs = [ ":cpp17" ]
+}
+
+static_library("pw_rpc") {
+  output_name = "libPwRpc"
+
+  public_configs = [ "${dir_pigweed}/pw_hdlc:default_config" ]
+  deps = [
+    "$dir_pw_hdlc:encoder",
+    "$dir_pw_hdlc:pw_rpc",
+    "$dir_pw_hdlc:rpc_channel_output",
+    "$dir_pw_rpc:synchronized_channel_output",
+    "$dir_pw_rpc/system_server:facade",
+    "$dir_pw_stream:socket_stream",
+    dir_pw_log,
+  ]
+  output_dir = "${root_out_dir}/lib"
+
+  complete_static_lib = true
+}

examples/common/pigweed/BUILD.gn

@@ -15,11 +15,32 @@
 import("//build_overrides/pigweed.gni")
 
 import("$dir_pw_build/target_types.gni")
+import("pigweed_rpcs.gni")
 
 config("default_config") {
   include_dirs = [ ".." ]
 }
 
+if (chip_enable_pw_rpc) {
+  import("//build_overrides/pigweed.gni")
+  import("$dir_pw_protobuf_compiler/proto.gni")
+
+  pw_proto_library("device_service") {
+    sources = [ "protos/device_service.proto" ]
+    inputs = [ "protos/device_service.options" ]
+    deps = [ "$dir_pw_protobuf:common_protos" ]
+    strip_prefix = "protos"
+    prefix = "device_service"
+  }
+
+  pw_proto_library("button_service") {
+    sources = [ "protos/button_service.proto" ]
+    deps = [ "$dir_pw_protobuf:common_protos" ]
+    strip_prefix = "protos"
+    prefix = "button_service"
+  }
+}
+
 pw_source_set("system_rpc_server") {
   sources = [ "system_rpc_server.cc" ]
 

examples/lighting-app/lighting-common/lighting.gni examples/common/pigweed/pigweed_rpcs.gni

@@ -14,5 +14,5 @@
 
 declare_args() {
   # Enable Pigweed RPC integration.
-  enable_pw_rpc = false
+  chip_enable_pw_rpc = false
 }

examples/common/pigweed/protos/button_service.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+import 'pw_protobuf_protos/common.proto';
+
+package chip.rpc;
+
+message ButtonEvent {
+  uint32 idx = 1;
+  bool pushed = 2;
+}
+
+service Button {
+  rpc Event(ButtonEvent) returns (pw.protobuf.Empty){}
+}

examples/common/pigweed/protos/device_service.options

@@ -0,0 +1,2 @@
+
+chip.rpc.DeviceInfo.serial_number max_size:32  // length defined in chip spec 8.2.3.1

examples/common/pigweed/protos/device_service.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package chip.rpc;
+
+import 'pw_protobuf_protos/common.proto';
+
+// type lengths defined in chip spec 8.2.3.1
+message DeviceInfo {
+  uint32 vendor_id = 1;
+  uint32 product_id = 2;
+  uint32 software_version = 3;
+  string serial_number = 4;
+}
+
+service Device {
+  rpc FactoryReset(pw.protobuf.Empty) returns (pw.protobuf.Empty){}
+  rpc Reboot(pw.protobuf.Empty) returns (pw.protobuf.Empty){}
+  rpc TriggerOta(pw.protobuf.Empty) returns (pw.protobuf.Empty){}
+  rpc GetDeviceInfo(pw.protobuf.Empty) returns (DeviceInfo){}
+}

examples/lighting-app/efr32/BUILD.gn

@@ -18,10 +18,15 @@ import("//build_overrides/efr32_sdk.gni")
 import("//build_overrides/pigweed.gni")
 
 import("${build_root}/config/defaults.gni")
-import("${chip_root}/examples/lighting-app/lighting-common/lighting.gni")
 import("${efr32_sdk_build_root}/efr32_executable.gni")
 import("${efr32_sdk_build_root}/efr32_sdk.gni")
 
+import("${chip_root}/examples/common/pigweed/pigweed_rpcs.gni")
+
+if (chip_enable_pw_rpc) {
+  import("//build_overrides/pigweed.gni")
+}
+
 assert(current_os == "freertos")
 
 efr32_project_dir = "${chip_root}/examples/lighting-app/efr32"
@@ -64,9 +69,7 @@ efr32_sdk("sdk") {
     "SL_HEAP_SIZE=(10 * 1024)",
   ]
 
-  if (enable_pw_rpc) {
-    sources +=
-        [ "${efr32_sdk_root}/hardware/kit/common/drivers/retargetserial.c" ]
+  if (chip_enable_pw_rpc) {
     defines += [
       "HAL_VCOM_ENABLE=1",
       "PW_RPC_ENABLED",
@@ -110,7 +113,8 @@ efr32_executable("lighting_app") {
     defines += [ "DISPLAY_ENABLED" ]
   }
 
-  if (enable_pw_rpc) {
+  if (chip_enable_pw_rpc) {
+    defines += [ "PW_RPC_ENABLED" ]
     sources += [
       "${chip_root}/examples/common/pigweed/RpcService.cpp",
       "${chip_root}/examples/common/pigweed/efr32/PigweedLoggerMutex.cpp",
@@ -123,8 +127,11 @@ efr32_executable("lighting_app") {
       "$dir_pw_checksum",
       "$dir_pw_hdlc:rpc_channel_output",
       "$dir_pw_stream",
+      "$dir_pw_stream:sys_io_stream",
       "$dir_pw_sys_io",
       "${chip_root}/config/efr32/lib/pw_rpc:pw_rpc",
+      "${chip_root}/examples/common/pigweed:button_service.nanopb_rpc",
+      "${chip_root}/examples/common/pigweed:device_service.nanopb_rpc",
       "${chip_root}/examples/lighting-app/lighting-common:lighting_service.nanopb_rpc",
       "${examples_plat_dir}/pw_sys_io:pw_sys_io_efr32",
     ]
@@ -160,6 +167,12 @@ efr32_executable("lighting_app") {
 
 group("efr32") {
   deps = [ ":lighting_app" ]
+  if (chip_enable_pw_rpc) {
+    deps += [
+      "${chip_root}/examples/lighting-app/lighting-common/py:lighting_app.install",
+      "${chip_root}/examples/lighting-app/lighting-common/py:lighting_app_wheel",
+    ]
+  }
 }
 
 group("default") {

examples/lighting-app/efr32/README.md

@@ -280,16 +280,24 @@ via 2002::2
 
 ## Running Pigweed RPC console
 
--   If you build the example with pigweed RPC option you can can interact with
-    the example by UART using the RPC LightingService. Call the following
-    command in your terminal
+-   As part of building the example with RPCs enabled the lighting_app python
+    interactive console is installed into your venv. The python wheel files are
+    also created in the output folder: out/debug/lighting_app_wheels. To install
+    the wheel files without rebuilding:
+    `pip3 install out/debug/lighting_app_wheels/*.whl`
 
-    `python -m pw_hdlc.rpc_console --device /dev/tty.<SERIALDEVICE> -b 115200 /<CHIP_ROOT>/examples/lighting-app/lighting-common/lighting_service/pigweed_lighting.proto -o /<YourFolder>/pw_log.out`
+-   To use the lighting-app console after it has been installed run:
+    `python3 -m lighting_app.rpc_console --device /dev/tty.<SERIALDEVICE> -b 115200 -o /<YourFolder>/pw_log.out`
 
 -   Then you can simulate a button press or realease using the following command
     where : idx = 0 or 1 for Button PB0 or PB1 action = 0 for PRESSED, 1 for
     RELEASE Test toggling the LED with
-    `rpcs.chip.rpc.LightingService.ButtonEvent(idx=1,action=0)`
+    `rpcs.chip.rpc.Button.Event(idx=1, pushed=True)`
+
+-   You can also Get and Set the light directly using the RPCs:
+    `rpcs.chip.rpc.Lighting.Get()`
+
+    `rpcs.chip.rpc.Lighting.Set(on=True)`
 
 ## Memory settings
 

examples/lighting-app/efr32/src/Rpc.cpp

@@ -22,7 +22,10 @@
 #include "PigweedLoggerMutex.h"
 #include "pigweed/RpcService.h"
 
-#include "lighting_service/pigweed_lighting.rpc.pb.h"
+#include "button_service/button_service.rpc.pb.h"
+#include "device_service/device_service.rpc.pb.h"
+#include "lib/support/CodeUtils.h"
+#include "lighting_service/lighting_service.rpc.pb.h"
 #include "pw_hdlc/rpc_channel.h"
 #include "pw_hdlc/rpc_packets.h"
 #include "pw_rpc/server.h"
@@ -33,30 +36,79 @@
 namespace chip {
 namespace rpc {
 
-class LightingService final : public generated::LightingService<LightingService>
+class Lighting final : public generated::Lighting<Lighting>
 {
 public:
-    pw::Status ButtonEvent(ServerContext & ctx, const chip_rpc_Button & request, chip_rpc_Empty & response)
+    pw::Status Set(ServerContext &, const chip_rpc_LightingState & request, pw_protobuf_Empty & response)
     {
-        GetAppTask().ButtonEventHandler(request.idx /* PB 0 or PB 1 */, request.action /* 0 =PRESSED 1= RELEASE */);
+        LightMgr().InitiateAction(AppEvent::kEventType_Light,
+                                  request.on ? LightingManager::ON_ACTION : LightingManager::OFF_ACTION);
+        return pw::OkStatus();
+    }
+
+    pw::Status Get(ServerContext &, const pw_protobuf_Empty & request, chip_rpc_LightingState & response)
+    {
+        response.on = LightMgr().IsLightOn();
+        return pw::OkStatus();
+    }
+};
+
+class Button final : public generated::Button<Button>
+{
+public:
+    pw::Status Event(ServerContext &, const chip_rpc_ButtonEvent & request, pw_protobuf_Empty & response)
+    {
+        GetAppTask().ButtonEventHandler(request.idx /* PB 0 or PB 1 */, request.pushed);
+        return pw::OkStatus();
+    }
+};
+
+class Device final : public generated::Device<Device>
+{
+public:
+    pw::Status FactoryReset(ServerContext & ctx, const pw_protobuf_Empty & request, pw_protobuf_Empty & response)
+    {
+        // TODO: Clear data from KVS
+        DeviceLayer::ConfigurationMgr().InitiateFactoryReset();
+        return pw::OkStatus();
+    }
+    pw::Status Reboot(ServerContext & ctx, const pw_protobuf_Empty & request, pw_protobuf_Empty & response)
+    {
+        NVIC_SystemReset();
+        // WILL NOT RETURN
+        return pw::OkStatus();
+    }
+    pw::Status TriggerOta(ServerContext & ctx, const pw_protobuf_Empty & request, pw_protobuf_Empty & response)
+    {
+        // TODO: auto err = DeviceLayer::SoftwareUpdateMgr().CheckNow();
+        return pw::Status::Unimplemented();
+    }
+    pw::Status GetDeviceInfo(ServerContext &, const pw_protobuf_Empty & request, chip_rpc_DeviceInfo & response)
+    {
+        response.vendor_id        = 1234;
+        response.product_id       = 5678;
+        response.software_version = 0;
         return pw::OkStatus();
     }
 };
 
 namespace {
-using std::byte;
 
 #define RPC_TASK_STACK_SIZE 4096
 #define RPC_TASK_PRIORITY 1
 static TaskHandle_t sRpcTaskHandle;
 StaticTask_t sRpcTaskBuffer;
 StackType_t sRpcTaskStack[RPC_TASK_STACK_SIZE];
 
-chip::rpc::LightingService lighting_service;
+chip::rpc::Button button_service;
+chip::rpc::Lighting lighting_service;
+chip::rpc::Device device_service;
 
 void RegisterServices(pw::rpc::Server & server)
 {
     server.RegisterService(lighting_service);
+    server.RegisterService(button_service);
+    server.RegisterService(device_service);
 }
 
 } // namespace
@@ -72,8 +124,8 @@ int Init()
     pw_sys_io_Init();
 
     // Start App task.
-    sRpcTaskHandle = xTaskCreateStatic(RunRpcService, "RPC_TASK", RPC_TASK_STACK_SIZE / sizeof(StackType_t), nullptr,
-                                       RPC_TASK_PRIORITY, sRpcTaskStack, &sRpcTaskBuffer);
+    sRpcTaskHandle = xTaskCreateStatic(RunRpcService, "RPC_TASK", ArraySize(sRpcTaskStack), nullptr, RPC_TASK_PRIORITY,
+                                       sRpcTaskStack, &sRpcTaskBuffer);
     return err;
 }
 

examples/lighting-app/efr32/with_pw_rpc.gni

@@ -21,6 +21,6 @@ import("${chip_root}/examples/platform/efr32/args.gni")
 
 efr32_sdk_target = get_label_info(":sdk", "label_no_toolchain")
 
-enable_pw_rpc = true
+chip_enable_pw_rpc = true
 chip_enable_openthread = true
 default_configs_std = [ "${chip_root}/config/efr32/lib/pw_rpc:std_cpp17" ]

examples/lighting-app/lighting-common/BUILD.gn

@@ -13,17 +13,17 @@
 # limitations under the License.
 
 import("//build_overrides/chip.gni")
-
-import("${chip_root}/examples/lighting-app/lighting-common/lighting.gni")
+import("${chip_root}/examples/common/pigweed/pigweed_rpcs.gni")
 import("${chip_root}/src/app/chip_data_model.gni")
 
-if (enable_pw_rpc) {
+if (chip_enable_pw_rpc) {
   import("//build_overrides/pigweed.gni")
+  import("$dir_pw_build/python.gni")
   import("$dir_pw_protobuf_compiler/proto.gni")
 
   pw_proto_library("lighting_service") {
-    sources = [ "lighting_service/pigweed_lighting.proto" ]
-    inputs = [ "lighting_service/pigweed_lighting.options" ]
+    sources = [ "lighting_service/lighting_service.proto" ]
+    deps = [ "$dir_pw_protobuf:common_protos" ]
   }
 }
 

examples/lighting-app/lighting-common/lighting_service/lighting_service.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+import 'pw_protobuf_protos/common.proto';
+
+package chip.rpc;
+
+message LightingBrightness {
+  // level is between 0 and max_level inclusively.
+  // The device should support rescaling if provided a max_value which doesn't
+  // match the platforms value.
+  uint32 level = 1;
+  uint32 max_level = 2;
+}
+
+message LightingState {
+  bool on = 1;
+  optional LightingBrightness brightness = 2;
+}
+
+service Lighting {
+  // Set will return OK if all supported fields are successfully applied, any
+  // unsupported fields will be ignored.
+  // Get can be used to determine which fields are supported.
+  rpc Set(LightingState) returns (pw.protobuf.Empty){}
+
+  // Get will populate all of the supported lighting state fields with the
+  // current values. This can be used to discover the devices supported
+  // lighting features.
+  rpc Get(pw.protobuf.Empty) returns (LightingState){}
+}