wip

2025-05-27 12:05:43 +02:00
parent 9cbf5b1cde
commit 38a1d5a2c6
10 changed files with 543 additions and 87 deletions
--- a/cmd/average_position/main.go
+++ b/cmd/average_position/main.go
@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log/slog"
 	"os"
+	"time"

 	reach "forge.cadoles.com/cadoles/go-emlid/reach/client"
 	"forge.cadoles.com/cadoles/go-emlid/reach/client/logger"
@ -37,113 +38,277 @@ type Payload struct {
 	AntennaOffset float64     `json:"antenna_offset"`
 }

+type BaseConfig struct {
+	Latitude      float64
+	Longitude     float64
+	Height        float64
+	AntennaOffset float64
+}
+
 func main() {
 	flag.Parse()

 	ctx := context.Background()
-	client := reach.NewClient(host)

+	client, err := initializeClient(ctx)
+	if err != nil {
+		fmt.Printf("[FATAL] %+v", err)
+		os.Exit(1)
+	}
+	defer closeClient(ctx, client)
+
+	// Récupération de la configuration
+	config, err := retrieveAndProcessConfig(ctx, client)
+	if err != nil {
+		fmt.Printf("[FATAL] %+v", err)
+		os.Exit(1)
+	}
+
+	baseConfig := extractBaseConfig(config)
+	fmt.Printf("Configuration base actuelle: lat=%v, lon=%v, height=%v, offset=%v\n\n NTRIPSettings: \n address:%s\n port:%d \n username: %s\n password:%s\n sendPositionToBase:%t\n",
+		baseConfig.Latitude, baseConfig.Longitude, baseConfig.Height, baseConfig.AntennaOffset, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Address, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Port, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Username, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Password, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.SendPositionToBase)
+
+	// Configuration des corrections NTRIP
+	if err := setupNTRIPCorrections(ctx, client, config); err != nil {
+		fmt.Printf("[FATAL] %+v", err)
+		os.Exit(1)
+	}
+
+	//Configuration de la base
+	if err := setBaseToSingleAndHold(ctx, client, baseConfig); err != nil {
+		fmt.Printf("[FATAL] %+v", err)
+		os.Exit(1)
+	}
+
+	// Collecte des données de positions
+	if err := averagePositionAndSave(ctx, client); err != nil {
+		fmt.Printf("[FATAL] %+v", err)
+		os.Exit(1)
+	}
+
+	fmt.Println("Configuration terminée avec succès")
+}
+
+func initializeClient(ctx context.Context) (*reach.Client, error) {
 	logLevel, err := logger.ParseLevel(rawLogLevel)
 	if err != nil {
-		fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-		os.Exit(1)
+		return nil, errors.WithStack(err)
 	}

 	slog.SetLogLoggerLevel(logLevel)

+	client := reach.NewClient(host)
 	if err := client.Connect(ctx); err != nil {
-		fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-		os.Exit(1)
+		return nil, errors.WithStack(err)
 	}

-	defer func() {
-		if err := client.Close(ctx); err != nil {
-			fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-			os.Exit(1)
-		}
-	}()
-
-	// récupération de la configurationa actuelle de la base
-	config, err := retrieveAndProcessConfig(ctx, client)
-	if err != nil {
-		fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-		os.Exit(1)
-	}
-	latitude := config.BaseMode.BaseCoordinates.Coordinates.Latitude
-	longitude := config.BaseMode.BaseCoordinates.Coordinates.Longitude
-	height := config.BaseMode.BaseCoordinates.Coordinates.Height
-	antennaOffset := config.BaseMode.BaseCoordinates.AntennaOffset
-	fmt.Printf("setting base (latitude: %v, longitude: %v, height: %v, antennaOffset: %v", latitude, longitude, height, antennaOffset)
-
-	opts := []protocol.SetBaseOptionFunc{
-		protocol.WithBaseLatitude(latitude),
-		protocol.WithBaseLongitude(longitude),
-		protocol.WithBaseHeight(height),
-		protocol.WithBaseAntennaOffset(antennaOffset),
-		protocol.WithBaseMode("single-and-hold"),
-	}
-	// Passage de la base en "single-and-hold" permettant la collecte des données
-	if err := client.SetBase(ctx, opts...); err != nil {
-		fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-		return
-	}
-
-	client.AveragePosition(ctx)
-	broadcasts, err := reach.OnMessageType(ctx, client, "task_status")
-	if err != nil {
-		fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-		os.Exit(1)
-	}
-
-	for b := range broadcasts {
-
-		data, err := json.MarshalIndent(b, "", "  ")
-		if err != nil {
-			fmt.Printf("[ERROR] %+v", errors.WithStack(err))
-			continue
-		}
-		fmt.Println(string(data))
-		var payload Payload
-		err = mapstructure.Decode(b.Payload, &payload)
-		if err != nil {
-			fmt.Printf("Erreur de désérialisation : %v\n", err)
-			continue
-		}
-
-		// la collecte est terminée, enregistrement du résultat en configuration
-		if b.State == "completed" {
-			fmt.Printf("lat: %g, long: %g, altitude:%g", payload.Coordinates.Latitude, payload.Coordinates.Longitude, payload.Coordinates.Height)
-
-			opts := []protocol.SetBaseOptionFunc{
-				protocol.WithBaseLatitude(payload.Coordinates.Latitude),
-				protocol.WithBaseLongitude(payload.Coordinates.Longitude),
-				protocol.WithBaseHeight(payload.Coordinates.Height),
-				protocol.WithBaseAntennaOffset(payload.AntennaOffset),
-				protocol.WithBaseMode("manual"),
-			}
-			// enregistrement du résultat en configuration
-			if err := client.SetBase(ctx, opts...); err != nil {
-				fmt.Printf("[FATAL] %+v", errors.WithStack(err))
-				return
-			}
-		}
+	return client, nil
+}

+func closeClient(ctx context.Context, client *reach.Client) {
+	if err := client.Close(ctx); err != nil {
+		fmt.Printf("[ERROR] Erreur lors de la fermeture: %+v", errors.WithStack(err))
 	}
 }

 func retrieveAndProcessConfig(ctx context.Context, client *reach.Client) (*model.Configuration, error) {
-
 	configData, err := client.Configuration(ctx)
 	if err != nil {
-		fmt.Printf("[ERROR] %+v", errors.WithStack(err))
-
+		return nil, errors.WithStack(err)
 	}
+
 	var config model.Configuration
-	err = mapstructure.Decode(configData, &config)
-	if err != nil {
-		fmt.Printf("[ERROR] %+v", errors.WithStack(err))
-
+	if err := mapstructure.Decode(configData, &config); err != nil {
+		return nil, errors.WithStack(err)
 	}
-	return &config, nil

+	return &config, nil
+}
+
+func extractBaseConfig(config *model.Configuration) BaseConfig {
+	return BaseConfig{
+		Latitude:      config.BaseMode.BaseCoordinates.Coordinates.Latitude,
+		Longitude:     config.BaseMode.BaseCoordinates.Coordinates.Longitude,
+		Height:        config.BaseMode.BaseCoordinates.Coordinates.Height,
+		AntennaOffset: config.BaseMode.BaseCoordinates.AntennaOffset,
+	}
+}
+
+func setupNTRIPCorrections(ctx context.Context, client *reach.Client, config *model.Configuration) error {
+	fmt.Println("Configuration des corrections NTRIP...")
+
+	// Recherche de points de montage
+	if err := client.GetNTRIPMountPoint(ctx); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return processNTRIPStreams(ctx, client, config)
+}
+
+func processNTRIPStreams(ctx context.Context, client *reach.Client, config *model.Configuration) error {
+	messages, err := reach.OnMessageType(ctx, client, "task_status")
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	timeout := time.NewTimer(30 * time.Second)
+	defer timeout.Stop()
+
+	for {
+		select {
+		case b := <-messages:
+			if b.State == "completed" {
+				return handleNTRIPResponse(ctx, client, config, b)
+			}
+
+		case <-timeout.C:
+			return errors.New("timeout lors de la récupération des streams NTRIP")
+
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func handleNTRIPResponse(ctx context.Context, client *reach.Client, config *model.Configuration, message reach.Broadcast) error {
+	var response model.NTRIPResponse
+	if err := mapstructure.Decode(message, &response); err != nil {
+		return errors.WithStack(err)
+	}
+
+	displayAvailableStreams(response)
+
+	return updateNTRIPMountPoint(ctx, client, config)
+}
+
+func displayAvailableStreams(response model.NTRIPResponse) {
+	streams := response.Payload.Str
+	fmt.Printf("=== %d Streams disponibles ===\n", len(streams))
+	for i, stream := range streams {
+		if stream.Distance < 50 {
+			fmt.Printf("%d. %-15s | %s (%s) | %.1fkm\n",
+				i+1,
+				stream.Mountpoint,
+				stream.ID,
+				stream.Country,
+				stream.Distance)
+		}
+	}
+}
+
+func updateNTRIPMountPoint(ctx context.Context, client *reach.Client, config *model.Configuration) error {
+	opts := []protocol.SetBaseCorrectionsFunc{
+		protocol.WithNTRIPAddress(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Address),
+		protocol.WithNTRIPPort(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Port),
+		protocol.WithNTRIPUsername(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Username),
+		protocol.WithNTRIPPassword(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Password),
+		// todo modification du point de montage ici
+		protocol.WithNTRIPMountPoint("EPI21"),
+		protocol.WithSendPositionToBase(true),
+	}
+
+	if err := client.SetBaseCorrections(ctx, opts...); err != nil {
+		return errors.WithStack(err)
+	}
+
+	fmt.Println("MountPoint NTRIP mis à jour")
+	return nil
+}
+
+func setBaseToSingleAndHold(ctx context.Context, client *reach.Client, baseConfig BaseConfig) error {
+	fmt.Println("Configuration de la base en mode single-and-hold...")
+
+	opts := []protocol.SetBaseOptionFunc{
+		protocol.WithBaseLatitude(baseConfig.Latitude),
+		protocol.WithBaseLongitude(baseConfig.Longitude),
+		protocol.WithBaseHeight(baseConfig.Height),
+		protocol.WithBaseAntennaOffset(baseConfig.AntennaOffset),
+		protocol.WithBaseMode("single-and-hold"),
+	}
+
+	if err := client.SetBase(ctx, opts...); err != nil {
+		return errors.WithStack(err)
+	}
+
+	fmt.Println("Base configurée en mode single-and-hold")
+	return nil
+}
+
+func averagePositionAndSave(ctx context.Context, client *reach.Client) error {
+	fmt.Println("Démarrage du moyennage de position...")
+
+	if err := client.AveragePosition(ctx); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return waitForAverageCompletion(ctx, client)
+}
+
+func waitForAverageCompletion(ctx context.Context, client *reach.Client) error {
+	broadcasts, err := reach.OnMessageType(ctx, client, "task_status")
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	timeout := time.NewTimer(5 * time.Minute)
+	defer timeout.Stop()
+
+	for {
+		select {
+		case b := <-broadcasts:
+			if err := logTaskProgress(b); err != nil {
+				fmt.Printf("[WARNING] %+v", err)
+				continue
+			}
+
+			if b.State == "completed" {
+				return handleAverageCompletion(ctx, client, b)
+			}
+
+		case <-timeout.C:
+			return errors.New("timeout lors du moyennage de position")
+
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func logTaskProgress(message reach.Broadcast) error {
+	data, err := json.MarshalIndent(message, "", "  ")
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	fmt.Println(string(data))
+	return nil
+}
+
+func handleAverageCompletion(ctx context.Context, client *reach.Client, message reach.Broadcast) error {
+	var payload Payload
+	if err := mapstructure.Decode(message.Payload, &payload); err != nil {
+		return errors.WithStack(err)
+	}
+
+	coords := payload.Coordinates
+	fmt.Printf("Position moyennée: lat=%g, lon=%g, altitude=%g\n",
+		coords.Latitude, coords.Longitude, coords.Height)
+
+	return saveAveragedPosition(ctx, client, payload)
+}
+
+func saveAveragedPosition(ctx context.Context, client *reach.Client, payload Payload) error {
+	opts := []protocol.SetBaseOptionFunc{
+		protocol.WithBaseLatitude(payload.Coordinates.Latitude),
+		protocol.WithBaseLongitude(payload.Coordinates.Longitude),
+		protocol.WithBaseHeight(payload.Coordinates.Height),
+		protocol.WithBaseAntennaOffset(payload.AntennaOffset),
+		protocol.WithBaseMode("manual"),
+	}
+
+	if err := client.SetBase(ctx, opts...); err != nil {
+		return errors.WithStack(err)
+	}
+
+	fmt.Println("Position sauvegardée en configuration")
+	return nil
 }
--- a/cmd/broadcast/main.go
+++ b/cmd/broadcast/main.go
@ -17,12 +17,14 @@ var (
 	host        string = "192.168.42.1"
 	filter      string = ""
 	rawLogLevel string = "ERROR"
+	messageType string = "broadcast"
 )

 func init() {
 	flag.StringVar(&rawLogLevel, "log-level", rawLogLevel, "log level")
 	flag.StringVar(&host, "host", host, "the reachrs module host")
-	flag.StringVar(&filter, "filter", filter, "filter the broadcast messages by name")
+	flag.StringVar(&filter, "filter", filter, "filter the socket messages by name")
+	flag.StringVar(&messageType, "messageType", messageType, "socket messages by name")
 }

 func main() {
@ -51,7 +53,7 @@ func main() {
 		}
 	}()

-	broadcasts, err := reach.OnBroadcast(ctx, client)
+	broadcasts, err := reach.OnMessageType(ctx, client, messageType)
 	if err != nil {
 		fmt.Printf("[FATAL] %+v", errors.WithStack(err))
 		os.Exit(1)