[Предложение функции] добавление счетчика пройденного расстояния за время нахождения в SRV

[VAKazakov]

Какое решение Вы хотите? Что вы хотите, что бы плагин делал? добавлял в спец переменную координаты уровень топлива на каждом изменении оных в статусе, после возвращения в корабль он бы рассчитывал расстояние за сессию и писал в строку ошибок коннектора расход топлива и пройденное расстояние.

Альтернативный режим - пеший с температурой в цельсиях, кислородом и прогнозом по времени жизни.

Альтернативные варианты Чистое описание того, как еще можно решить проблему

Дополнительные материалы

[Requese]

Оставлю здесь, чтобы засейвить

from math import sin, cos, sqrt, atan2, radians
import sys
import time
import functools
from l10n import Locale

def main_data(self, entry, lat, lon):
    if entry.get("Latitude"):
        self.eventAltName = entry.get("Name")
            self.lat = entry.get("Latitude")
        else:
            self.lat = lat

        if entry.get("Longitude"):
            self.lon = entry.get("Longitude")
        else:
            self.lon = lon
'''
Запись координат по контрольным точкам: "LaunchSRV" и "DockSRV".
'''
def save1(self):

    if (event == "LaunchSRV"):
    lat1 = lat
    lon1 = lon

def save2(self):
     if (event == "DockSRV"):
     lat2 = lat
     lon2= lon

'''
Далее идет процесс подсчета даистанции. Позже сделать триггер на радиус планеты, на которую высаживается пилот. За основу взят радиус Земли.
'''
def transaction(self):

    R = 6373.0

    Rad1lat = radians(lat1)
    Rad1lon = radians(lon1)
    Rad2lat = radians(lat2)
    Rad2lon = radians(lon2)

    dlon = Rad2lon - Rad1lon
    dlat = Rad2lat - Rad1lat

    a = sin(dlat / 2)**2 + cos(Rad1lat) * cos(Rad2lat) * sin(dlon / 2)**2
    c = 2 * atan2(sqrt(a), sqrt(1 - a))

    distance = R * c
    round(distance, 2)
'''
Интерфейс надо доделать.
'''
def update_distance(self):
msg = "SRV distance: ", distance, " km"

[Requese]

Реквест кое как сделан, на счет правильности надо проверить, к тому же надо добавить сообщение о невозможности соединения. Расчеты проверены и верны.

Добавлено:

• триггер и переменная радиуса.
• вывод на интерфейс ЕДСМа о статусе модуля и дистанции.
• флаг plug.FlagsInSRV и проверка, см 16 стр.

Код:

from math import sin, cos, sqrt, atan2, radians
from theme import theme
import sys
import time
import plug
import functools
import requests

class SRV_Distance(self):

this = sys.modules[__name__]
#this.all_coords=[ [ x1 , y1 ], [x2,y2],.....,[xn,yn]] - нужно ли?

def main_data(self, cmdr, lat, lon, ts, radius)[]:

    SRV_Deployed = entry ['Flags'] & plug.FlagsInSRV # проверОчка на деплой срв
    if SRV_Deployed = true

        dist = tk.SRV_stat(SRV_Deployed, text='DISTANCE COUNTER IS ACTIVE')
        '''
        или так: this.SRV_stat = tk.SRV_stat(SRV_Deployed, text='DISTANCE COUNTER IS ACTIVE', foreground="green")
        '''
        payload = {'cmdr': self.cmdr,'distance': main_dist}
        cmdr_serv_start.text = requests.get('http://'. params=payload) # обращение к серваку

        if entry.get("Latitude"): 
            self.eventAltName = entry.get("Name")
                self.lat = entry.get("Latitude")
            else:
                self.lat = lat

        if entry.get("timestamp"):
                self.lat = entry.get("timestamp")
            else:
                self.ts = ts

        if entry.get("Longitude"):
            self.lon = entry.get("Longitude")
            else:
                self.lon = lon

        if entry.get("Radius"):
            self.radius = entry.get("Radius")
            else:
                R = self.radius / 1000 # схрон радиуса планеты

        def launch(self):
            if (event == "LaunchSRV"):
            lat1 = [xn]
            lon1 = [yn]

        def dock(self):
            if (event == "DockSRV"):
            lat2 = [xn]
            lon2 = [yn]

        def transaction(self):

            dlat = radians(lat2-lat1)
            dlon = radians(lon2-lon1)

            a = (sin(dlat/2) * sin(dlat/2) + cos(radians(lat1)) * cos(radians(lat2)) *sin(dlon/2) * sin(dlon/2))
            c = 2 * atan2(sqrt(a), sqrt(1-a))

            d = R * c
            round(d, 2) 

            main_dist = main_dist + d # как? я сам не знаю, ъеъ, но суть думаю понятна

        def update_distance(main_dist, msg):
            msg = "SRV distance: ", main_dist, " km"
            dist = tk.SRV_dist(main_dist, text=msg)
            payload = {'distance': main_dist}
            cmdr_serv_end.text = requests.put('http://'. params=payload)
    else:
        dist = tk.SRV_stat(SRV_Deployed, text='DISTANCE COUNTER IS INACTIVE')

 return (label, SRV_dist, SRV_Deployed) # +this.SRV_stat

[Requese]

Тригеры для ног: LaunchSRV || DockSRV --> OnFoot (bool) вроде усе ¯_(ツ)_/¯

[Requese]

Перебрал весь код. Сделал сохранение и подсчет координат через массивы и циклы.

Удалил старые циклы, добавил виджеты. Осторожно можно запутаться лично я чуть кукухой не поехал

from math import sin, cos, sqrt, atan2, radians
from theme import theme
from typing import Optional, Tuple
import sys
import time
import plug
import functools
import requests
import array
import tkinter as tk

class Distance(self):
    status: Optional[tk.Label]
    this = sys.modules[__name__]
    def main_data(self, cmdr, lat, lon, ts, radius, entry)[]:
        entry.get("SRV_Deployed") == entry ['Flags'] & plug.FlagsInSRV # проверОчка на деплой срв
        if entry.get("SRV_Deployed") == True:
            while entry.get("SRV_Deployed") == False:
                distSRV == tk.SRV_stat(entry.get("SRV_Deployed"), text == 'DISTANCE COUNTER IS ACTIVE [SRV]')
                payload == {'cmdr': self.cmdr,'distance': main_dist}
                CountCycleSRV == 0 #число циклов
                CountCycleSRV += 1
        if CountCycleSRV => 1: # добавляем значения в массив, если цикл повторялся больше 1 раза
            self.latSRV.append(entry.get("Latitude")) #добавляем через append точку
            self.lonSRV.append(entry.get("Longitude")) 
            self.tsSRV.append(entry.get("timestamp")) 
            time.sleep(300)
            else: #первый цикл
                lat == self.latSRV[0]
                self.latSRV[0] == entry.get("Latitude")
                lon == self.tsSRV[0]
                self.lonSRV[0] == entry.get("Longitude")
                ts == self.tsSRV[0]
                self.tsSRV[0] == entry.get("timestamp")
                self.radius == entry.get("Radius")
                R == self.radius / 1000 # схрон радиуса планеты
                time.sleep(300) # задержка 5 минут, чтобы коорд много не быбло
        if entry.get("SRV_Deployed") == True:
            self.latSRV.append(entry.get("Latitude")) 
            self.lonSRV.append(entry.get("Longitude")) 
            self.tsSRV.append(entry.get("timestamp")) 
            break

        entry.get("OnFoot") == entry ['Flags'] & plug.Flags2OnFoot
        if entry.get("OnFoot") == True:
            while entry.get("OnFoot") == False:
                distFT == tk.FT_stat(entry.get("OnFoot"), text == 'DISTANCE COUNTER IS ACTIVE [ON FOOT]')
                payload == {'cmdr': self.cmdr,'distance': main_dist}
                CountCycleFT == 0 #число циклов
                CountCycleFT += 1
        if CountCycleFT => 1:
            self.latFT.append(entry.get("Latitude")) 
            self.lonFT.append(entry.get("Longitude"))
            self.tsFT.append(entry.get("timestamp"))
            time.sleep(300)
            else:
                lat == self.latFT[0]
                self.latFT[0] == entry.get("Latitude")
                lon == self.tsFT[0]
                self.lonFT[0] == entry.get("Longitude")
                ts == self.tsFT[0]
                self.tsFT[0] == entry.get("timestamp")
                self.radius == entry.get("Radius")
                R == self.radius / 1000
                time.sleep(300)
        if entry.get("OnFoot") = True:
            self.latFT.append(entry.get("Latitude")) 
            self.lonFT.append(entry.get("Longitude"))
            self.tsFT.append(entry.get("timestamp"))
            break

    def transaction_srv(self): # подсчет расстояния на СРВ
        CountTransactionSRV == 0 
        while CountCycleSRV == CountTransactionSRV:
            if CountTransactionSRV == 1: # первый цикл
                dlatSRV == radians(latSRV[1]-latSRV[0]) #вычесление расстояния между 2мя точками, в данном случае между 1 и 2, пушто это 1ый цикл
                dlonSRV == radians(lonSRV[1]-lonSRV[0])
                a == (sin(dlatSRV/2) * sin(dlatSRV/2) + cos(radians(latSRV[0])) * cos(radians(latSRV[1])) *sin(dlonSRV/2) * sin(dlonSRV/2))
                c == 2 * atan2(sqrt(a), sqrt(1-a))
                distance_separatelySRV == d[0]
                Dist_sep == R * c
                dSRV[0] == Dist_sepSRV
                CountTransactionSRV =+ 1
                round(Dist_sepSRV, 2)
                return (a, c)
                else: # выполняется, если было больше одного цикла
                    distance_separatelySRV.append(float.Dist_sep)
                    CountTransactionSRV == CountTransactionSRV_add
                    CountTransactionSRV_add =+ 1 # дополнительный счетчик, берет на массив выше, чтобы можно было от чего отнимать
                    dlatSRV == radians(latSRV[CountTransactionSRV_add]-latSRV[CountTransactionSRV]) # не знаю можно ли так делать, но суть в том что: счетчик циклов +1 и выполняются операции над большим массивом
                    dlonSRV == radians(lonSRV[CountTransactionSRV_add]-lonSRV[CountTransactionSRV])
                    aSRV == (sin(dlatSRV/2) * sin(dlatSRV/2) + cos(radians(latSRV[0])) * cos(radians(latSRV[1])) * sin(dlonSRV/2) * sin(dlonSRV/2)) #каждую переменную под определенное вычесление сделал, дубликатов быть не должно (напремер одинаковые переменные между вычеслениями расстояния на ногах и на СРВ, кроме радиуса планеты)
                    cSRV == 2 * atan2(sqrt(aFT), sqrt(1 - aFT))
                    Dist_sepSRV == R * cFT
                    round(Dist_sepSRV, 2)
                    CountTransactionSRV =+ 1
                    return (aSRV, cSRV)
        DistSRV == sum(distance_separatelySRV) # итог на СРВ

    def transaction_FT(self): # аналогичная фича и на ножках 
        CountTransactionFT == 0
        while CountCycleFT == CountTransactionFT:
            if CountTransactionFT == 1:
                dlatFT == radians(latFT[1]-latFT[0])
                dlonFT == radians(lonFT[1]-lonFT[0])
                aFT == (sin(dlatFT/2) * sin(dlatFT/2) + cos(radians(latFT[0])) * cos(radians(latFT[1])) *sin(dlonFT/2) * sin(dlonFT/2))
                cFT == 2 * atan2(sqrt(aFT), sqrt(1-aFT))
                distance_separatelyFT == d[0]
                Dist_sepFT == R * cFT
                dFT[0] == Dist_sepFT
                CountTransactionFT =+ 1
                round(Dist_sepFT, 2)
                return (aFT, cFT)
                else:
                    distance_separatelyFT.append(float.Dist_sep)
                    CountTransactionSRV == CountTransactionSRV_add
                    CountTransactionSRV_add =+ 1
                    dlat == radians(latSRV[CountTransactionSRV_add]-latSRV[CountTransactionSRV])
                    dlon == radians(lonSRV[CountTransactionSRV_add]-lonSRV[CountTransactionSRV])
                    aFT == (sin(dlat/2) * sin(dlat/2) + cos(radians(latSRV[0])) * cos(radians(latSRV[1])) * sin(dlon/2) * sin(dlon/2))
                    cFT == 2 * atan2(sqrt(a), sqrt(1 - a))
                    Dist_sepFT == R * cFT
                    CountTransactionSRV =+ 1
                    return (aFT, cFT)
        DistFT == sum(distance_separatelyFT) # общая дистанция на ножках

    def displaySRV(parent: tk.FrameSRV) -> Tuple[tk.LabelSRV, tk.LabelSRV]: # настройки виджетов, надо доработать
        global status
        labelSRV = tk.LabelSRV(parent, text="Passed on SRV "+'DistFT'+" km.") 
        statusSRV = tk.LabelSRV(parent, text="", foreground="yellow")  
        return (label, status)

    def displayFT(parent: tk.FrameFT) -> Tuple[tk.LabelFT, tk.LabelFT]:
        global status
        labelFT = tk.LabelFT(parent, text="Passed on foot "+'DistFT'+" km.") 
        statusFT = tk.LabelFT(parent, text="", foreground="yellow")  
        return (label, status)