Lots of improvements

Author: gorbit99

src/network/connection.cpp

@@ -21,6 +21,8 @@
 	THE SOFTWARE.
 */
 
+#include <cstdint>
+#include <cstring>
 #include <string_view>
 
 #include "GlobalVars.h"
@@ -406,6 +408,38 @@ void Connection::sendFlexData(uint8_t sensorId, float flexLevel) {
 	));
 }
 
+// PACKET_PROVISIONING_NEW_TRACER 29
+void Connection::sendProvisioningNewTracker(uint8_t mac[6]) {
+	MUST(m_Connected);
+	ProvisioningNewTrackerPacket packet{};
+	memcpy(packet.mac, mac, sizeof(packet.mac));
+	MUST(sendPacket(SendPacketType::ProvisioningNewTracker, packet));
+}
+
+// PACKET_PROVISIONING_STATUS 30
+void Connection::sendProvisioningStatus(
+	uint8_t mac[6],
+	ProvisioningPackets::ConnectionStatus status
+) {
+	MUST(m_Connected);
+	ProvisioningStatusPacket packet{
+		.status = status,
+	};
+	memcpy(packet.mac, mac, sizeof(packet.mac));
+	MUST(sendPacket(SendPacketType::ProvisioningStatus, packet));
+}
+
+// PACKET_PROVISIONING_FAILED 31
+void Connection::sendProvisioningFailed(
+	uint8_t mac[6],
+	ProvisioningPackets::ConnectionError error
+) {
+	MUST(m_Connected);
+	ProvisioningFailedPacket packet{.error = error};
+	memcpy(packet.mac, mac, sizeof(packet.mac));
+	MUST(sendPacket(SendPacketType::ProvisioningFailed, packet));
+}
+
 #if ENABLE_INSPECTION
 void Connection::sendInspectionRawIMUData(
 	uint8_t sensorId,

src/network/connection.h

@@ -25,12 +25,16 @@
 
 #include <Arduino.h>
 #include <WiFiUdp.h>
+#include <sys/types.h>
 
+#include <cstdint>
 #include <optional>
 
 #include "../configuration/SensorConfig.h"
+#include "c_types.h"
 #include "featureflags.h"
 #include "globals.h"
+#include "network/wifiprovisioning/provisioning-packets.h"
 #include "packets.h"
 #include "quat.h"
 #include "sensors/sensor.h"
@@ -98,6 +102,19 @@ class Connection {
 	// PACKET_FLEX_DATA 26
 	void sendFlexData(uint8_t sensorId, float flexLevel);
 
+	// PACKET_PROVISIONING_NEW_TRACER 29
+	void sendProvisioningNewTracker(uint8_t mac[6]);
+
+	// PACKET_PROVISIONING_STATUS 30
+	void sendProvisioningStatus(
+		uint8_t mac[6],
+		ProvisioningPackets::ConnectionStatus status
+	);
+
+	// PACKET_PROVISIONING_FAILED 31
+	void
+	sendProvisioningFailed(uint8_t mac[6], ProvisioningPackets::ConnectionError error);
+
 #if ENABLE_INSPECTION
 	void sendInspectionRawIMUData(
 		uint8_t sensorId,

src/network/packets.h

@@ -56,9 +56,9 @@ enum class SendPacketType : uint8_t {
 	AcknowledgeConfigChange = 24,
 	FlexData = 26,
 	// PositionData = 27,
-	ProvisioningNewTracker = 28,
-	ProvisioningStatus = 29,
-	ProvisioningFailed = 30,
+	ProvisioningNewTracker = 29,
+	ProvisioningStatus = 30,
+	ProvisioningFailed = 31,
 	Bundle = 100,
 	Inspection = 105,
 };
@@ -73,7 +73,7 @@ enum class ReceivePacketType : uint8_t {
 	SensorInfo = 15,
 	FeatureFlags = 22,
 	SetConfigFlag = 25,
-	StartWiFiProvisioning = 27,
+	StartWiFiProvisioning = 28,
 };
 
 enum class InspectionPacketType : uint8_t {
@@ -240,16 +240,16 @@ struct StartWiFiProvisioningPacket {
 	bool start;
 };
 
-struct ProvisioningNewTracker {
+struct ProvisioningNewTrackerPacket {
 	uint8_t mac[6];
 };
 
-struct ProvisioningStatus {
+struct ProvisioningStatusPacket {
 	uint8_t mac[6];
 	SlimeVR::Network::ProvisioningPackets::ConnectionStatus status;
 };
 
-struct ProvisioningFailed {
+struct ProvisioningFailedPacket {
 	uint8_t mac[6];
 	SlimeVR::Network::ProvisioningPackets::ConnectionError error;
 };

src/network/wifihandler.cpp

@@ -53,19 +53,21 @@ bool WiFiNetwork::isConnected() const {
 void WiFiNetwork::setWiFiCredentials(const char* SSID, const char* pass) {
 	wifiProvisioning.stopSearchForProvider();
 	wifiProvisioning.stopProvisioning();
-	WiFi.persistent(true);
 	tryConnecting(false, SSID, pass);
 	retriedOnG = false;
-	// Reset state, will get back into provisioning if can't connect
-	hadWifi = false;
 	wifiState = WiFiReconnectionStatus::ServerCredAttempt;
 }
 
+void WiFiNetwork::setProvisionedWiFiCredentials(const char* SSID, const char* pass) {
+	tryConnecting(false, SSID, pass);
+	retriedOnG = false;
+	wifiState = WiFiReconnectionStatus::ProvisionedAttempt;
+}
+
 IPAddress WiFiNetwork::getAddress() { return WiFi.localIP(); }
 
 void WiFiNetwork::setUp() {
-	// Don't need to save the already saved credentials or the hardcoded ones
-	WiFi.persistent(false);
+	WiFi.persistent(true);
 	wifiHandlerLogger.info("Setting up WiFi");
 	WiFi.mode(WIFI_AP_STA);
 	WiFi.hostname("SlimeVR FBT Tracker");
@@ -109,7 +111,6 @@ void WiFiNetwork::setUp() {
 
 void WiFiNetwork::onConnected() {
 	wifiState = WiFiReconnectionStatus::Success;
-	wifiProvisioning.stopProvisioning();
 	statusManager.setStatus(SlimeVR::Status::WIFI_CONNECTING, false);
 	hadWifi = true;
 	wifiHandlerLogger.info(
@@ -201,6 +202,12 @@ void WiFiNetwork::upkeep() {
 				wifiState = WiFiReconnectionStatus::Failed;
 			}
 			return;
+		case WiFiReconnectionStatus::ProvisionedAttempt:  // Couldn't connect with
+														  // credentials received from
+														  // provisioning
+			if (!tryProvisionedCredentials()) {
+				wifiState = WiFiReconnectionStatus::Failed;
+			}
 		case WiFiReconnectionStatus::Failed:  // Couldn't connect with second set of
 											  // credentials or server credentials
 			if (startedProvisioning) {
@@ -347,6 +354,20 @@ bool WiFiNetwork::tryServerCredentials() {
 	return tryConnecting(true);
 }
 
+bool WiFiNetwork::tryProvisionedCredentials() {
+	if (WiFi.status() != WL_DISCONNECTED) {
+		return false;
+	}
+
+	if (retriedOnG) {
+		return false;
+	}
+
+	retriedOnG = true;
+
+	return tryConnecting(true);
+}
+
 bool WiFiNetwork::tryConnecting(bool phyModeG, const char* SSID, const char* pass) {
 #if ESP8266
 	if (phyModeG) {

src/network/wifihandler.h

@@ -38,6 +38,7 @@ class WiFiNetwork {
 		SavedAttempt,
 		HardcodeAttempt,
 		ServerCredAttempt,
+		ProvisionedAttempt,
 		Failed,
 		Success
 	};
@@ -53,23 +54,25 @@ class WiFiNetwork {
 	void setUp();
 	void upkeep();
 	void setWiFiCredentials(const char* SSID, const char* pass);
+	void setProvisionedWiFiCredentials(const char* SSID, const char* pass);
 	static IPAddress getAddress();
 	WiFiReconnectionStatus getWiFiState();
 	bool startedProvisioning = false;
 
+	static String getSSID();
+	static String getPassword();
+
 private:
 	static constexpr float WiFiTimeoutSeconds = 11;
 
 	void reportWifiProgress();
 	void setStaticIPIfDefined();
 	void onConnected();
 
-	static String getSSID();
-	static String getPassword();
-
 	bool trySavedCredentials();
 	bool tryHardcodedCredentials();
 	bool tryServerCredentials();
+	bool tryProvisionedCredentials();
 	bool tryConnecting(
 		bool phyModeG = false,
 		const char* SSID = nullptr,

src/network/wifiprovisioning/provisioning-packets.cpp

@@ -0,0 +1,27 @@
+#include "provisioning-packets.h"
+
+namespace SlimeVR::Network::ProvisioningPackets {
+
+const char* statusToCstr(ConnectionStatus status) {
+	switch (status) {
+		case ConnectionStatus::Connecting:
+			return "Connecting";
+		case ConnectionStatus::Connected:
+			return "Connected";
+		case ConnectionStatus::ServerFound:
+			return "Server Found";
+	}
+	return "Unknown";
+}
+
+const char* errorToCstr(ConnectionError error) {
+	switch (error) {
+		case ConnectionError::ConnectionFailed:
+			return "Connection Failed";
+		case ConnectionError::ServerNotFound:
+			return "Server Not Found";
+	}
+	return "Unknown";
+}
+
+}  // namespace SlimeVR::Network::ProvisioningPackets

src/network/wifiprovisioning/provisioning-packets.h

@@ -5,12 +5,13 @@
 namespace SlimeVR::Network::ProvisioningPackets {
 
 enum class ProvisioningPacketId : uint8_t {
-	ProvisioningAvailable = 0,
-	ProvisioningRequest = 1,
-	ProvisioningStart = 2,
-	ProvisioningStarted = 3,
-	ProvisioningStatus = 4,
-	ProvisioningFailed = 5,
+	ProvisioningAvailable,
+	ProvisioningRequest,
+	ProvisioningStart,
+	ProvisioningStatus,
+	ProvisioningStatusAck,
+	ProvisioningFailed,
+	ProvisioningFailedAck,
 };
 
 #pragma pack(push, 1)
@@ -26,11 +27,15 @@ enum class ConnectionStatus : uint8_t {
 	ServerFound,
 };
 
+const char* statusToCstr(ConnectionStatus status);
+
 enum class ConnectionError : uint8_t {
 	ConnectionFailed,
 	ServerNotFound,
 };
 
+const char* errorToCstr(ConnectionError error);
+
 struct ProvisioningAvailable
 	: ProvisioningPacket<ProvisioningPacketId::ProvisioningAvailable> {};
 
@@ -46,19 +51,22 @@ struct ProvisioningStart : ProvisioningPacket<ProvisioningPacketId::Provisioning
 	char wifiPassword[64] = "";
 };
 
-struct ProvisioningStarted
-	: ProvisioningPacket<ProvisioningPacketId::ProvisioningStarted> {};
-
 struct ProvisioningStatus
 	: ProvisioningPacket<ProvisioningPacketId::ProvisioningStatus> {
 	ConnectionStatus status = ConnectionStatus::Connecting;
 };
 
+struct ProvisioningStatusAck
+	: ProvisioningPacket<ProvisioningPacketId::ProvisioningStatusAck> {};
+
 struct ProvisioningFailed
 	: ProvisioningPacket<ProvisioningPacketId::ProvisioningFailed> {
 	ConnectionError error = ConnectionError::ConnectionFailed;
 };
 
+struct ProvisioningFailedAck
+	: ProvisioningPacket<ProvisioningPacketId::ProvisioningFailedAck> {};
+
 #pragma pack(pop)
 
 }  // namespace SlimeVR::Network::ProvisioningPackets

src/network/wifiprovisioning/provisioning-party.cpp

@@ -1,4 +1,5 @@
 #include <cstdint>
+#include <optional>
 
 #include "logging/Logger.h"
 #include "provisioning-party.h"
@@ -8,6 +9,16 @@ namespace SlimeVR::Network {
 ProvisioningParty::ProvisioningParty(SlimeVR::Logging::Logger& logger) noexcept
 	: logger{logger} {}
 
+void ProvisioningParty::handleSendResult(bool success) { lastPacketSuccess = success; }
+
+void ProvisioningParty::resetLastSendResult() { lastPacketSuccess.reset(); }
+
+std::optional<bool> ProvisioningParty::getLastSendResult() {
+	auto result = lastPacketSuccess;
+	lastPacketSuccess.reset();
+	return result;
+}
+
 void ProvisioningParty::addPeer(uint8_t macAddress[6]) const {
 #if ESP8266
 	esp_now_add_peer(macAddress, ESP_NOW_ROLE_COMBO, 0, nullptr, 0);
@@ -25,12 +36,4 @@ void ProvisioningParty::removePeer(uint8_t macAddress[6]) const {
 	esp_now_del_peer(macAddress);
 }
 
-void ProvisioningParty::sendMessage(
-	uint8_t receiverMac[6],
-	const uint8_t* data,
-	uint8_t length
-) const {
-	// TODO:
-}
-
 }  // namespace SlimeVR::Network