sta: fix reconnect ap when ap lost

Signed-off-by: YoungSoo Shin <shinys000114@gmail.com>

README.md

@@ -77,4 +77,13 @@ sudo apt install nodejs npm nanopb
 1.  After flashing, the ESP32 will either connect to the pre-configured Wi-Fi network or start an Access Point (APSTA).
 2.  Check the serial monitor logs to find the IP address assigned to the device in STA mode, or the default AP address (usually `192.168.4.1`).
 3.  Open a web browser and navigate to the device's IP address.
-4.  You should now see the ODROID Remote control panel.
+4.  You should now see the ODROID Remote control panel.
+
+## Docs
+
+- Hardkernel WiKi: [https://wiki.odroid.com/accessory/powermate](https://wiki.odroid.com/accessory/powermate)
+
+## Repo
+
+- Hardkernel Github: [https://github.com/hardkernel/odroid-powermate](https://github.com/hardkernel/odroid-powermate)
+- Original Repo: [https://github.com/shinys000114/odroid-powermate](https://github.com/shinys000114/odroid-powermate)

example/logger/.gitignore

@@ -0,0 +1,5 @@
+/.venv/
+/venv/
+status_pb2.py
+test.csv
+plot.png

example/logger/README.md

@@ -0,0 +1,41 @@
+# Power Consumption Logger Example
+
+Based on this script, you can monitor power consumption and implement graph plotting.
+
+## How to Run the Script
+
+### Install Python Virtual Environment
+
+```shell
+sudo apt install virtualenv
+virtualenv venv
+source venv/bin/activate
+```
+
+### Install require package
+
+```shell
+pip install grpcio-tools requests websockets protobuf pandas matplotlib
+```
+
+### Build `status_pb2.py`
+
+```shell
+python -m grpc_tools.protoc -I ../../proto --python_out=. status.proto
+```
+
+### Execute script
+
+#### Power consumption collection
+```shell
+# python3 logger.py -u <username> -o <name.csv> -p <password> <address>
+python3 logger.py -u admin -p password -o test.csv 192.168.30.5 
+```
+
+#### Plot data
+
+```shell
+python3 csv_2_plot.py test.csv plot.png [--type power voltage current]
+```
+
+![plot.png](plot.png)

example/logger/csv_2_plot.py

@@ -0,0 +1,108 @@
+import argparse
+
+import matplotlib.dates as mdates
+import matplotlib.pyplot as plt
+import pandas as pd
+
+
+def plot_power_data(csv_path, output_path, plot_types):
+    """
+    Reads power data from a CSV file and generates a plot image.
+
+    Args:
+        csv_path (str): The path to the input CSV file.
+        output_path (str): The path to save the output plot image.
+        plot_types (list): A list of strings indicating which plots to generate
+                           (e.g., ['power', 'voltage', 'current']).
+    """
+    try:
+        # Read the CSV file into a pandas DataFrame
+        # The 'timestamp' column is parsed as dates
+        df = pd.read_csv(csv_path, parse_dates=['timestamp'])
+        print(f"Successfully loaded {len(df)} records from '{csv_path}'")
+    except FileNotFoundError:
+        print(f"Error: The file '{csv_path}' was not found.")
+        return
+    except Exception as e:
+        print(f"An error occurred while reading the CSV file: {e}")
+        return
+
+    # --- Plotting Configuration ---
+    plot_configs = {
+        'power': {'title': 'Power Consumption', 'ylabel': 'Power (W)',
+                  'cols': ['vin_power', 'main_power', 'usb_power']},
+        'voltage': {'title': 'Voltage', 'ylabel': 'Voltage (V)',
+                    'cols': ['vin_voltage', 'main_voltage', 'usb_voltage']},
+        'current': {'title': 'Current', 'ylabel': 'Current (A)', 'cols': ['vin_current', 'main_current', 'usb_current']}
+    }
+    channel_labels = ['VIN', 'MAIN', 'USB']
+    channel_colors = ['red', 'green', 'blue']
+
+    num_plots = len(plot_types)
+    if num_plots == 0:
+        print("No plot types selected. Exiting.")
+        return
+
+    # Create a figure and a set of subplots based on the number of selected plot types.
+    # sharex=True makes all subplots share the same x-axis (time)
+    # squeeze=False ensures that 'axes' is always a 2D array, even if num_plots is 1.
+    fig, axes = plt.subplots(num_plots, 1, figsize=(15, 6 * num_plots), sharex=True, squeeze=False)
+    axes = axes.flatten()  # Flatten the 2D array to 1D for easier iteration
+
+    # --- Loop through selected plot types and generate plots ---
+    for i, plot_type in enumerate(plot_types):
+        ax = axes[i]
+        config = plot_configs[plot_type]
+
+        for j, col_name in enumerate(config['cols']):
+            ax.plot(df['timestamp'], df[col_name], label=channel_labels[j], color=channel_colors[j])
+
+        ax.set_title(config['title'])
+        ax.set_ylabel(config['ylabel'])
+        ax.legend()
+        ax.grid(True, which='both', linestyle='--', linewidth=0.5)
+
+    # --- Formatting the x-axis (Time) ---
+    # Improve date formatting on the x-axis
+    # Apply formatting to the last subplot's x-axis
+    last_ax = axes[-1]
+    last_ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
+    last_ax.xaxis.set_major_locator(plt.MaxNLocator(15))  # Limit the number of ticks
+    plt.xlabel('Time')
+    plt.xticks(rotation=45)
+
+    # Add a main title to the figure
+    start_time = df['timestamp'].iloc[0].strftime('%Y-%m-%d %H:%M:%S')
+    end_time = df['timestamp'].iloc[-1].strftime('%H:%M:%S')
+    fig.suptitle(f'ODROID Power Log ({start_time} to {end_time})', fontsize=16, y=0.95)
+
+    # Adjust layout to prevent titles/labels from overlapping
+    plt.tight_layout(rect=[0, 0, 1, 0.94])
+
+    # --- Save the plot to a file ---
+    try:
+        plt.savefig(output_path, dpi=150)
+        print(f"Plot successfully saved to '{output_path}'")
+    except Exception as e:
+        print(f"An error occurred while saving the plot: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a plot from an Odroid PowerMate CSV log file.")
+    parser.add_argument("input_csv", help="Path to the input CSV log file.")
+    parser.add_argument("output_image", help="Path to save the output plot image (e.g., plot.png).")
+    parser.add_argument(
+        "-t", "--type",
+        nargs='+',
+        choices=['power', 'voltage', 'current'],
+        default=['power', 'voltage', 'current'],
+        help="Types of plots to generate. Choose from 'power', 'voltage', 'current'. "
+             "Default is to generate all three."
+    )
+    args = parser.parse_args()
+
+    plot_power_data(args.input_csv, args.output_image, args.type)
+
+
+if __name__ == "__main__":
+    main()

example/logger/logger.py

@@ -0,0 +1,152 @@
+import argparse
+import asyncio
+import csv
+import requests
+import websockets
+from datetime import datetime
+
+# Import the status_pb2.py file generated by `protoc`.
+# This file must be in the same directory as logger.py.
+import status_pb2
+
+
+class OdroidPowerLogger:
+    """
+    A class to connect to the Odroid Smart Power monitoring server and log power data.
+    1. Logs into the server via an HTTP POST request to obtain an authentication token.
+    2. Connects to the WebSocket using the obtained token.
+    3. Receives and decodes binary data in Protobuf format, then prints it.
+    """
+
+    def __init__(self, host, username, password, output_file=None):
+        self.host = host
+        self.username = username
+        self.password = password
+        self.base_url = f"http://{self.host}"
+        self.ws_url = f"ws://{self.host}/ws"
+        self.output_file = output_file
+        self.token = None
+
+    def login(self):
+        """Logs into the server to retrieve an authentication token."""
+        login_url = f"{self.base_url}/login"
+        payload = {"username": self.username, "password": self.password}
+        try:
+            print(f"Attempting to log in to '{login_url}'...")
+            response = requests.post(login_url, json=payload, timeout=5)
+            response.raise_for_status()
+
+            response_json = response.json()
+            if "token" in response_json:
+                self.token = response_json["token"]
+                print("Login successful! Token received.")
+                return True
+            else:
+                print("Login failed: No token in response.")
+                return False
+        except requests.exceptions.RequestException as e:
+            print(f"Error during login: {e}")
+            return False
+
+    async def listen_power_data(self):
+        """Connects to the WebSocket to receive and log power data."""
+        if not self.token:
+            print("Cannot connect to WebSocket without an authentication token.")
+            return
+
+        # Add the authentication token as a query parameter
+        uri = f"{self.ws_url}?token={self.token}"
+
+        csv_file = None
+        csv_writer = None
+
+        try:
+            # --- CSV File Handling ---
+            if self.output_file:
+                try:
+                    # Open the file in write mode, with newline='' to prevent extra blank rows
+                    csv_file = open(self.output_file, 'w', newline='', encoding='utf-8')
+                    csv_writer = csv.writer(csv_file)
+
+                    # Write header
+                    header = [
+                        'timestamp', 'uptime_sec',
+                        'vin_voltage', 'vin_current', 'vin_power',
+                        'main_voltage', 'main_current', 'main_power',
+                        'usb_voltage', 'usb_current', 'usb_power'
+                    ]
+                    csv_writer.writerow(header)
+                    print(f"Logging data to {self.output_file}")
+                except IOError as e:
+                    print(f"Error opening CSV file: {e}")
+                    # If file can't be opened, disable CSV writing
+                    csv_file = None
+                    csv_writer = None
+            # --- End CSV File Handling ---
+
+            async with websockets.connect(uri) as websocket:
+                print(f"Connected to WebSocket: {uri}")
+                while True:
+                    # Receive binary message from the server
+                    message_bytes = await websocket.recv()
+
+                    # Decode the Protobuf message
+                    status_message = status_pb2.StatusMessage()
+                    status_message.ParseFromString(message_bytes)
+
+                    # Process only if the payload type is 'sensor_data'
+                    if status_message.WhichOneof('payload') == 'sensor_data':
+                        sensor_data = status_message.sensor_data
+                        ts_dt = datetime.fromtimestamp(sensor_data.timestamp)
+                        ts_str = ts_dt.strftime('%Y-%m-%d %H:%M:%S')
+
+                        print(f"--- {ts_str} (Uptime: {sensor_data.uptime_sec}s) ---")
+
+                        # Print data for each channel
+                        for name, channel in [('VIN', sensor_data.vin), ('MAIN', sensor_data.main),
+                                              ('USB', sensor_data.usb)]:
+                            print(
+                                f"  {name:<4}: {channel.voltage:5.2f} V | {channel.current:5.3f} A | {channel.power:5.2f} W")
+
+                        # Write to CSV if enabled
+                        if csv_writer:
+                            row = [
+                                ts_dt.isoformat(), sensor_data.uptime_sec,
+                                sensor_data.vin.voltage, sensor_data.vin.current, sensor_data.vin.power,
+                                sensor_data.main.voltage, sensor_data.main.current, sensor_data.main.power,
+                                sensor_data.usb.voltage, sensor_data.usb.current, sensor_data.usb.power
+                            ]
+                            csv_writer.writerow(row)
+
+        except websockets.exceptions.ConnectionClosed as e:
+            print(f"WebSocket connection closed: {e}")
+        except Exception as e:
+            print(f"Error during WebSocket processing: {e}")
+        finally:
+            if csv_file:
+                csv_file.close()
+                print(f"\nCSV file '{self.output_file}' saved.")
+
+    async def run(self):
+        """Runs the logger."""
+        if self.login():
+            await self.listen_power_data()
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Odroid Smart Power Data Logger")
+    parser.add_argument("host", help="Server's host address or IP (e.g., 192.168.1.10)")
+    parser.add_argument("-u", "--username", required=True, help="Login username")
+    parser.add_argument("-p", "--password", required=True, help="Login password")
+    parser.add_argument("-o", "--output", help="Path to the output CSV file.")
+    args = parser.parse_args()
+
+    logger = OdroidPowerLogger(host=args.host, username=args.username, password=args.password, output_file=args.output)
+    await logger.run()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nExiting program.")

main/wifi/priv_wifi.h

@@ -8,5 +8,6 @@
 void wifi_init_sta(void);
 void wifi_init_ap(void);
 void initialize_sntp(void);
+void wifi_set_auto_reconnect(bool enable);
 
 #endif // ODROID_POWER_MATE_PRIV_WIFI_H

main/wifi/sta.c

@@ -81,6 +81,14 @@ void wifi_scan_aps(wifi_ap_record_t** ap_records, uint16_t* count)
     *count = 0;
     *ap_records = NULL;
 
+    wifi_set_auto_reconnect(false);
+
+    wifi_ap_record_t ap_info;
+    if (esp_wifi_sta_get_ap_info(&ap_info) != ESP_OK)
+    {
+        esp_wifi_disconnect();
+    }
+
     // Start scan, this is a blocking call
     if (esp_wifi_scan_start(NULL, true) == ESP_OK)
     {
@@ -100,6 +108,16 @@ void wifi_scan_aps(wifi_ap_record_t** ap_records, uint16_t* count)
             }
         }
     }
+
+    wifi_set_auto_reconnect(true);
+
+    if (esp_wifi_sta_get_ap_info(&ap_info) != ESP_OK)
+    {
+        if (!nconfig_value_is_not_set(WIFI_SSID))
+        {
+            wifi_connect();
+        }
+    }
 }
 
 esp_err_t wifi_get_current_ap_info(wifi_ap_record_t* ap_info)

main/wifi/wifi.c

@@ -16,9 +16,13 @@
 #include "wifi.h"
 
 #include "indicator.h"
+static bool s_auto_reconnect = true;
 
 static const char* TAG = "WIFI";
 
+void wifi_set_auto_reconnect(bool enable) { s_auto_reconnect = enable; }
+
+
 static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data)
 {
     if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STACONNECTED)
@@ -46,10 +50,18 @@ static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t e
     }
     else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
     {
-        led_set(LED_RED, BLINK_TRIPLE);
+        led_set(LED_BLU, BLINK_TRIPLE);
         wifi_event_sta_disconnected_t* event = (wifi_event_sta_disconnected_t*)event_data;
         ESP_LOGW(TAG, "Disconnected from AP, reason: %s", wifi_reason_str(event->reason));
-        // ESP-IDF will automatically try to reconnect by default.
+
+        if (event->reason != WIFI_REASON_ASSOC_LEAVE)
+        {
+            if (s_auto_reconnect && !nconfig_value_is_not_set(WIFI_SSID))
+            {
+                ESP_LOGI(TAG, "Connection lost, attempting to reconnect...");
+                esp_wifi_connect();
+            }
+        }
     }
     else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP)
     {

partitions.csv

@@ -3,4 +3,3 @@
 nvs,data,nvs,0x9000,24K,
 phy_init,data,phy,0xf000,4K,
 factory,app,factory,0x10000,2M,
-littlefs, data, littlefs,   ,1536K,