examples/shell/shell_common/cmd_btp.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 #include "ChipShellCollection.h"
  19
  20 #include <core/CHIPCore.h>
  21
  22 #if CONFIG_NETWORK_LAYER_BLE
  23
  24 #if CONFIG_DEVICE_LAYER
  25 #include <platform/CHIPDeviceLayer.h>
  26 #endif
  27
  28 #include <lib/shell/shell.h>
  29 #include <support/CHIPArgParser.hpp>
  30 #include <support/CHIPMem.h>
  31 #include <support/CodeUtils.h>
  32
  33 using namespace chip;
  34 using namespace chip::Shell;
  35 using namespace chip::Platform;
  36 using namespace chip::DeviceLayer;
  37 using namespace chip::Logging;
  38 using namespace chip::ArgParser;
  39
  40 static chip::Shell::Shell sShellDeviceSubcommands;
  41
  42 int cmd_btp_help_iterator(shell_command_t * command, void * arg)
  43 {
  44     streamer_printf(streamer_get(), "  %-15s %s\n\r", command->cmd_name, command->cmd_help);
  45     return 0;
  46 }
  47
  48 int cmd_btp_help(int argc, char ** argv)
  49 {
  50     sShellDeviceSubcommands.ForEachCommand(cmd_btp_help_iterator, nullptr);
  51     return 0;
  52 }
  53
  54 int cmd_btp_adv(int argc, char ** argv)
  55 {
  56     CHIP_ERROR error  = CHIP_NO_ERROR;
  57     streamer_t * sout = streamer_get();
  58     bool adv_enabled;
  59
  60     if (argc == 0)
  61     {
  62         ExitNow(error = CHIP_ERROR_INVALID_ARGUMENT);
  63     }
  64
  65     adv_enabled = ConnectivityMgr().IsBLEAdvertisingEnabled();
  66     if (strcmp(argv[0], "start") == 0)
  67     {
  68         if (adv_enabled)
  69         {
  70             streamer_printf(sout, "BLE advertising already enabled");
  71         }
  72         else
  73         {
  74             streamer_printf(sout, "Starting BLE advertising");
  75             ConnectivityMgr().SetBLEAdvertisingEnabled(true);
  76         }
  77     }
  78     else if (strcmp(argv[0], "stop") == 0)
  79     {
  80         if (adv_enabled)
  81         {
  82             streamer_printf(sout, "Stopping BLE advertising");
  83             ConnectivityMgr().SetBLEAdvertisingEnabled(false);
  84         }
  85         else
  86         {
  87             streamer_printf(sout, "BLE advertising already stopped");
  88         }
  89     }
  90     else
  91     {
  92         ExitNow(error = CHIP_ERROR_INVALID_ARGUMENT);
  93     }
  94
  95 exit:
  96     return error;
  97 }
  98
  99 int cmd_btp_scan(int argc, char ** argv)
 100 {
 101     CHIP_ERROR error  = CHIP_NO_ERROR;
 102     streamer_t * sout = streamer_get();
 103
 104     if (argc == 0)
 105     {
 106         ExitNow(error = CHIP_ERROR_INVALID_ARGUMENT);
 107     }
 108
 109     if (strcmp(argv[0], "start") == 0)
 110     {
 111         streamer_printf(sout, "Starting scanning over BLE");
 112         // TODO: start scanning
 113     }
 114     else if (strcmp(argv[0], "stop") == 0)
 115     {
 116         streamer_printf(sout, "Stopping scanning over BLE");
 117         // TODO: stop scanning
 118     }
 119     else
 120     {
 121         ExitNow(error = CHIP_ERROR_INVALID_ARGUMENT);
 122     }
 123
 124 exit:
 125     return error;
 126 }
 127
 128 int cmd_btp_connect(int argc, char ** argv)
 129 {
 130     CHIP_ERROR error  = CHIP_NO_ERROR;
 131     streamer_t * sout = streamer_get();
 132
 133     if (argc == 0)
 134     {
 135         ExitNow(error = CHIP_ERROR_INVALID_ARGUMENT);
 136     }
 137
 138     if (strcmp(argv[0], "start") == 0)
 139     {
 140         streamer_printf(sout, "Connecting to the device over BLE");
 141         // connecting
 142     }
 143     else if (strcmp(argv[0], "stop") == 0)
 144     {
 145         streamer_printf(sout, "Disconnecting from the device");
 146         // disconnecting
 147     }
 148     else
 149     {
 150         ExitNow(error = CHIP_ERROR_INVALID_ARGUMENT);
 151     }
 152
 153 exit:
 154     return error;
 155 }
 156
 157 int cmd_btp_send(int argc, char ** argv)
 158 {
 159     return CHIP_ERROR_NOT_IMPLEMENTED;
 160 }
 161
 162 int cmd_btp_dispatch(int argc, char ** argv)
 163 {
 164     CHIP_ERROR error = CHIP_NO_ERROR;
 165
 166     VerifyOrExit(argc > 0, error = CHIP_ERROR_INVALID_ARGUMENT);
 167
 168     error = sShellDeviceSubcommands.ExecCommand(argc, argv);
 169
 170 exit:
 171     return error;
 172 }
 173
 174 static const shell_command_t cmds_btp_root = { &cmd_btp_dispatch, "btp", "BLE transport commands" };
 175
 176 /// Subcommands for root command: `btp <subcommand>`
 177 static const shell_command_t cmds_btp[] = {
 178     { &cmd_btp_help, "help", "Usage: btp <subcommand>" },
 179     { &cmd_btp_scan, "scan", "Enable or disable scan. Usage: btp scan <start timeout|stop>" },
 180     { &cmd_btp_connect, "connect", "Connect or disconnect to a device. Usage: btp connect <start address|stop>" },
 181     { &cmd_btp_adv, "adv", "Enable or disable advertisement. Usage: btp adv <start|stop>" },
 182     { &cmd_btp_send, "send", "Send binary data. Usage: device dump" },
 183 };
 184
 185 #endif // CONFIG_NETWORK_LAYER_BLE
 186
 187 void cmd_btp_init()
 188 {
 189 #if CONFIG_NETWORK_LAYER_BLE
 190     // CHIP_ERROR error = CHIP_NO_ERROR;
 191
 192     // Register `device` subcommands with the local shell dispatcher.
 193     sShellDeviceSubcommands.RegisterCommands(cmds_btp, ArraySize(cmds_btp));
 194
 195     // Register the root `btp` command with the top-level shell.
 196     shell_register(&cmds_btp_root, 1);
 197
 198 #endif // CONFIG_NETWORK_LAYER_BLE
 199 }