diff --git a/external/Schusstafel/SHA256SUM.Schusstafel b/external/Schusstafel/SHA256SUM.Schusstafel new file mode 100755 index 000000000..31ef9fa61 --- /dev/null +++ b/external/Schusstafel/SHA256SUM.Schusstafel @@ -0,0 +1,3 @@ +985fd529adec6514f64aede19ffe2ae3e9df0ddcb72041b9d99e57785be4ae3d Schusstafel.h +aaab96761236062e729a2e1a5f37638e579c6096cf6d36c213c2b90753e1e9d8 libSchusstafel.a +20709adcebac0adc7c89bb60c81c09b0dfd2ec9e6623598fb736b410304fb0f1 libSchusstafel.so diff --git a/external/Schusstafel/Schusstafel.h b/external/Schusstafel/Schusstafel.h new file mode 100755 index 000000000..c9e3d2f6b --- /dev/null +++ b/external/Schusstafel/Schusstafel.h @@ -0,0 +1,378 @@ +/*! +// ------------------------------------------------------------------ +// filename : Schusstafel.h +// ------------------------------------------------------------------ +// Time-stamp: "11.09.14-14:02 marienfeld" +// ------------------------------------------------------------------ +// copyright (C) 2011 Rheinmetall Defence Electronics, D-28305 BREMEN +// ------------------------------------------------------------------ +// +// HIER/ITEM : CSU: +// BRIEF DESC: +// AUTHOR : R. Marienfeld, SGTB +// RELEASE : /main/0 +// MODIF/STAT: 09.09.2011 +// ORIGIN REF: +// LANGUAGE : C/C++ +*/ + +#ifndef __SCHUSSTAFEL_H_ +#define __SCHUSSTAFEL_H_ + +#include +#include + +class Schusstafel { + +#define MAXTAFEL 13 /* Standard- und Nicht_Std_Tafel */ +#define MAXCORR 3 /* Anzahl Korrektur-Tafeln */ +#define DATAROWS 600 /* Anzahl Daten-Zeilen pro Tafel */ +#define DATACOLS 16 /* Anzahl Daten-Spalten pro Tafel */ +#define DATAFLNG 48 /* Anzahl Zeichen je Datenfeld */ +#define MAXZIELW 25 /* Anzahl Tafeln Zielhoehenwinkel */ +#define TESTFLAG 0 /* Test der Tafeln beim Einlesen */ + +public: + + typedef enum { + ST_ENTFERNUNG, ST_AUFSATZ, ST_FLUGZEIT + } TAFEL_NAMEN_ET; + + class Fehler : public std::exception { + + public: + explicit Fehler (const std::string& what_arg); + virtual ~Fehler () throw(); + virtual const char* what() const throw(); + + private: + std::string fehler_string; + }; + + Schusstafel (std::string pfad, std::string munitionsart, std::string suffix) + throw (Fehler); + + ~Schusstafel () {}; + +/* + Aufbau der Datenfiles fuer die Schusstafeln + ------------------------------------------- +Die Schusstafeln fuer jede Munition wird in einem eigenen Text-File beschrieben. + +Zu jeder Schusstafel muessen die Datenbloecke "Schuss_Tafel" und "Standard_Tafel" +vorhanden sein. +Optional koennen die "Nicht_Std_Tafel" und die "Korrektur_Tafel" vorhanden sein. + +Die Nicht-Standard-Tafel modifiziert Tafelwerte aus der Standard-Tafel. +Die Korrektur-Tafel modifiziert Tafelwerte aus der Nicht-Standard-Tafel. + +Der Datenblock "Schuss_Tafel" beschreibt die Basis-Parameter einer Munition: +Schuss_Tafel = + Munition = "xxxx" + Version = "XXXX" + Muni_Parameter = { Kaliber = x.x Masse = x.x V0 = x.x } + Std_Parameter = { DELTA_V0 = x.x + LUFTTEMP = x.x + LUFTDRUCK = x.x + LAENGSWIND = x.x + QUERWIND = x.x + PULVERTEMP = x.x } +Diese Parameter koennen mit den Funktionen +"ST_version", "ST_muni_parameter" und "ST_std_parameter" abgefragt werden. + +Der Datenblock "Standard_Tafel" beschreibt die Standard-Parameter einer Munition: +Standard_Tafel = + Spaltengruppe = + Belegung = { AUFSATZ = (2) [-] + VORHALT = (3) [-] + FLUGZEIT = (4) + } + Zeilenlaenge = 4 + Datenblock = { +# ENTF AUFSATZ VORHALT FLUGZEIT V_END + xx x.x x.x x.x x.x + xx x.x x.x x.x x.x +} +Der Parameter "Zeilenlaenge" (besser: Anzahl Spalten) bestimmt wie viele Spalten der +Tabelle eingelesen werden. Sind mehr Spalten in der Tabelle vorhanden als angegeben, +werden die restlichen Spalten nicht beruecksichtigt. +Der Parameter "Belegung" beschreibt den Aufbau der Tabelle: + "name" = (spalte) [dimension] +Bei der Standard-Tafel muessen die Parameter ENTFERNUNG, AUFSATZ, VORHALT und +FLUGZEIT vorhanden sein. Weitere Parameter (z.B. Endgeschwindigkeit, Fallwinkel, ..) +koennen hinzugefuegt werden. +Die (spalte) definiert die Spaltennummer in der Tabelle, ist diese Angabe nicht +vorhanden, wird die Spalte nicht beruecksichtigt. +Die [dimension] definiert die Winkeleinheit. Der Standardwert ist rad, zulaessige +Einheiten sind "-", "mil", "STRICH". +Es werden so viele Zeile eingelesen wie in der Tabelle vorhanden sind. Bei +ballistischen Schusstafeln funktioniert die Berechnung der Anzahl der Zeilen ueber +die Angabe der Entfernung-Range nicht. + +Der Datenblock "Nicht_Std_Tafel" beschreibt die Nicht-Standard-Parameter einer +Munition: +Nicht_Std_Tafel = + Parameter = LUFTTEMP + Tafelwerte = { AUFSATZ FLUGZEIT } + Spaltengruppe = { + Belegung = { AUFSATZ ( x.x ) = (2) [-] + FLUGZEIT ( x.x ) = (4) + AUFSATZ ( x.x ) = (3) [-] + FLUGZEIT ( x.x ) = (5) + } + Zeilenlaenge = 5 + Datenblock = { +# ENTF AUFSATZ AUFSATZ FLUGZEIT FLUGZEIT + xx x.x x.x x.x x.x + xx x.x x.x x.x x.x +} +In dem Beispiel beeinflusst die Lufttemperatur den Aufsatz und die Flugzeit in +Abhaengigkeit der Entfernung. +Ist am Ende der Belegungs-Zeile ein "+/-" angegeben wird das Vorzeichen der Daten +dieser Spalte invertiert. + +Zum Aufbau einer symmetrischen Nicht-Standard-Tafel (z.B. fuer Seitenwind) kann +am Ende der Belegungs-Zeile ein "-(n)" angegeben werden. + Belegung = { VORHALT ( 0.0) = (2) [-] +/- + VORHALT ( 5.0) = (3) [-] + VORHALT ( 10.0) = (4) [-] + VORHALT ( -5.0) = (5) [-] -(3) + VORHALT (-10.0) = (6) [-] -(4) + } + Zeilenlaenge = 6 + Datenblock = { +# ENTF VORHALT VORHALT VORHALT +# 0.0 +5.0 +10.0 + xx -x.x x.x x.x + xx -x.x x.x x.x +} +In dem Beispiel wird aus der Spalte 3 (5m/s) eine neue Spalte 5 (-5m/s) erzeugt. +Die Daten der Spalte 2 (0m/s) werden invertiert. + +*/ + +void ST_tafelwerte (TAFEL_NAMEN_ET arg_name, float arg_wert, + float luftdruck, float lufttemp, float delta_v0, + float querwind, float pulvertemp, + float *entfernung, float *aufsatz, float *vorhalt, + float *flugzeit); +/* diese Funktion liefert fuer die angegebenen Argumente die korrigierten und */ +/* interpolierten Werte fuer Entfernung, Aufsatz, Vorhalt und Flugzeit aus der */ +/* aktuellen Schusstafel. Bei Entfernungen groesser als der max. Tafelwert */ +/* werden die letzten Tafelwerte linear extrapoliert. */ +/* Die Einheit fuer die Aufsatz- und Vorhalt-Winkel ist rad. */ + +void ST_artillerie + (TAFEL_NAMEN_ET arg_name, float arg_wert, float zielhoehenwinkel, + float *entfernung1, float *aufsatz1, float *flugzeit1, float *drift1, + float *entfernung2, float *aufsatz2, float *flugzeit2, float *drift2); +/* diese Funktion liefert fuer die angegebenen Argumente die interpolierten */ +/* Werte fuer Entfernung, Aufsatz, Flugzeit und Drift aus der aktuellen */ +/* Schusstafel. Bei der Funktion Aufsatz, Flugzeit, Drift in Abhaengigkeit */ +/* der Entfernung werden die Werte fuer die untere (in 1) und obere (in 2) */ +/* Winkelgruppe ausgegeben, bei den anderen Funktionen sind diese Werte 0. */ +/* Die Winkel-Einheit ist rad. */ +/* Der Zielhoehenwinkel wird (noch) nicht beruecksichtigt. */ + +int ST_status (std::string *fehler); +/* diese Funktion liefert das Ergebnis vom Einlesen der Schusstafel. */ +/* In "fehler" ist die letzte Fehler-Info enthalten */ +/* return: 0 = fehlerfrei, -1 = Datenfile nicht gefunden, >0 = Fehler */ + +char* ST_version (void); +/* diese Funktion liefert den Versions-String der aktuellen Munition */ + +void ST_muni_parameter (float *kaliber, float *masse, float *v0); +/* diese Funktion liefert die Munitions-Parameter */ + +int ST_std_parameter (std::string tafel, std::string tafelwert, float *value); +/* diese Funktion liefert den Standard-Wert einer Nicht_Std_Tafel */ + +void ST_entfernung_range (float *min, float *max, float *delta); +/* diese Funktion liefert den Entfernung-Bereich der Standard-Tafel */ + +int ST_zielhoehenwinkel (float zielwinkel); +/* diese Funktion waehlt die Tafeln fuer den Zielhoehenwinkel. */ +/* Zwischen allen Tafelwerte wird linear interpoliert. */ +/* Weil die Differenzen der Werte bei grossen Zielhoehenwinkel */ +/* stark nichtlinear sind, (Fehler bei 90 Grad ist unendlich) */ +/* wird der Zielhoehenwinkel auf den kleinsten bzw groessten */ +/* Wert aus den eingelesenen Kommandotafeln begrenzt. */ +/* return: 0 = fehlerfrei, -1 = Schusstafeln nicht gefunden */ + + +private: + + Schusstafel () {}; + +void ST_setze_pfad (std::string pfad, std::string praefix, std::string suffix); +/* vor dem Einlesen von Datenfiles koennen Pfad und Filenamen projektspezifisch */ +/* modifiziert werden */ +/* Open fuer das Datenfile erfolgt mit "" */ +/* Standard fuer Pfad/Filenamen ist "./.sus" */ + +int ST_einlesen (void); +/* liest das Datenfile einer Munitionsart ein und erzeugt eine Schusstafel */ +/* return: 0 = fehlerfrei, -1 = Datenfile nicht gefunden, >0 = Fehler */ + +typedef enum { + ENTF=0, AUFSATZ, VORHALT, FLUGZEIT, DRIFT +} correl_et; + +typedef struct { + char titel[DATAFLNG]; + char einheit[DATAFLNG]; + char vorz[11]; + float wert; +} spalten_typ; + +typedef struct { + float value[DATACOLS]; +} daten_typ; +daten_typ datenblock; + +typedef struct { + int zeilenlaenge; + float zielwinkel; + char parameter[DATAFLNG]; + spalten_typ spalte[DATACOLS+1]; +} beleg_typ; + +typedef struct { + int hoehenwinkel; + int datenzeilen; + int zuordnung[DATAROWS]; + beleg_typ belegung; + daten_typ datenblock[DATAROWS]; +} tafel_typ; +tafel_typ schusstafel[MAXTAFEL+1]; + +typedef struct { + tafel_typ schusstafel[MAXTAFEL+1]; +} zielw_typ; +zielw_typ *pZielwinkel; + +typedef struct { + char parameter[DATAFLNG]; + char belegung[DATAFLNG]; + int datenlen; + daten_typ datenblock[DATAROWS]; +} korrektur_typ; +korrektur_typ korrektur[MAXCORR]; + +typedef struct { + float winkel; + long index; +} elev_typ; +elev_typ elevation[MAXZIELW+2]; + +typedef struct { + char munition[DATAFLNG]; + char version[DATAFLNG]; + char flugbahn[DATAFLNG]; + int parabel; + float zielwinkel; + float kaliber; /* Muni_Parameter */ + float masse; + float v0; + float luftdruck; /* Std_Parameter */ + float lufttemp; + float delta_v0; + float querwind; + float pulvertemp; + float laengswind; + float min; /* Entfernung_Range */ + float max; + float delta; + float scheitel; +} parameter_typ; +parameter_typ parameter; +parameter_typ aktuell; + +#define BUFLNG 512 +#define MILRAD M_PI/3200 +#define MILGRAD 360/6400 + +char ST_file[BUFLNG/2]; +char ST_pfad[BUFLNG/2]; +char ST_praefix[BUFLNG/2]; +char ST_suffix[BUFLNG/2]; +char buffer[BUFLNG]; +char notice[BUFLNG]; +char element[DATAFLNG]; +int inhalt[MAXTAFEL+1]; +float delta_aufs, delta_vorh, delta_zeit; +long fpos1, fpos2; +int col_aufs; +int col_vorh; +int col_zeit; +int winkel; +int error; +int tafel; +int zeile; +int index; +int len; +FILE *fd1; + + +int Elevation_Tafel (FILE *fd, elev_typ *elev); +void Basis_Parameter (void); +void Tafel_einlesen (int tafel); +void Tafel_Belegung (int tafel); +void Korrektur_Tafel (int tafel); +void Standard_Tafel (void); +int Nicht_Std_Tafel (int tafel); +void sortiere_Tafel (int tafel); +void kopiere_Spalte (tafel_typ *ziel, int sp1, tafel_typ von, int sp2); +void aktuelle_Tafel (float luftdruck, float lufttemp, float delta_v0, + float querwind, float pulvertemp); +void neue_tafelwerte (float entfernung, float luftdruck, float lufttemp, + float delta_v0, float querwind, float pulvertemp, + float *aufsatz, float *vorhalt, float *flugzeit); +void ladeSchusstafel (int tafel); +void sucheSpalten (float value, char *tafelwert, + beleg_typ belegung, int *spalte1, int *spalte2); +float abweichung (float value, float entf, int tafel, + std::string spalte, int zeile); +float korrigieren (float value, std::string param, std::string belegung); +int leseDatenblock (daten_typ *daten, int tafel); +void copyDatenblock (daten_typ *ziel, daten_typ *von, + beleg_typ *tafel); +int testDatenblock (tafel_typ tafel, daten_typ *block); +void neuerDatenblock (float winkel, daten_typ *neu, + beleg_typ beleg1, daten_typ *block1, + beleg_typ beleg2, daten_typ *block2); +int sucheTafel (std::string param, std::string tafel); +int ZeileLesen (char *buf); +int leseZeichen (int full); +int DatenZeile (char *buf); +int splitValue (char *buf, char *val); +int fetchValue (char *buf, char *val); +int floatValue (std::string item, float *value); +int sucheString (char *str1, std::string str2); +void setzeEinheit (beleg_typ *tafel); +void sucheEinheit (char *zeile, beleg_typ *tafel); +float interpolieren (float x, float f1, float f0, float x1, float x0); +void upperCase (char *buf, int len); +void cArray (std::string str, char *chr); +}; + +#endif /* __SCHUSSTAFEL_H_ */ + + +/* + ---------------------------------------- + ------ PROGRAM REVISION HISTORY ------ + ---------------------------------------- + +09.09.11: Marienfeld, SGTB, Tel: 457-4657 + first edition +12.07.12: Marienfeld, SGTB, Tel: 457-4657 + Funktion "ST_distanz" hinzugefuegt +04.09.12: Marienfeld, SGTB, Tel: 457-4657 + Die Funktion "ST_distanz" entfaellt +05.05.14: Marienfeld, SGAP, Tel: 457-4657 + Funktion "ST_zielhoehenwinkel" hinzugefuegt +26.06.14: Marienfeld, SGAP, Tel: 457-4657 + Funktion "ST_artillerie" hinzugefuegt +*/ diff --git a/external/Schusstafel/libSchusstafel.a b/external/Schusstafel/libSchusstafel.a new file mode 100755 index 000000000..d6e611df2 Binary files /dev/null and b/external/Schusstafel/libSchusstafel.a differ diff --git a/external/Schusstafel/libSchusstafel.so b/external/Schusstafel/libSchusstafel.so new file mode 100755 index 000000000..9db596d92 Binary files /dev/null and b/external/Schusstafel/libSchusstafel.so differ