241 lines
7.8 KiB
Go
241 lines
7.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"log/slog"
|
|
"os"
|
|
|
|
reach "forge.cadoles.com/cadoles/go-emlid/reach/client"
|
|
"forge.cadoles.com/cadoles/go-emlid/reach/client/logger"
|
|
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
|
|
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v2/model"
|
|
"github.com/mitchellh/mapstructure"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var (
|
|
host string = "192.168.42.1"
|
|
rawLogLevel string = "ERROR"
|
|
baseAccuracy string = "fix"
|
|
)
|
|
|
|
func init() {
|
|
flag.StringVar(&rawLogLevel, "log-level", rawLogLevel, "log level")
|
|
flag.StringVar(&host, "host", host, "the reachrs module host")
|
|
flag.StringVar(&baseAccuracy, "baseAccuracy", baseAccuracy, "precision required for average position")
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
|
|
ctx := context.Background()
|
|
|
|
client, err := initializeClient(ctx)
|
|
if err != nil {
|
|
fmt.Printf("[FATAL] %+v", err)
|
|
os.Exit(1)
|
|
}
|
|
defer closeClient(ctx, client)
|
|
/// setModem
|
|
if err := updateModem(ctx, client); err != nil {
|
|
fmt.Printf("[FATAL] %+v", err)
|
|
os.Exit(1)
|
|
}
|
|
// Récupération de la configuration
|
|
config, err := retrieveAndProcessConfig(ctx, client)
|
|
if err != nil {
|
|
fmt.Printf("[FATAL] %+v", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Configuration actuelle de la base :\n lat=%v\n lon=%v\n height=%v\n antenna_offset=%v\n accumulation=%v\n\n NTRIPSettings: \n address:%s\n port:%d \n username: %s\n password:%s\n sendPositionToBase:%t\n",
|
|
config.BaseMode.BaseCoordinates.Coordinates.Latitude, config.BaseMode.BaseCoordinates.Coordinates.Longitude, config.BaseMode.BaseCoordinates.Coordinates.Height, config.BaseMode.BaseCoordinates.AntennaOffset, config.BaseMode.BaseCoordinates.Accumulation, 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)
|
|
|
|
//NTRIP Correction
|
|
processNTRIPCorrection(ctx, client, config)
|
|
|
|
//Base configuration
|
|
if err := setBaseToModeAndHold(ctx, client, config, baseAccuracy, 30); err != nil {
|
|
fmt.Printf("[FATAL] %+v", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// AveragePosition
|
|
processAveragePosition(ctx, client)
|
|
}
|
|
|
|
func initializeClient(ctx context.Context) (*reach.Client, error) {
|
|
logLevel, err := logger.ParseLevel(rawLogLevel)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
slog.SetLogLoggerLevel(logLevel)
|
|
|
|
client := reach.NewClient(host)
|
|
if err := client.Connect(ctx); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
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 {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
var config model.Configuration
|
|
if err := mapstructure.Decode(configData, &config); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
return &config, nil
|
|
}
|
|
|
|
func processNTRIPCorrection(ctx context.Context, client *reach.Client, config *model.Configuration) {
|
|
// Configuration des corrections NTRIP
|
|
ntripMsg, err := setupNTRIPCorrections(ctx, client)
|
|
if err != nil {
|
|
fmt.Printf("[FATAL] %+v", err)
|
|
os.Exit(1)
|
|
}
|
|
displayAvailableMountPoint(ntripMsg)
|
|
updateNTRIPMountPoint(ctx, client, config)
|
|
}
|
|
|
|
func setupNTRIPCorrections(ctx context.Context, client *reach.Client) (*protocol.TaskMessage[protocol.NTRIPPayload], error) {
|
|
fmt.Println("\nConfiguration des corrections NTRIP...")
|
|
|
|
// Recherche de points de montage
|
|
ntripMsg, err := client.GetNTRIPMountPoint(ctx)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return ntripMsg, nil
|
|
}
|
|
|
|
func displayAvailableMountPoint(response *protocol.TaskMessage[protocol.NTRIPPayload]) {
|
|
streams := response.Payload.Str
|
|
fmt.Printf("=== %d Streams disponibles ===\n", len(streams))
|
|
fmt.Printf("=== Base < 50 km disponibles ===\n")
|
|
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 setBaseToModeAndHold(ctx context.Context, client *reach.Client, baseConfig *model.Configuration, mode string, accumulation int) error {
|
|
fmt.Printf("Configuration de la base en mode %s-and-hold...\n", baseAccuracy)
|
|
|
|
opts := []protocol.SetBaseOptionFunc{
|
|
protocol.WithBaseLatitude(baseConfig.BaseMode.BaseCoordinates.Coordinates.Latitude),
|
|
protocol.WithBaseLongitude(baseConfig.BaseMode.BaseCoordinates.Coordinates.Longitude),
|
|
protocol.WithBaseHeight(baseConfig.BaseMode.BaseCoordinates.Coordinates.Height),
|
|
protocol.WithBaseAntennaOffset(baseConfig.BaseMode.BaseCoordinates.AntennaOffset),
|
|
protocol.WithBaseMode(fmt.Sprintf("%s-and-hold", mode)),
|
|
protocol.WithAccumulation(accumulation),
|
|
}
|
|
|
|
if err := client.SetBase(ctx, opts...); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
fmt.Printf("Base configurée en mode %s-and-hold\n", baseAccuracy)
|
|
return nil
|
|
}
|
|
|
|
func processAveragePosition(ctx context.Context, client *reach.Client) {
|
|
// Collecte des données de positions
|
|
messageTask, err := averagePosition(ctx, client)
|
|
if err != nil {
|
|
fmt.Printf("[FATAL] %+v", err)
|
|
os.Exit(1)
|
|
}
|
|
displayAveragePositionMessage(messageTask)
|
|
saveAveragedPosition(ctx, client, messageTask)
|
|
|
|
fmt.Println("Configuration terminée avec succès")
|
|
}
|
|
|
|
func averagePosition(ctx context.Context, client *reach.Client) (*protocol.TaskMessage[protocol.AveragePositionPayload], error) {
|
|
fmt.Println("Démarrage de la moyenne des position...")
|
|
messageTask, err := client.AveragePosition(ctx)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return messageTask, nil
|
|
|
|
}
|
|
|
|
func displayAveragePositionMessage(message *protocol.TaskMessage[protocol.AveragePositionPayload]) error {
|
|
fmt.Printf("Position moyennée: lat=%g, lon=%g, altitude=%g\n",
|
|
message.Payload.Coordinates.Latitude, message.Payload.Coordinates.Longitude, message.Payload.Coordinates.Height)
|
|
return nil
|
|
|
|
}
|
|
|
|
func saveAveragedPosition(ctx context.Context, client *reach.Client, message *protocol.TaskMessage[protocol.AveragePositionPayload]) error {
|
|
opts := []protocol.SetBaseOptionFunc{
|
|
protocol.WithBaseLatitude(message.Payload.Coordinates.Latitude),
|
|
protocol.WithBaseLongitude(message.Payload.Coordinates.Longitude),
|
|
protocol.WithBaseHeight(message.Payload.Coordinates.Height),
|
|
protocol.WithBaseAntennaOffset(message.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
|
|
}
|
|
|
|
func updateModem(ctx context.Context, client *reach.Client) error {
|
|
opts := []protocol.SetModemOptionsFunc{
|
|
protocol.WithApn("mmsbouygtel.com"),
|
|
}
|
|
|
|
if err := client.SetModem(ctx, opts...); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
fmt.Println("Modem mis à jour")
|
|
return nil
|
|
}
|