{getString('POOR_ACCURACY', this.lang)}
50 | } 51 | {this.accuracyStatus === AccuracyStatus.Medium && 52 |{getString('MEDIUM_ACCURACY', this.lang)}
53 | } 54 | {this.accuracyStatus === AccuracyStatus.Good && 55 |{getString('GOOD_ACCURACY', this.lang)}
56 | } 57 |
53 | 
69 | Tractor Navigator
70 |{dayjs(recording.dateStart).format('MMM DD, YYYY')}
54 |{dayjs(recording.dateStart).format('hh:mm a')} - {dayjs(recording.dateEnd).format('hh:mm a')}
55 |{getString('GALILEO_GALILEO_DUALFREQ', this.lang)}
73 | } 74 | {this.isGalileoSupported === true && this.dualFreqSupported !== true && 75 |{getString('GALILEO_GALILEO_NO_DUALFREQ', this.lang)}
77 |You should consider upgrading to a phone that supports dual frequency signals offered by Galileo
78 |{getString('GALILEO_NO_GALILEO_NO_DUALFREQ', this.lang)}
83 |You will be able to get better accuracy by upgrading to a phone that supports Galileo
84 |
87 | {getString('POOR_GALILEO_DUAL_FREQ', this.lang)}
62 | } 63 | {this.isGalileoSupported === true && this.dualFreqSupported !== true && 64 |{getString('POOR_GALILEO_NO_DUAL_FREQ', this.lang)}
65 | } 66 | {this.isGalileoSupported !== true && this.dualFreqSupported !== true && 67 |{getString('POOR_NO_GALILEO_NO_DUAL_FREQ', this.lang)}
68 | } 69 |{getString('MEDIUM_GALILEO_DUAL_FREQ', this.lang)}
75 | } 76 | {this.isGalileoSupported === true && this.dualFreqSupported !== true && 77 |{getString('MEDIUM_GALILEO_NO_DUAL_FREQ', this.lang)}
79 |{getString('GOOD_GALILEO_DUAL_FREQ', this.lang)}
88 | } 89 |You will be able to get better accuracy by upgrading to a phone that supports dual frequency signals offered by Galileo
94 | } 95 | {this.isGalileoSupported === false && 96 |You will be able to get better accuracy by upgrading to a phone that supports Galileo
97 | } 98 |
99 | {getString('SATELLITE_STATUS', this.lang)}
105 |-
106 |
- {getString('NB_SATELLITE_IN_RANGE', this.lang)}: {this.satelliteData.nbSatellitesInRange} 107 |
- {getString('NB_GALILEO_SATELLITE_IN_RANGE', this.lang)}: {this.satelliteData.nbGalileoSatelliteInRange} 108 |
- {getString('NB_SATELLITE_USED', this.lang)}: {this.satelliteData.nbSatelliteInFix} 109 |
- {getString('NB_GALILEO_SATELLITE_USED', this.lang)}: {this.satelliteData.nbGalileoSatelliteInFix} 110 |
A propos de la précision de positionnement
116 |La précision de positionnement renvoyée par votre téléphone dépend de plusieurs facteurs:
117 |-
118 |
- Est-ce que votre téléphone est compatibles avec la constellation de satellites Galileo ? 119 |
- Est ce qu’il supporte les signaux doubles fréquences ? 120 |
- Combien de satellites sont dans le champs de vision de l’antenne ? 121 |
- Êtes-vous dans une environnement ouvert, en ville, ou proche d’obstacles ? 122 |
About positioning accuracy
128 |Your phone positioning accuracy depends on multiple factors:
129 |-
130 |
- Is it compatible with the Galileo constellation ? 131 |
- Does it support receiving multiple frequency signals ? 132 |
- How many satellites does it has currently in sight ? 133 |
- Are you in an open sky or urban area environment ? 134 |
37 | {this.lang.indexOf('fr') > -1 &&
38 | Cette application a été développée dans le cadre du MyGalileoApp Challenge 2019
40 |Le projet est OpenSource (license MIT)
41 |https://github.com/tdurand/tractornavigator
42 |Equipe
43 |-
44 |
- Vincent Duret 45 |
- Thibault Durand 46 |
A propos de MyGalileoApp Challenge
48 |L’agence du GNSS européen (GSA) a organisé un concours dans lequel des développeurs conçoivent, développent, testent et rendent disponible une application fonctionnelle afin de mettre en avant les avantages liés à Galileo en terme de précision et de disponibilité de signaux de localisation.
49 |Les gagnants de ce challenge reçoivent un prix pouvant aller jusqu’à 100 000 euros. Quelque soit les domaines d’applications, la réalité augmentée, le geo-marketing, la navigation adaptative, les réseaux sociaux, etc… GSA souhaite soutenir les développeurs afin que leurs idées prennent forme et deviennent réalité..
50 |Le concours “MyGalileoApp Challenge” a pour but de lancer une application mobile qui fournit une géolocalisation grâce aux smartphones recevant les signaux de Galileo que ce soit sur la plateforme Android ou iOS. Elle doit également mettre en avant l’importance de Galileo en terme de précision et de disponibilité de signal dans une solution multi constellation / multi fréquences dans le cadre de son utilisation.
51 |A propos de Galileo
52 |Galileo est le système de positionnement par satellites (GNSS) sous contrôle civile qui fournit des information de localisation, navigation et de temps pour les utilisateurs du monde entier.
53 |Galileo améliore le quotidien de nombreux services, entreprises et utilisateurs européens. Par exemple, des utilisateurs peuvent connaîtres leur position exacte avec une précision accrue grâce à la prise en compte de la constellation de satellites Galileo. Le fonctionnement double fréquence avec Galileo offre de nombreux avantages et améliorations en terme de précision et de stabilité de signal.
54 |Aussi, dans un monde où la navigation par satellite a une importance grandissante et dans lequel de nombreux services en sont dépendant, des perturbations ou erreurs ne sont plus acceptables. Galileo permet à l’Europe d’être indépendante sur ce secteur et ainsi d’assurer une stabilité économique en maintenant une disponibilité des ses applications et services. En résumé, Galileo est un catalyseur pour l’innovation Européenne en contribuant directement à la création de nombreux nouveaux produits, emplois tout en permettant à l’Europe d’avoir une part encore plus importante sur le marché mondial des ces services.
55 |Comment la navigation par satellites fonctionne ? GNSS (constellation de satellites) envoie des signaux aux antennes terrestres qui elles même renvoient à l’utilisateur des informations de positions et de temps. Afin d’avoir une mesure précise de cette position et temps, un minimum de 4 satellites est nécessaire. Le nombre de satellites visibles par l’antenne de l’utilisateur est ce qui détermine la précision. Plus il y aura de satellites disponibles ou visibles plus précise sera l’information renvoyée par l’antenne à l’utilisateur.
56 |This app is developed as part of the MyGalileoApp Challenge 2019
61 |It is an Open Source project (license MIT)
62 |https://github.com/tdurand/tractornavigator
63 |Team
64 |-
65 |
- Vincent Duret 66 |
- Thibault Durand 67 |
About MyGalileoApp Challenge
69 |The European GNSS Agency’s (GSA) MyGalileoApp prize competition challenges developers to design, develop, test and launch a mobile application that takes advantage of the increased accuracy and availability provided by Galileo.
70 |The winners take home up to EUR 100,000. Whether it be in the area of augmented reality, geo- marketing, smart navigation, social networking or otherwise – the GSA wants to help you take your idea from concept to reality.
71 |The MyGalileoApp prize Competition challenges to launch a mobile application that provides a position and/or time fix using a Galileo-enabled smartphone equipped with Android /iOS operating system. It must also demonstrate how the increased accuracy/availability provided by Galileo within a multi-constellation/multi- frequency solution adds value to the application.
72 |About Galileo
73 |Galileo is the European Global Navigation Satellite System (GNSS) under civilian control, providing a range of positioning, navigation and timing services to users worldwide. Galileo offers benefits for many European services, businesses and users. For example, users can know their exact position with greater precision thanks to the multi- constellation of receivers that Galileo add to. Galileo’s dual frequency capability offers significant advantages in terms of achievable accuracy, but also in terms of improved resistance to jamming.
74 |Last but not least, due to the ever-growing importance and dependence of satellite navigation applications a potential disruption of a satellite navigation service is unacceptable. Galileo ensures independence that is important to the EU economy, securing the availability of those applications and services. In short, Galileo boosts European innovation, contributing to the creation of many new products and services, creating jobs and allowing Europe to own a greater share of the global market for added value services.
75 |How does satellite navigation work? Global Navigation Satellite Systems send signals to receivers, giving time and positioning information to users. To get an accurate measurement of your time and position, a minimum of four satellites in view are needed. The number of satellites in view of the user’s receiver is what determines how accurately time and location can be worked out. The more satellites in view, the more precise the information received will be.
76 |Technically speaking, this is equivalent to {@code Math.abs(a - b) <= tolerance || 58 | * Double.valueOf(a).equals(Double.valueOf(b))}. 59 | * 60 | *
Notable special cases include: 61 | * 62 | *
-
63 | *
- All NaNs are fuzzily equal. 64 | *
- If {@code a == b}, then {@code a} and {@code b} are always fuzzily equal. 65 | *
- Positive and negative zero are always fuzzily equal. 66 | *
- If {@code tolerance} is zero, and neither {@code a} nor {@code b} is NaN, then {@code a} 67 | * and {@code b} are fuzzily equal if and only if {@code a == b}. 68 | *
- With {@link Double#POSITIVE_INFINITY} tolerance, all non-NaN values are fuzzily equal. 69 | *
- With finite tolerance, {@code Double.POSITIVE_INFINITY} and {@code 70 | * Double.NEGATIVE_INFINITY} are fuzzily equal only to themselves. 71 | *
This is reflexive and symmetric, but not transitive, so it is not an
74 | * equivalence relation and not suitable for use in {@link Object#equals}
75 | * implementations.
76 | *
77 | * @throws IllegalArgumentException if {@code tolerance} is {@code < 0} or NaN
78 | * @since 13.0
79 | */
80 | public static boolean fuzzyEquals(double a, double b, double tolerance) {
81 | checkNonNegative("tolerance", tolerance);
82 | return Math.copySign(a - b, 1.0) <= tolerance
83 | // copySign(x, 1.0) is a branch-free version of abs(x), but with different NaN semantics
84 | || (a == b) // needed to ensure that infinities equal themselves
85 | || (Double.isNaN(a) && Double.isNaN(b));
86 | }
87 |
88 | static double checkNonNegative(String role, double x) {
89 | if (!(x >= 0)) { // not x < 0, to work with NaN.
90 | throw new IllegalArgumentException(role + " (" + x + ") must be >= 0");
91 | }
92 | return x;
93 | }
94 |
95 | /**
96 | * Converts the provided value "a" value to a value "b" given a range of possible values for "a"
97 | * ("minA" and "maxA") and a range of possible values for b ("minB" and "maxB").
98 | *
99 | * If a is less than minA, then minB is returned. If a is more than maxA, then maxB is returned.
100 | *
101 | * @param a the value to be mapped to the range between minB and maxB
102 | * @param minA the minimum value of the range of a
103 | * @param maxA the maximum value of the range of a
104 | * @param minB the minimum value of the range of b
105 | * @param maxB the maximum value of the range of b
106 | * @return the value of b as it relates to the values minB and maxB, based on the provided value a
107 | * and it's range of minA and maxA
108 | */
109 | public static float mapToRange(float a, float minA, float maxA,
110 | float minB, float maxB) {
111 | // If the value is outside the range return the min or max accordingly
112 | if (a < minA) {
113 | return minB;
114 | }
115 | if (a > maxA) {
116 | return maxB;
117 | }
118 |
119 | // Shift ranges to calculate percentages (because default min value may not be 0)
120 | final float maxBshifted = maxB - minB;
121 | final float maxAshifted = maxA - minA;
122 |
123 | // Calculate percentage of given a value to the a range
124 | final float aPercent = (100 * (a - minA)) / maxAshifted;
125 |
126 | // Apply percentage to adjusted b range
127 | final float bShifted = (maxBshifted * aPercent) / 100;
128 |
129 | // Shift b value back using original b range offset and return
130 | return bShifted + minB;
131 | }
132 |
133 | /**
134 | * Returns true if the provided value is a valid floating point value for signal strength, or false if it's not
135 | * @return true if the provided value is a valid floating point value for signal strength, or false if it's not
136 | */
137 | public static boolean isValidFloat(float value) {
138 | return value != 0.0f && !Float.isNaN(value);
139 | }
140 |
141 | /**
142 | * Clamps a value between the given positive min and max. If abs(value) is less than
143 | * min, then min is returned. If abs(value) is greater than max, then max is returned.
144 | * If abs(value) is between min and max, then abs(value) is returned.
145 | *
146 | * @param min minimum allowed value
147 | * @param value value to be evaluated
148 | * @param max maximum allowed value
149 | * @return clamped value between the min and max
150 | */
151 | public static double clamp(double min, double value, double max) {
152 | value = Math.abs(value);
153 | if (value >= min && value <= max) {
154 | return value;
155 | } else {
156 | return (value < min ? value : max);
157 | }
158 | }
159 |
160 | /**
161 | * Converts the provided base 64 string to UTF-8
162 | * @param base64 the base 64 string to convert to UTF-8
163 | * @return the input string converted to UTF-8
164 | */
165 | public static String fromBase64(String base64) throws UnsupportedEncodingException {
166 | byte[] data = Base64.decode(base64, Base64.DEFAULT);
167 | return new String(data, "UTF-8");
168 | }
169 |
170 | /**
171 | * Converts the provided string input to a double, and handles locale issues such as commas
172 | * instead of periods. Does NOT validate input.
173 | * @param input string version of double to be converted
174 | * @return double value of the input string, or null if there is a parsing error
175 | */
176 | public static Double toDouble(String input) {
177 | try {
178 | return NumberFormat.getInstance().parse(input).doubleValue();
179 | } catch (ParseException e) {
180 | e.printStackTrace();
181 | return null;
182 | }
183 | }
184 | }
--------------------------------------------------------------------------------
/src/components.d.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable */
2 | /* tslint:disable */
3 | /**
4 | * This is an autogenerated file created by the Stencil compiler.
5 | * It contains typing information for all components that exist in this project.
6 | */
7 | import { HTMLStencilElement, JSXBase } from "@stencil/core/internal";
8 | import { GeolocationPosition } from "@capacitor/core";
9 | export namespace Components {
10 | interface AccuracyHelper {
11 | }
12 | interface AppAbout {
13 | }
14 | interface AppGpsstatus {
15 | }
16 | interface AppHistory {
17 | }
18 | interface AppHistoryDetails {
19 | "indexOfRecording": number;
20 | }
21 | interface AppHome {
22 | }
23 | interface AppOffline {
24 | }
25 | interface AppRoot {
26 | }
27 | interface AppTabs {
28 | }
29 | interface GalileoModal {
30 | }
31 | interface GuidingHelper {
32 | "distanceToClosestGuidingLine": number;
33 | "isGuidingLineOnRightOrLeft": string;
34 | }
35 | interface GuidingInterface {
36 | "position": GeolocationPosition;
37 | }
38 | interface GuidingSetup {
39 | "handleGuidingLinesDefined": Function;
40 | }
41 | }
42 | declare global {
43 | interface HTMLAccuracyHelperElement extends Components.AccuracyHelper, HTMLStencilElement {
44 | }
45 | var HTMLAccuracyHelperElement: {
46 | prototype: HTMLAccuracyHelperElement;
47 | new (): HTMLAccuracyHelperElement;
48 | };
49 | interface HTMLAppAboutElement extends Components.AppAbout, HTMLStencilElement {
50 | }
51 | var HTMLAppAboutElement: {
52 | prototype: HTMLAppAboutElement;
53 | new (): HTMLAppAboutElement;
54 | };
55 | interface HTMLAppGpsstatusElement extends Components.AppGpsstatus, HTMLStencilElement {
56 | }
57 | var HTMLAppGpsstatusElement: {
58 | prototype: HTMLAppGpsstatusElement;
59 | new (): HTMLAppGpsstatusElement;
60 | };
61 | interface HTMLAppHistoryElement extends Components.AppHistory, HTMLStencilElement {
62 | }
63 | var HTMLAppHistoryElement: {
64 | prototype: HTMLAppHistoryElement;
65 | new (): HTMLAppHistoryElement;
66 | };
67 | interface HTMLAppHistoryDetailsElement extends Components.AppHistoryDetails, HTMLStencilElement {
68 | }
69 | var HTMLAppHistoryDetailsElement: {
70 | prototype: HTMLAppHistoryDetailsElement;
71 | new (): HTMLAppHistoryDetailsElement;
72 | };
73 | interface HTMLAppHomeElement extends Components.AppHome, HTMLStencilElement {
74 | }
75 | var HTMLAppHomeElement: {
76 | prototype: HTMLAppHomeElement;
77 | new (): HTMLAppHomeElement;
78 | };
79 | interface HTMLAppOfflineElement extends Components.AppOffline, HTMLStencilElement {
80 | }
81 | var HTMLAppOfflineElement: {
82 | prototype: HTMLAppOfflineElement;
83 | new (): HTMLAppOfflineElement;
84 | };
85 | interface HTMLAppRootElement extends Components.AppRoot, HTMLStencilElement {
86 | }
87 | var HTMLAppRootElement: {
88 | prototype: HTMLAppRootElement;
89 | new (): HTMLAppRootElement;
90 | };
91 | interface HTMLAppTabsElement extends Components.AppTabs, HTMLStencilElement {
92 | }
93 | var HTMLAppTabsElement: {
94 | prototype: HTMLAppTabsElement;
95 | new (): HTMLAppTabsElement;
96 | };
97 | interface HTMLGalileoModalElement extends Components.GalileoModal, HTMLStencilElement {
98 | }
99 | var HTMLGalileoModalElement: {
100 | prototype: HTMLGalileoModalElement;
101 | new (): HTMLGalileoModalElement;
102 | };
103 | interface HTMLGuidingHelperElement extends Components.GuidingHelper, HTMLStencilElement {
104 | }
105 | var HTMLGuidingHelperElement: {
106 | prototype: HTMLGuidingHelperElement;
107 | new (): HTMLGuidingHelperElement;
108 | };
109 | interface HTMLGuidingInterfaceElement extends Components.GuidingInterface, HTMLStencilElement {
110 | }
111 | var HTMLGuidingInterfaceElement: {
112 | prototype: HTMLGuidingInterfaceElement;
113 | new (): HTMLGuidingInterfaceElement;
114 | };
115 | interface HTMLGuidingSetupElement extends Components.GuidingSetup, HTMLStencilElement {
116 | }
117 | var HTMLGuidingSetupElement: {
118 | prototype: HTMLGuidingSetupElement;
119 | new (): HTMLGuidingSetupElement;
120 | };
121 | interface HTMLElementTagNameMap {
122 | "accuracy-helper": HTMLAccuracyHelperElement;
123 | "app-about": HTMLAppAboutElement;
124 | "app-gpsstatus": HTMLAppGpsstatusElement;
125 | "app-history": HTMLAppHistoryElement;
126 | "app-history-details": HTMLAppHistoryDetailsElement;
127 | "app-home": HTMLAppHomeElement;
128 | "app-offline": HTMLAppOfflineElement;
129 | "app-root": HTMLAppRootElement;
130 | "app-tabs": HTMLAppTabsElement;
131 | "galileo-modal": HTMLGalileoModalElement;
132 | "guiding-helper": HTMLGuidingHelperElement;
133 | "guiding-interface": HTMLGuidingInterfaceElement;
134 | "guiding-setup": HTMLGuidingSetupElement;
135 | }
136 | }
137 | declare namespace LocalJSX {
138 | interface AccuracyHelper {
139 | }
140 | interface AppAbout {
141 | }
142 | interface AppGpsstatus {
143 | }
144 | interface AppHistory {
145 | }
146 | interface AppHistoryDetails {
147 | "indexOfRecording"?: number;
148 | }
149 | interface AppHome {
150 | }
151 | interface AppOffline {
152 | }
153 | interface AppRoot {
154 | }
155 | interface AppTabs {
156 | }
157 | interface GalileoModal {
158 | }
159 | interface GuidingHelper {
160 | "distanceToClosestGuidingLine"?: number;
161 | "isGuidingLineOnRightOrLeft"?: string;
162 | }
163 | interface GuidingInterface {
164 | "position"?: GeolocationPosition;
165 | }
166 | interface GuidingSetup {
167 | "handleGuidingLinesDefined"?: Function;
168 | }
169 | interface IntrinsicElements {
170 | "accuracy-helper": AccuracyHelper;
171 | "app-about": AppAbout;
172 | "app-gpsstatus": AppGpsstatus;
173 | "app-history": AppHistory;
174 | "app-history-details": AppHistoryDetails;
175 | "app-home": AppHome;
176 | "app-offline": AppOffline;
177 | "app-root": AppRoot;
178 | "app-tabs": AppTabs;
179 | "galileo-modal": GalileoModal;
180 | "guiding-helper": GuidingHelper;
181 | "guiding-interface": GuidingInterface;
182 | "guiding-setup": GuidingSetup;
183 | }
184 | }
185 | export { LocalJSX as JSX };
186 | declare module "@stencil/core" {
187 | export namespace JSX {
188 | interface IntrinsicElements {
189 | "accuracy-helper": LocalJSX.AccuracyHelper & JSXBase.HTMLAttributes