Question:
Comment convertir de Lat / Long en Grid Square?
PearsonArtPhoto
2013-10-23 17:24:05 UTC
view on stackexchange narkive permalink

Je vois que de nombreux concours, récompenses et autres objets utilisent des carrés de grille pour identifier où ils se trouvent. Comment peut-on déterminer quel est son carré de grille, compte tenu de la latitude / longitude?

Cherchez-vous un algorithme ou une application?
Un algorithme vraiment, mais une application pourrait être utile à d'autres.
Treize réponses:
#1
+25
PearsonArtPhoto
2013-10-23 17:42:51 UTC
view on stackexchange narkive permalink

Tout d'abord, si vous ne voulez pas faire de maths, regardez une carte quadrillée, telle que celle-ci.

Il existe un excellent processus sur cette page, et des ressources supplémentaires de ARRL. Essentiellement, les carrés de la grille contiennent 3 paires, les première et dernière lettres et les chiffres du milieu. La longitude est toujours la première, suivie de la latitude, pour chaque paire. Pour simplifier, supposons que l'Ouest et le Sud sont négatifs lat / long, comme c'est une convention courante. À titre d'exemple, je vais utiliser 32.123 W, 14.321 N. L'essentiel est de faire ce qui suit :

  1. Ajoutez 180 à la longitude, prenez la valeur entière / 20 et ajoutez-en une. Ensuite, déterminez à quelle lettre de l'alphabet correspond, généralement en majuscules. L'exemple sera 147.877 / 20 = 7. En ajouter une donnera la 8e lettre de l'alphabet, ou H. Il reste 7.877.
  2. Prenez le reste de ce qui reste et divisez par 2 en arrondissant vers le bas. Ceci est le nombre, aucune conversion requise. L'exemple donnera une valeur de 3. Notez qu'il reste 1,877.
  3. Prenez le reste qui reste, multipliez par 12 et ajoutez-en un. Arrondissez à l'entier inférieur le plus proche. Il s'agit de la lettre de l'alphabet, généralement écrite en minuscules. L'exemple donne une valeur de 22 + 1 = 23. Ce sera la lettre w.

Latitude

  1. Ajoutez 90 à la longitude et prenez la valeur entière / 10, et ajoutez-en un. Ensuite, déterminez à quelle lettre de l'alphabet correspond, généralement en majuscules. L'exemple sera 104,321 / 10 = 10. En ajouter une donnera la 11e lettre de l'alphabet, ou K. Il reste 4.321.
  2. Prenez le reste de ce qui reste et arrondissez vers le bas. Ceci est le nombre, aucune conversion requise. L'exemple donnera une valeur de 4. Il reste 0,321 note.
  3. Prenez le reste qui reste, multipliez par 24 et ajoutez-en un. Arrondissez à l'entier inférieur le plus proche. Il s'agit de la lettre de l'alphabet, généralement écrite en minuscules. L'exemple donne une valeur de 7 + 1 = 8. Ce sera la lettre h.

En les mettant ensemble par paires, et en alternant la première longitude puis la latitude, le carré de la grille pour 32.123 W, 14.321 N est HK34wh.

#2
+7
Walter Underwood K6WRU
2013-10-23 22:04:57 UTC
view on stackexchange narkive permalink

Si vous souhaitez le faire vous-même, vous pouvez utiliser ce programme Python que j'ai écrit.

  # - * - codage: utf-8 - * - import sys # Convertir la latitude et longitude vers les localisateurs de grille Maidenhead. ## Les arguments sont exprimés en latitude et longitude décimales signées. Par exemple, # l'emplacement de mon QTH Palo Alto, CA est: 37.429167, -122.138056 ou # en degrés, minutes et secondes: 37 ° 24 '49 "N 122 ° 6' 26" Wupper = 'ABCDEFGHIJKLMNOPQRSTUVWX'lower =' abcdefghijklmnopqrstuvwx'def to_grid (dec_lat, dec_lon): sinon (-180< = dec_lon<180): sys.stderr.write ('la longitude doit être -180< = lon<180, étant donné% flon \ n'% decit_s.ex. not (-90< = dec_lat<90): sys.stderr.write ('la latitude doit être -90< = lat<90, étant donné% f \ n'% dec_lat) sys.exit (33) # ne peut pas gérer le pôle nord, désolé, [AR ] adj_lat = dec_lat + 90.0 adj_lon = dec_lon + 180.0 grid_lat_sq = supérieur [int (adj_lat / 10)]; grid_lon_sq = supérieur [int (adj_lon / 20)]; grid_lat_field = str (int (adj_lat% 10)) grid_lon_field = str (int ((adj_lon / 2)% 10)) adj_lat_remainder = (adj_lat - int (adj_lat)) * 60 adj_lon_remainder = ((adj_lon) - int (adj_lon / 2 ) * 2) * 60 grid_lat_subsq = lower [int (adj_lat_remainder / 2.5)] grid_lon_subsq = lower [int (adj_lon_remainder / 5)] retourne grid_lon_sq + grid_lat_sq + grid_lon_field + grid_lat_field + grid_lon_subsq + grid_lat_subsq arguments, latitude et longitude décimales. ' print 'Exemple pour Newington, Connecticut (W1AW):' print 'python maidenhead.py 41.714775 -72.727260' print 'renvoie: FN31pr'def test (): # Les quatre premiers exemples de test proviennent de "Conversion entre géodésiques et systèmes de localisation de grille", # par Edmund T.Tyson N5JTY QST Janvier 1989 test_data = (('Munich', (48.14666,11.60833), 'JN58td'), ('Montevideo', (-34.91, -56.21166), 'GF15vc'), ('Washington , DC ', (38.92, -77.065),' FM18lw '),
('Wellington', (-41.28333,174.745), 'RE78ir'), ('Newington, CT (W1AW)', (41.714775, -72.727260), 'FN31pr'), ('Palo Alto (K6WRU)', (37.413708 , -122.1073236), 'CM87wj'),) print 'Exécution de l'autotest \ n' réussi = Vrai pour nom, latlon, grille dans test_data: print 'Test de% s à% f% f:'% (nom, latlon [0 ], latlon [1]) test_grid = to_grid (latlon [0], latlon [1]) if test_grid! = grid: print 'Failed' + test_grid + 'should be' + grid pass = False else: print 'Passed' + test_grid print '' si réussi: print 'Réussi!' else: print 'Failed!' def main (argv = None): si argv est None: argv = sys.argv if len (argv)! = 3: usage () print '' test () else: print to_grid (float ( argv [1]), float (argv [2])) main ()  
#3
+7
Ossi Väänänen
2015-12-15 04:30:26 UTC
view on stackexchange narkive permalink

Mon premier message dans SO. Voici une version C ... faite pour un projet Arduino.

  void calcLocator (char * dst, double lat, double lon) {int o1, o2, o3; int a1, a2, a3; double reste; // reste de longitude = lon + 180,0; o1 = (entier) (reste / 20,0); reste = reste - (double) o1 * 20,0; o2 = (entier) (reste / 2,0); reste = reste - 2,0 * (double) o2; o3 = (entier) (12,0 * reste); // reste de la latitude = lat + 90,0; a1 = (entier) (reste / 10,0); reste = reste - (double) a1 * 10,0; a2 = (int) (reste); reste = reste - (double) a2; a3 = (entier) (24,0 * reste); dst [0] = (car) o1 + 'A'; dst [1] = (car) a1 + 'A'; dst [2] = (car) o2 + '0'; dst [3] = (car) a2 + '0'; dst [4] = (car) o3 + 'A'; dst [5] = (car) a3 + 'A'; dst [6] = (car) 0;}  
#4
+5
Chris AC2CZ
2015-03-26 06:14:33 UTC
view on stackexchange narkive permalink

Cela m'a aidé. Pour tous ceux qui en ont besoin, voici un portage vers Java:

  public class Location {String latlon; Tête de jeune fille à cordes; Emplacement public (chaîne p1, chaîne p2) {float lat = -100.0f; float lon = 0,0f; essayez {lat = Float.parseFloat (p1); lon = Float.parseFloat (p2); maidenhead = latLonToGridSquare (lat, lon); } catch (Exception e) {// TODO Bloc catch généré automatiquement e.printStackTrace (); }} Public Location (float lat, float lon) {try {maidenhead = latLonToGridSquare (lat, lon); } catch (Exception e) {// TODO Bloc catch généré automatiquement e.printStackTrace (); }} private void gridSquareToLatLon (String grid) {} ​​public String latLonToGridSquare (float lat, float lon) jette Exception {float adjLat, adjLon; char GLat, GLon; Chaîne nLat, nLon; char gLat, gLon; float rLat, rLon; Chaîne U = "ABCDEFGHIJKLMNOPQRSTUVWX"; Chaîne L = U.toLowerCase (); // supporte la bibliothèque Chris Veness 2002-2012 LatLon et // d'autres objets avec des propriétés lat / lon // les propriétés peuvent être des fonctions de lecture, des nombres ou des chaînes si (Float.isNaN (lat)) lance une nouvelle exception ("lat is NaN" ); if (Float.isNaN (lon)) throw new Exception ("lon is NaN"); if (Math.abs (lat) == 90.0) throw new Exception ("carrés de grille invalides aux pôles N / S"); if (Math.abs (lat) > 90) throw new Exception ("latitude invalide:" + lat); if (Math.abs (lon) > 180) throw new Exception ("longitude invalide:" + lon); adjLat = lat + 90; adjLon = lon + 180; GLat = U.charAt ((int) (adjLat / 10)); GLon = U.charAt ((int) (adjLon / 20)); nLat = "" + (int) (adjLat% 10); nLon = "" + (int) ((adjLon / 2)% 10); rLat = (adjLat - (int) (adjLat)) * 60; rLon = (adjLon - 2 * (int) (adjLon / 2)) * 60; gLat = L.charAt ((int) (rLat / 2,5)); gLon = L.charAt ((int) (rLon / 5)); Localisateur de chaîne = "" + GLon + GLat + nLon + nLat + gLon + gLat; localisateur de retour; }}  

Et voici le cas de test JUnit:

  import static org.junit.Assert. *; import org.junit.After; import org.junit.AfterClass; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test ; public class LocationTest {@Test public void testLatLonToGridSquare () {Location loc = new Location (48.14666f, 11.60833f); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "JN58td"); loc = nouvel emplacement ("- 34.91", "- 56.21166"); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "GF15vc"); loc = nouvel emplacement (38.92f, -77.065f); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "FM18lw"); loc = nouvel emplacement (-41,28333f, 174,745f); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "RE78ir"); loc = nouvel emplacement (41.714775f, -72.727260f); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "FN31pr"); loc = nouvel emplacement (37.413708f, -122.1073236f); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "CM87wj"); loc = nouvel emplacement (35.0542f, -85.1142f); System.out.println (loc.maidenhead); assertEquals (loc.maidenhead, "EM75kb"); }}  
#5
+3
dh1tw
2014-10-12 05:09:47 UTC
view on stackexchange narkive permalink

J'ai inclus des calculs basés sur Locator dans PyHamTools - une bibliothèque python open source, facile à utiliser:

C'est aussi simple que ceci:

  de pyhamtools .locator import calcul_distance, latlong_to_locatorlocator1 = latlong_to_locator (48,52, 9,375) locator2 = latlong_to_locator (-32,77, 152,125) distance = calcul_en-tête (locator1, locator2) print ("%. 1fkm"% distance) 16466,4 km   

Pour plus d'exemples et la documentation, consultez: http://pyhamtools.readthedocs.org/en/latest/index.html

#6
+2
Dan KD2EE
2013-10-23 17:32:42 UTC
view on stackexchange narkive permalink

Vous pouvez commencer par utiliser une carte, mais cela devient incontrôlable une fois que vous dépassez le deuxième ensemble de chiffres. Il existe des calculatrices en ligne, comme celle-ci de QRZ ou ce localisateur cartographique. Il est également possible de le calculer à la main - l ' article Wikipédia a une bonne description de leur fonctionnement.

Fondamentalement, les deux premiers caractères créent une grille, comme sur n'importe quel carte. Le premier caractère est la longitude, le second la latitude et la première paire de lettres A-R, ce qui signifie que le monde est divisé en 18 tranches. Comme il y a 360 degrés de longitude et 180 degrés de latitude, cela signifie que chaque carré de la grille mesure environ 18 degrés de largeur sur 9 degrés de hauteur. Il commence à 180 degrés ouest et 90 degrés sud, donc si je suis dans la sixième grille à l'est de 180 degrés W (ce qui signifie que ma longitude est comprise entre 72 ouest et 90 W), mon premier caractère est F. Ensuite, la deuxième paire de digits divise cela en 10 tranches égales, et ainsi de suite.

#7
+2
Damion Junk
2015-08-03 20:19:53 UTC
view on stackexchange narkive permalink

Je n'ai vu aucune réponse contenant le carré étendu comme indiqué dans l'article Wikipédia. L'implémentation My Clojure (GitHub Gist Here) encode les quatrième et cinquième paires.

  (defn to-maidenhead [lat long] (let [long (-> long ( + 180) (/ 2)) lat (-> lat (+ 90)) funs [# (* 10 (mod% 1)) # (* 24 (mod% 1)) # (* 10 (mod% 1)) # (* 24 (mod% 1))] voitures [\ A \ 0 \ a \ 0 \ a]] (carte (fn [geo] (carte (fn [n voiture] (char (+ (int voiture) n) )) (réductions (fn [n fun] (fun n)) (/ geo 10) funs) cars)) [long lat]))) (def to-maidenhead-str (comp # (apply str%) # (apply interleave%) to-maidenhead))  

Un simple test:

  (comment (appliquer str (appliquer entreleave (to-maidenhead 36.165926 -86.723285 ))) ;; = > "EM66pd39et" (et (= "EM66pd39et" (to-maidenhead-str 36.165926 -86.723285)) (= "OF86cx76ql" (to-maidenhead-str -33.014673 116.230695)) (= "FD54o to-maidenhead-str -55.315349 -68.794971)) (= "PM85ge79vh" (to-ma idenhead-str 35.205535 136.56579))) ;; = > vrai ;; Juste un simple test à différentes coordonnées dans le monde entier. ;; Maidenhead Locator extrait de http://no.nonsense.ee/qth/map.html)  
#8
+1
J damne
2015-12-25 23:56:09 UTC
view on stackexchange narkive permalink

Jetez un œil à numpy.meshgrid

http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.meshgrid.html

Les liens en eux-mêmes ne sont pas de très bonnes réponses. Peut-être pourriez-vous ajouter plus de détails, comme expliquer ce que fait numpy.meshgrid et comment l'utiliser de manière pertinente?
#9
+1
Paul King
2016-07-08 01:00:37 UTC
view on stackexchange narkive permalink

Les solutions que j'ai vues semblent toutes ressasser le même code sans réfléchir à ce qui se passe réellement. J'ai décidé d'écrire une solution qui résout le cas général, ce qui simplifie l'extension de la précision du résultat à n'importe quelle longueur. Puisque je suis développeur iOS, la solution est dans Swift:

  private let upper = "ABCDEFGHIJKLMNOPQRSTUVWX" private let lower = "abcdefghijklmnopqrstuvwx" public func maidenhead (latitude: Double, longitude: Double) - > String {var lonDegrees: Double = 360 var latDegrees: Double = 180 var lon = longitude + 180.0 var lat = latitude + 90.0 var lonRemainder = lon var latRemainder = lat func gridPair (divisions: Double) -> (Double, Double) { lonDegrees = lonDegrees / divisions latDegrees = latDegrees / divisions lon = lonRemainder / lonDegrees lonRemainder = lonRemainder% lonDegrees lat = latRemainder / latDegrees latRemainder = latRemainder% latDegrees return (lon, latair)} let (gridLonField) gridLonSquare, gridLatSquare) = gridPair (10) let (gridLonSubSquare, gridLatSubSquare) = gridPair (24) let (gridLonExtSquare, gridLatExtSquare) = gridPair (10) le t (gridLonSubExtSquare, gridLatSubExtSquare) = gridPair (24) return "\ (supérieur [Int (gridLonField)]) \ (supérieur [Int (gridLatField)]) \ (Int (gridLonSquare)) \ (Int (gridLatSquare)) \ (inférieur [Int (gridLonSubSquare)]) \ (lower [Int (gridLatSubSquare)]) \ (Int (gridLonExtSquare)) \ (Int (gridLatExtSquare)) \ (lower [Int (gridLonSubExtSquare)]) \ (lower [Int (gridLatSubExtSquare)) ) "}  
#11
  0
Paul
2015-01-26 03:33:11 UTC
view on stackexchange narkive permalink

En Javascript, je n'ai pas trouvé de bibliothèque de carrés de grille avec Google, bien qu'il existe évidemment du code sur plusieurs sites Web de cartographie de ham.

J'ai donc codé HamGridSquare.js basé en partie sur la réponse de K6WRU ci-dessus.

Il réussit ses tests.

Les définitions de fonction sont compatibles avec le framework MeteorJS et supportent diverses entrées.

Un appel à latLonFromGridSquare () peut avoir deux paramètres numériques ou chaîne (lat, lon) ou un seul paramètre qui est un tableau ou un objet avec propriétés numériques, de chaîne ou de fonction ([lat, lon]) ({lat: nnn, lon: nnn}) ({lat: latGetterFunc, lon: lonGetterFunc}) . Ce dernier doit être compatible avec les objets LatLon créés par la bibliothèque LatLon JS de Chris Veness. La bibliothèque LatLon de Chris fournit un moyen de calculer les distances et les relèvements.

  // HamGridSquare.js // Copyright 2014 Paul Brewer KI6CQ // Licence: Licence MIT http://opensource.org/licenses / MIT ou CC-BY-SA //// Routines Javascript pour convertir de lat-lon à Maidenhead Grid Squares // généralement utilisées dans les opérations Ham Radio Satellite et les concours VHF //// Inspiré en partie par la réponse python de K6WRU Walter Underwood / / http://ham.stackexchange.com/a/244// à cette question de débordement de pile: // Comment peut-on convertir de Lat / Long en Grid Square // http://ham.stackexchange.com/questions/221 / comment-peut-on-convertir-de-lat-long-en-grille-carré // latLonToGridSquare = function (param1, param2) {var lat = -100.0; var lon = 0,0; var adjLat, adjLon, GLat, GLon, nLat, nLon, gLat, gLon, rLat, rLon; var U = 'ABCDEFGHIJKLMNOPQRSTUVWX' var L = U.toLowerCase (); // supporte la bibliothèque Chris Veness 2002-2012 LatLon et // d'autres objets avec des propriétés lat / lon // propriétés peuvent être des fonctions de lecture, des nombres ou des chaînes function toNum (x) {if (typeof (x) === 'number' ) retourne x; if (typeof (x) === 'string') return parseFloat (x); if (typeof (x) === 'function') return parseFloat (x ());
throw "HamGridSquare - toNum - ne peut pas convertir l'entrée:" + x; } if (typeof (param1) === 'objet') {if (param1.length === 2) {lat = toNum (param1 [0]); lon = toNum (param1 [1]); } else if (('lat' dans param1) && ('lon' dans param1)) {lat = toNum (param1.lat); lon = toNum (param1.lon); } else if (('latitude' dans param1) && ('longitude' dans param1)) {lat = toNum (param1.latitude); lon = toNum (param1.longitude); } else {throw "HamGridSquare - impossible de convertir l'objet -" + param1; }} else {lat = toNum (param1); lon = toNum (param2); } if (isNaN (lat)) throw "lat is NaN"; if (isNaN (lon)) throw "lon is NaN"; if (Math.abs (lat) === 90.0) throw "carrés de grille invalides aux pôles N / S"; if (Math.abs (lat) > 90) jette "latitude invalide:" + lat; if (Math.abs (lon) > 180) jette "longitude invalide:" + lon; adjLat = lat + 90; adjLon = lon + 180; GLat = U [Math.trunc (adjLat / 10)]; GLon = U [Math.trunc (adjLon / 20)]; nLat = '' + Math.trunc (adjLat% 10); nLon = '' + Math.trunc ((adjLon / 2)% 10); rLat = (adjLat - Math.trunc (adjLat)) * 60; rLon = (adjLon - 2 * Math.trunc (adjLon / 2)) * 60; gLat = L [Math.trunc (rLat / 2.5)]; gLon = L [Math.trunc (rLon / 5)]; return GLon + GLat + nLon + nLat + gLon + gLat;} testGridSquare = function () {// Les quatre premiers exemples de test proviennent de "Conversion Between Geodetic and Grid Locator Systems", // par Edmund T. Tyson N5JTY QST Janvier 1989 / / données de test originales / citations de Walter Underwood K6WRU // dernier test et codage en Javascript à partir de Python par Paul Brewer KI6CQ var testData = [['Munich', [48.14666,11.60833], 'JN58td'], ['Montevideo', [ [-34.91, -56.21166]], 'GF15vc'], ['Washington, DC', [{lat: 38.92, lon: -77.065}], 'FM18lw'], ['Wellington', [{latitude: -41.28333 , longitude: 174,745}], 'RE78ir'], ['Newington, CT (W1AW)', [41.714775, -72.727260], 'FN31pr'], ['Palo Alto (K6WRU)', [[37.413708, -122.1073236] ], 'CM87wj'],
['Chattanooga (KI6CQ / 4)', [{lat: function () {return "35.0542"; }, lon: function () {return "-85.1142"}}], "EM75kb"]]; var i = 0, l = testData.length, result = '', thisPassed = 0, totalPassed = 0; for (i = 0; i<l; ++ i) {result = latLonToGridSquare.apply ({}, testData [i] [1]); thisPassed = résultat === testData [i] [2]; console.log ("test" + i + ":" + testData [i] [0] + "" + JSON.stringify (testData [i] [1]) + "result =" + résultat + "attendu =" + testData [ i] [2] + "passé =" + thisPassed); totalPassed + = thisPassed; } console.log (totalPassed + "sur" + l + "test réussi"); return totalPassed === l;}  
Probablement un long plan, mais sauriez-vous comment étendre ce code pour prendre également un paramètre de distance et renvoyer un tableau de carrés de la grille dans un cercle avec la distance comme rayon?
@SteveE il existe des bibliothèques dans lesquelles vous pouvez donner un long cap et une distance et récupérer les coordonnées de destination. Appelez cela dans une boucle car le cap est varié et convertissez toutes les coordonnées de destination en carrés de la grille. Ensuite, nettoyez-le en triant la liste et en supprimant les doublons. Bonne chance.
#12
  0
tomfanning
2017-02-03 05:00:30 UTC
view on stackexchange narkive permalink

Version C #

  public static String LatLonToGridSquare (double lat, double lon) {double adjLat, adjLon; char GLat, GLon; Chaîne nLat, nLon; char gLat, gLon; double rLat, rLon; Chaîne U = "ABCDEFGHIJKLMNOPQRSTUVWX"; Chaîne L = U.ToLower (); if (double.IsNaN (lat)) throw new Exception ("lat is NaN"); if (double.IsNaN (lon)) throw new Exception ("lon is NaN"); if (Math.Abs ​​(lat) == 90.0) throw new Exception ("carrés de grille invalides aux pôles N / S"); if (Math.Abs ​​(lat) > 90) throw new Exception ("invalid latitude:" + lat); if (Math.Abs ​​(lon) > 180) throw new Exception ("longitude invalide:" + lon); adjLat = lat + 90; adjLon = lon + 180; GLat = U [(int) (adjLat / 10)]; GLon = U [(int) (adjLon / 20)]; nLat = "" + (int) (adjLat% 10); nLon = "" + (int) ((adjLon / 2)% 10); rLat = (adjLat - (int) (adjLat)) * 60; rLon = (adjLon - 2 * (int) (adjLon / 2)) * 60; gLat = L [(entier) (rLat / 2,5)]; gLon = L [(int) (rLon / 5)]; Localisateur de chaîne = "" + GLon + GLat + nLon + nLat + gLon + gLat; localisateur de retour;}  
#13
  0
KN4BIA
2017-12-28 08:12:39 UTC
view on stackexchange narkive permalink

Juste une amélioration pour l'une des réponses ci-dessus d'Ossi Väänänen commençant par ceci:

  void calcLocator (char * dst, double lat, double lon) {[...] dst [ 0] = (char) o1 + 'A'; dst [1] = (car) a1 + 'A'; dst [2] = (car) o2 + '0'; dst [3] = (car) a2 + '0'; dst [4] = (car) o3 + 'A'; dst [5] = (car) a3 + 'A'; dst [6] = (car) 0; }  

Pensez à convertir les valeurs dst en caractères ascii. Remplacez les entrées du tableau dst ci-dessus par ce qui suit:

  dst [0] = char (o1 + 65); dst [1] = car (a1 + 65); dst [2] = car (o2 + 48); dst [3] = car (a2 + 48); dst [4] = car (o3 + 97); dst [5] = char (a3 + 97);  

Plus 65 vous donne les valeurs des lettres ascii pour les majuscules, +48 pour les nombres et +97 pour les minuscules.

Exemple de résultats comme suit:

  char grid [4]; calcLocator (grid, gps.location.lat (), gps.location.lng ()); Serial.print ( grid); // les résultats seront au format suivant: AB01ab  

73's all



Ce Q&R a été automatiquement traduit de la langue anglaise.Le contenu original est disponible sur stackexchange, que nous remercions pour la licence cc by-sa 3.0 sous laquelle il est distribué.
Loading...