[FL-3889] 5V on GPIO control for ext. modules (#3830)

* Make file extensions case-insensitive
* Bump protobuf version
* Add support for 5V control via RPC
* Add support for 5V control via Expansion protocol
* Update running instructions
* Update expansion module documentation
* Prettify condition
* Test RPC OTG control as well
* Assets: bump protobuf version
* Disable PVS license expiration check, fix PVS warnings

Co-authored-by: あく <alleteam@gmail.com>

applications/services/expansion/expansion_protocol.h

@@ -64,8 +64,28 @@ typedef enum {
  * @brief Enumeration of suported control commands.
  */
 typedef enum {
-    ExpansionFrameControlCommandStartRpc = 0x00, /**< Start an RPC session. */
-    ExpansionFrameControlCommandStopRpc = 0x01, /**< Stop an open RPC session. */
+    /** @brief Start an RPC session.
+     *
+     * Must only be used while the RPC session is NOT active.
+     */
+    ExpansionFrameControlCommandStartRpc = 0x00,
+    /** @brief Stop an open RPC session.
+      *
+      * Must only be used while the RPC session IS active.
+      */
+    ExpansionFrameControlCommandStopRpc = 0x01,
+    /** @brief Enable OTG (5V) on external GPIO.
+      *
+      * Must only be used while the RPC session is NOT active,
+      * otherwise OTG is to be controlled via RPC messages.
+      */
+    ExpansionFrameControlCommandEnableOtg = 0x02,
+    /** @brief Disable OTG (5V) on external GPIO.
+      *
+      * Must only be used while the RPC session is NOT active,
+      * otherwise OTG is to be controlled via RPC messages.
+      */
+    ExpansionFrameControlCommandDisableOtg = 0x03,
 } ExpansionFrameControlCommand;
 
 #pragma pack(push, 1)

applications/services/expansion/expansion_worker.c

@@ -245,9 +245,18 @@ static bool expansion_worker_handle_state_connected(
 
     do {
         if(rx_frame->header.type == ExpansionFrameTypeControl) {
-            if(rx_frame->content.control.command != ExpansionFrameControlCommandStartRpc) break;
-            instance->state = ExpansionWorkerStateRpcActive;
-            if(!expansion_worker_rpc_session_open(instance)) break;
+            const uint8_t command = rx_frame->content.control.command;
+            if(command == ExpansionFrameControlCommandStartRpc) {
+                if(!expansion_worker_rpc_session_open(instance)) break;
+                instance->state = ExpansionWorkerStateRpcActive;
+            } else if(command == ExpansionFrameControlCommandEnableOtg) {
+                furi_hal_power_enable_otg();
+            } else if(command == ExpansionFrameControlCommandDisableOtg) {
+                furi_hal_power_disable_otg();
+            } else {
+                break;
+            }
+
             if(!expansion_worker_send_status_response(instance, ExpansionFrameErrorNone)) break;
 
         } else if(rx_frame->header.type == ExpansionFrameTypeHeartbeat) {
@@ -279,9 +288,14 @@ static bool expansion_worker_handle_state_rpc_active(
             if(size_consumed != rx_frame->content.data.size) break;
 
         } else if(rx_frame->header.type == ExpansionFrameTypeControl) {
-            if(rx_frame->content.control.command != ExpansionFrameControlCommandStopRpc) break;
-            instance->state = ExpansionWorkerStateConnected;
-            expansion_worker_rpc_session_close(instance);
+            const uint8_t command = rx_frame->content.control.command;
+            if(command == ExpansionFrameControlCommandStopRpc) {
+                instance->state = ExpansionWorkerStateConnected;
+                expansion_worker_rpc_session_close(instance);
+            } else {
+                break;
+            }
+
             if(!expansion_worker_send_status_response(instance, ExpansionFrameErrorNone)) break;
 
         } else if(rx_frame->header.type == ExpansionFrameTypeStatus) {

applications/services/gui/modules/byte_input.c

@@ -33,7 +33,7 @@ typedef struct {
 
 static const uint8_t keyboard_origin_x = 7;
 static const uint8_t keyboard_origin_y = 31;
-static const uint8_t keyboard_row_count = 2;
+static const int8_t keyboard_row_count = 2;
 static const uint8_t enter_symbol = '\r';
 static const uint8_t backspace_symbol = '\b';
 static const uint8_t max_drawable_bytes = 8;
@@ -649,11 +649,11 @@ static void byte_input_view_draw_callback(Canvas* canvas, void* _model) {
         }
         canvas_set_font(canvas, FontKeyboard);
         // Draw keyboard
-        for(uint8_t row = 0; row < keyboard_row_count; row++) {
+        for(int8_t row = 0; row < keyboard_row_count; row++) {
             const uint8_t column_count = byte_input_get_row_size(row);
             const ByteInputKey* keys = byte_input_get_row(row);
 
-            for(size_t column = 0; column < column_count; column++) {
+            for(uint8_t column = 0; column < column_count; column++) {
                 if(keys[column].value == enter_symbol) {
                     canvas_set_color(canvas, ColorBlack);
                     if(model->selected_row == row && model->selected_column == column) {

applications/services/rpc/rpc_gpio.c

@@ -2,6 +2,7 @@
 #include "rpc_i.h"
 #include "gpio.pb.h"
 #include <furi_hal_gpio.h>
+#include <furi_hal_power.h>
 #include <furi_hal_resources.h>
 
 static const GpioPin* rpc_pin_to_hal_pin(PB_Gpio_GpioPin rpc_pin) {
@@ -188,6 +189,44 @@ void rpc_system_gpio_set_input_pull(const PB_Main* request, void* context) {
     free(response);
 }
 
+void rpc_system_gpio_get_otg_mode(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(context);
+    furi_assert(request->which_content == PB_Main_gpio_get_otg_mode_tag);
+
+    RpcSession* session = context;
+
+    const bool otg_enabled = furi_hal_power_is_otg_enabled();
+
+    PB_Main* response = malloc(sizeof(PB_Main));
+    response->command_id = request->command_id;
+    response->which_content = PB_Main_gpio_get_otg_mode_response_tag;
+    response->content.gpio_get_otg_mode_response.mode = otg_enabled ? PB_Gpio_GpioOtgMode_ON :
+                                                                      PB_Gpio_GpioOtgMode_OFF;
+
+    rpc_send_and_release(session, response);
+
+    free(response);
+}
+
+void rpc_system_gpio_set_otg_mode(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(context);
+    furi_assert(request->which_content == PB_Main_gpio_set_otg_mode_tag);
+
+    RpcSession* session = context;
+
+    const PB_Gpio_GpioOtgMode mode = request->content.gpio_set_otg_mode.mode;
+
+    if(mode == PB_Gpio_GpioOtgMode_OFF) {
+        furi_hal_power_disable_otg();
+    } else {
+        furi_hal_power_enable_otg();
+    }
+
+    rpc_send_and_release_empty(session, request->command_id, PB_CommandStatus_OK);
+}
+
 void* rpc_system_gpio_alloc(RpcSession* session) {
     furi_assert(session);
 
@@ -212,5 +251,11 @@ void* rpc_system_gpio_alloc(RpcSession* session) {
     rpc_handler.message_handler = rpc_system_gpio_set_input_pull;
     rpc_add_handler(session, PB_Main_gpio_set_input_pull_tag, &rpc_handler);
 
+    rpc_handler.message_handler = rpc_system_gpio_get_otg_mode;
+    rpc_add_handler(session, PB_Main_gpio_get_otg_mode_tag, &rpc_handler);
+
+    rpc_handler.message_handler = rpc_system_gpio_set_otg_mode;
+    rpc_add_handler(session, PB_Main_gpio_set_otg_mode_tag, &rpc_handler);
+
     return NULL;
 }