Comme son nom l' indique , ce multiplexeur NMEA permettra de recevoir des données de plusieurs sources différentes ( AIS, GPS, ....) et de les envoyer vers un PC , un iPad , un smartphone , une centrale de navigation ,....sur un port USB , un port Ethernet , un réseau wifi ,......

Le cœur du système sera un contrôleur Arduino Méga 2560

Découverte du contrôleur Arduino
1 | La carte Arduino Méga 2560 et son câble USB

2 | Télécharger le logiciel  Arduino
Dernière version sur la page  download page.
Déziper l’ archive…..

 

Remarque :il est possible d' utiliser une tablette Android au lieu d' un PC arduinodroid

L'application prend environ 210MB :assurez-vous que vous avez suffisamment d'espace libre dans la mémoire interne car elle ne peut être installée sur la carte SD à cause de la politique de sécurité d'Android.

3 | Connecter la carte
Les cartes Arduino Méga reconnaissent automatiquement l’ alimentation qu’ elle vienne de la prise alimentation ( de 7 à 12 Volts ) ou de la prise USB
Connecter  la carte au PC avec  le câble  USB. La LED verte s’ allume .

4 | Installer  les drivers
Dans le répertoire du logiciel Arduino aller dans le répertoire Drivers  et double cliquer sur dpinst-amd64.exe si le PC Windows 7 ou8  sont 64 bit sinon sur dpinst-x86.exe; sur mon PC de Nav avec XPSP3 le driver fourni avec le programme ne fonctionne pas , j' ai utilisé celui ci.

5 | Lancer l’ application  Arduino

Le langage français doit être reconnu sinon le choisir dans FICHIERS/Préférences

6 | Ouvrir l’ exemple blink
Cet exemple permet de se familiariser avec le micro contrôleur: il s’ agit de faire clignoter une LED à intervalle pré défini.

Brancher une LED entre les Pin 13 et GND; une LED 12 volts de tableau électrique peut faire l' affaire ( elle éclairera faiblement).

7 | Sélectionner le type de carte

8 | Sélectionner le Port  Série

9 | Uploader  le Programme (téléverser)

Après quelques secondes , le programme est dans le micro contrôleur et démarre : la LED clignote
Facile !!!!!.....................les choses sérieuses maintenant:

Nous allons fabriquer un multiplexeur NMEA 0183 USB et Wifi, mais avec ce contrôleur il est possible de faire beaucoup plus ,.....un multiplexeur NMEA 0183 et 2000 , une centrale de navigation , etc ...

On peut lui adjoindre des modules complémentaires , Bluetooth , Wifi , GPS ,.... nous allons utiliser le module Ethernet.

 

 

 

 

Recevoir des entrées NMEA 0183 sur le contrôleur et les lire

L'interface électrique :


C'est l'interface série RS232 ,composée de 3 fils : Tx (émission), Rx (réception) et GND (référence) , qui est la plus utilisée par les équipements compatibles NMEA 0183(surtout le PC). L'interface différentielle RS422 ( composée de 4 fils (TX+ Tx-) et ( Rx+ Rx-) est aussi  très utilisé utilisée pour la communication avec les appareils autres que le PC( VHF,lecteur de cartes,...) ; c' est à partir de cette dernière interface que nous allons construire notre multiplexeur ; il est néanmoins très facile de remplacer cette interface par une interface RS232 .....si nécessaire; je dis si nécessaire car les entrées-sorties NMEA à 3 fils des appareils ne sont pas de vrais RS232 au niveau des tensions qui varient entre le -5 v et le + 5 V , plus proches du standard RS422.(voir le tableau ci dessous qui indique le niveau de tension pour ces 2 standards)

 

les tensions varient de +5 Volts (niveau 0) à -5 Volts (niveau 1) par rapport à la masse (GND), voir tableau ci dessous)

 

La tension de à 5 Volts est envoyée entre + et - ( niveau 0) ou entre - et + ( niveau 1)

 

La tension entre Rx + et Rx - variera entre + 5 Volts et - 5 Volts :IMPORTANT ,NE PAS RELIER LE RX- à la MASSE

C' est ce montage qu'il faudra employer pour notre multiplexeur en présence d' une liaison 3 fils

 

C' est ce schéma par exemple de la sortie série 38400 bauds des VHF AIS Navicom ou Radio Océan; les fils sont bleu et gris plus la masse , entre bleu et gris c' est une liaison RS422 et entre bleu et la masse une liaison RS232.

 

Matériel nécessaire:

 

En plus de l’ Arduino  sur lequel les pins  TX0 1 (transmit) et RX0 0 (receive) sont connectés a l’ USB (donc le PC) et ne sont donc pas disponibles pour notre multiplexage. Les phrases NMEA reçu seront renvoyées sur ce port USB.

  • Une platine d’ essai et des fils de câblage pour la platine.
  • Des CI 75175 et 75174 (ce dernier n' est utile que pour une sortie nmea , pas obligatoirement utile) pour convertir les signaux RS422 en TTL et réciproquement

Les micro contrôleurs n'utilisent pas de tensions négatives, ils utilisent des tensions de 0V et +5V; Un niveau logique 0 correspond à une tension de 0V et un niveau logique 1 correspond à une tension de +5V.

il faut donc adapter les tensions provenant des appareils car les normes RS232 et RS422 imposent les tensions suivantes :

 

 

Le montage souvent affiché sur Google est faux :

  • Le bon schéma :
  • Seule la partie en jaune nous intéresse pour l' instant.

Premier montage d’ essai :

Comme l' expliquent les schémas plus haut le fil NMEA 0183 - peut être remplacé par la masse(GND) si la liaison est 3 fils et ne provient pas d' un ordinateur ( vraie RS232)

Communication Série de la carte Arduino :

Port Série Serial : 0 (RX) et 1 (TX);

Port Série Serial 1: 19 (RX) et 18 (TX);

Port Série Serial 2: 17 (RX) et 16 (TX);

Port Série Serial 3: 15 (RX) et 14 (TX).

Ils sont utilisés pour recevoir (RX) et transmettre (TX) les données séries de niveau TTL. Les broches 0 (RX) et 1 (TX) sont connectées au circuit intégré ATmega8U2 ,le convertisseur USB-série de la carte.

 

Les broches d'alimentation sont les suivantes :

VIN. La tension d'entrée positive lorsque la carte Arduino est alimentée par une de tension externe . Il est possible d' alimenter la carte à l'aide de cette broche, ou, si l'alimentation se fait par le jack d'alimentation, utiliser cette tension en se raccordant sur cette broche.

5Volts. La tension régulée pour le micro contrôleur et les autres composants de la carte (un régulateur est intégré à la carte Arduino). .

3Volts3. Une alimentation de 3.3Volts pour certains circuits externes nécessitant cette tension à la place du 5Volts. L'intensité maximale disponible est de 50mA

GND. Broche de masse (0 Volt).

 

Le programme pour tester le montage :

// -- programme de test lecture d’ une entrée NMEA 0183
void setup()
{
// Connexion série vers PV
Serial.begin(9600);// 9600 = vitesse
Serial.println(“NMEA Multiplexer…Test Montage”);
// connexion  NMEA .essai avec AIS de la VHF donc 38400
Serial3.begin(38400) ;// 38400 = vitesse
}
void loop()
{char car = 0 ; //variable contenant le caractère a lire
int car_buffer = 0 ; //variable contenant le nb de caractères disponibles dans le buffer
car_buffer = Serial3.available() ;// lecture nb caractères

    // lecture caracteres
while(car_buffer > 0)
{
car = Serial3.read() ; //on lit le caractère
Serial.print(car) ; //envoi vers PC
car_buffer = Serial3.available() ; //lect a nouveau du nombre de caracteres
}

  }

 

Les signaux provenant ou allant à  la VHF sont utilisés ( la VHF est récente et ce sont de vrais signaux 422.

La vitesse d' envoi et réception est exprimée en bauds(bit par seconde)

Plus le câble est court, plus le débit pourra être élevé (moins de chute de tension et de parasites).

Le format des phrases NMEA :

AIS .....

!AIVDM,1,1,,A,14eG;o@034o8sd<L9i:a;WF>062D,0*7D

!AIVDM:        Le message NMEA type
1              Nombre de Sentences
1              Sentence Numéro
               Pour messages multi-sentences)
A              AIS Channel (A or B)
14eG;...   Données AIS
0*            Fin des données
7D             NMEA Checksum

GPS....

$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47

$GPGGA       : Type de trame
064036.289   : Trame envoyée à 06h40m36,289s (heure UTC)
4836.5375,N  : Latitude 48,608958° Nord = 48°36'32.25" Nord
00740.9373,E : Longitude 7,682288° Est = 7°40'56.238" Est
1            : Type de positionnement (le 1 est un positionnement GPS)
04           : Nombre de satellites utilisés pour calculer les coordonnées
3.2          : Précision horizontale ou HDOP (Horizontal dilution of precision)
200.2,M      : Altitude 200,2, en mètres
,,,,,0000    : D'autres informations peuvent être inscrites dans ces champs
*0E          : Somme de contrôle de parité, un simple XOR sur les caractères précédents

 

.

Essai avec les signaux AIS à 38400 bauds .

Téléverser le programme dans l' Arduino et ouvrir le port Com ......Résultat :

Le 75175sn possède 4 entrées) : Essai sur la 2eme entrée avec le GPS à 4800 bauds

:

Remplacer les lignes  du programme :  
// connexion  NMEA .essai avec AIS de la VHF donc 38400
Serial3.begin(38400) ;
Par :
// connexion  NMEA .essai avec le GPS a 4800
Serial3.begin(4800) ;

Ce qui donne :

Il faut maintenant multiplexer les données.

 

 

Réalisation d' un multiplexeur 3 entrées NMEA0183 et 1 sortie USB


Le programme pour le multiplexage :

il existe une librairie NMEA  mais qui ne peut être utilisée , elle est uniquement consacrée au GPS  , j’ ai développé une librairie qui fait l’ acquisition et le contrôle de validité des signaux NMEA provenant de différentes sources ( GPS, AIS , appareils propriétaires ,….):
Copier le contenu de chaque fichier dans un fichier texte  et copier ces fichiers dans un répertoire nommé  ‘NMEA_ACQ' ( 3 fichiers) ou téléchargez NMEA_ACQ

  • Nmea_acq.cpp
  • /*
    nmea_acq.cpp - Acquisition et vérification de validité de phrase NMEA 0183 $ (GPS...) et ! (AIS) pour Arduino
    Copyright (c) 2014 Michel Gravier, France.
    All right reserved.

      This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation;
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

      You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    */
    #include "nmea_acq.h"

     

    #define _LIB_version   1.01       // version de cette librairie

    ACQ::ACQ(int connect)
    {              n = 0;
    _w = 0;
    _checksum = 0;
    }

    int ACQ::lecture(char c)
    {// si LF et  CR : _w=0 ----->case 0
    if ((c == 10) || (c == 13)) { _w = 0; }
    if  (( c == '!') || (c == '$'))
    { _checksum = 0;
    _phrase[0] = c;
    n = 1;
    _w = 1;
    return 0;  //valeur de retour FALSE
    }

    // ajout des caractères pour fabriquer la phrase
    switch(_w)
    {
    case 0:
    // attente des caractères  '!' et '$'
    break;
    case 1:              
    _phrase[n++] = c;
    switch (c)
    {
    case '*':  // si fin de phrase ( avant checksum)
    _w = 2;   // il faut lire le 1er caractère du checksum en case 2
    break;
    default:  // ce n' est pas la fin de la phrase
    _checksum = _checksum ^ c;
    _w = 1;
    break;
    }
    break;
    case 2:
    _phrase[n++] = c; // on lit le 1er caractère du checksum
    _check = (16 * _convert_hex(c));
    _w = 3;   // il faut lire le 2eme caractère du checksum en case 3
    break;
    case 3:              
    _phrase[n++] = c; // lecture 2eme caractere checksum
    _phrase[n++] = 13;// retour chariot
    _phrase[n++] = 10;// retour ligne
    _phrase[n++] = 0;
    _check = _check + _convert_hex(c);
    if (_checksum == _check) {        _w = 0; return 1;}// phrase acceptée , valeur de retour TRUE pour 1
    else return 0; // valeur de retour FALSE pour 0
    default:

    break;
    }
    return 0;
    }

    char* ACQ::phrase() {   // retoune la phrase valide
    return _phrase;
    }

    int ACQ::_convert_hex(char a) {
    // retourne la valeur en base 16 des caractères
    if (int(a) >= 65) { return int(a)-55; }
    else {return int(a)-48;  }
    }

    int ACQ::libversion() {
    // retourne version de la librairie
    return _LIB_version;

    }
  • Nmea_acq.h
  • /*
    nmea_acq.h - Acquisition et verification de validité de phrase NMEA 0183 $ (GPS...) et ! (AIS) pour Arduino
    Copyright (c) 2014 Michel Gravier, France.
    All right reserved.

      This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation;
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

      You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    */
    #ifndef nmea_acq_h
    #define nmea_acq_h

    #include "arduino.h"
    #define               ALL                                                                       0                            
    class ACQ
    {
    public:
    ACQ(int connect);                                                                        
    int                          lecture(char c); // réception des caractères
    char*    phrase();                            // retour de la dernière phrase valide
    char              _phrase[90]; // phrase nmea ( une phrase contient 82 caractères max)
    int                          n;
    int                          _w; // numero du traitement sur le caractere
    int                          _checksum; // somme de controle calculée
    int          _check;// checksum inclus avec la phrase
    int                          _convert_hex(char a); //conversion en base 16
    int     libversion() ;// affichage version
    };

    #endif
  • keywords.txt
  • # Datatypes (KEYWORD1)
    #######################################

    ACQ       KEYWORD1

    #######################################
    # Methods and Functions (KEYWORD2)
    #######################################

    lecture KEYWORD2
    phrase  KEYWORD2

    #######################################
    # Constants (LITERAL1)
    #######################################

    ALL         LITERAL1

Importer la librairie :

 

 

Le CI 75175sn possède 4 entrées mais nous ne pouvons utiliser que 3 entrées de l' Arduino,car les E/S Rx0 et Tx0 ne peuvent être utilisées  , elles sont utilisées par l’ USB reliant le PC

 

l' essai se fera sur 2 entrées mais le programme fera l' acquisition de 3 entrées: rec_gps , rec_ais, rec_nmea1

 

on définit les entrées par leur nom pour une meilleure lisibilité ( #define ………), la partie réception des caractères est légèrement modifiée par rapport au programme précédent car elle utilise la librairie NMEA_ACQ qui en plus de l' acquisition des caractères fera un contrôle de validité des phrases NMEA.

 

// Multiplexeur  AIS + GPS + autres entrees
// utilisation librairie  NMEA_ACQ

#include <nmea_acq.h>//librairie nmea_acq
#define nmea_gps Serial3
#define nmea_ais Serial2
#define nmea_1 Serial1 // autre entree
//Serial  ne peut être utilisé si le PC est connecté
ACQ rec_ais(ALL);// librairie pour AIS
ACQ rec_gps(ALL);
ACQ rec_nmea1(ALL);
;
void setup()
{
// Setup serial connexion vers PC.
Serial.begin(9600);
Serial.println("NMEA Multiplexer... GPS + AIS + Autres");

    // Setup serial connexion NMEA
nmea_gps.begin(4800);
nmea_ais.begin(38400);
nmea_1.begin(4800); // autre entree

}

void loop()
{char car = 0; //variable contenant le caractère à lire GPS

    // il y a un caractere à lire ?
if (nmea_gps.available())
{car = nmea_gps.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence GPS
if (rec_gps.lecture(car)) // identique à : rec_gps.lecture(car)==1 , 1 pour TRUE (vrai)
{// recuperation de la phrase nmea

Serial.print(rec_gps.phrase());
}
}
if (nmea_ais.available())//
{car = nmea_ais.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence AIS
if (rec_ais.lecture(car)) // si la condition est TRUE (vrai) , code retour de la fonction
{// recuperation de la phrase

Serial.print(rec_ais.phrase());
}
}
if (nmea_1.available())//
{car = nmea_1.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence
if (rec_nmea1.lecture(car))
{// recuperation de la phrase

Serial.print(rec_nmea1.phrase());
}
}

}

 

Résultat :

 

Il suffit maintenant , pour remplacer la plaque d' essai , de souder un support pour le CI sur une plaque de circuit imprimé pour gérer les signaux NMEA des différentes entrées afin de les renvoyer dans le format adapté (TTL) sur le contrôleur.

support pour CIsupport

 

+++++++++Essai sous W7 et W8 , effectué avec SEACLEAR ( fermer le logiciel Arduino pour libérer le port com ).

Utiliser le même port qu’ Arduino.

 

 

 

Problème avec XP  , le driver fourni avec l' application ne fonctionne pas correctement (essais avec avec OpenCPN et SeaPro) ; en installant ce driver le fonctionnement est correct avec SeaPro et OpenCPN ( version 3.2 )

Ce montage est un galop d' essai ,……ci dessous ajout d' une sortie Ethernet

 

Réalisation d' un multiplexeur 3 entrées NMEA 0183, 1 sortie USB et 1 sortie Ethernet

 

Nous allons simplement ajouter la communication Ethernet à notre montage .

 

Matériel complémentaire :

- une carte Arduino Ethernet ( elle possède également un lecteur de carte SD):

- il suffit de l' emboîter sur la carte principale :

 

-

On relie avec un cordon Ethernet l'Arduino avec le PC; pour qu' ils puissent communiquer , il doivent être sur le même réseau , nous allons donc attribuer au PC l' adresse 192.168.56.180 ( l'arduino étant sur 192.168.56.177)

 

 

 

On complète le programme précédent :

//  AIS + GPS + autres entrées + Ethernet
// utilisation librairie  NMEA_ACQ

#include <nmea_acq.h>//librairie nmea_acq
#define nmea_gps Serial3
#define nmea_ais Serial2
#define nmea_1 Serial1 // autre entree
//Serial  ne peut être utilisé si le PC est connecté

#include <SPI.h>
#include <Ethernet.h>

  // (ethernet hardware) addresses  de la carte (mac et IP):
byte mac = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
byte ip = { 192, 168, 56, 177 };   
byte subnet = { 255, 255, 255, 0 };

EthernetServer server(80);

ACQ rec_ais(ALL);// librairie pour AIS
ACQ rec_gps(ALL);
ACQ rec_nmea1(ALL);

;
void setup()
{
// initialialise la carte ethernet
Ethernet.begin(mac, ip); // start ethernet using the mac and IP address
server.begin();
// Setup serial connexion vers PC.
Serial.begin(9600);
Serial.println("NMEA Multiplexer... GPS + AIS + Autres");

    // Setup serial connexion NMEA
nmea_gps.begin(4800);
nmea_ais.begin(38400);
nmea_1.begin(4800); // autre entree
delay(1000); // donne a la carte  ethernet une  seconde pour s’ initialiser

 }

void loop()
{
char car = 0; //variable contenant le caractère à lire GPS

    // il y a un caractere à lire ?
if (nmea_gps.available())
{car = nmea_gps.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence GPS
if (rec_gps.lecture(car)==1)// valeur de retour TRUE:1
{// recuperation de la phrase nmea
Serial.print(rec_gps.phrase());

       }

}
if (nmea_ais.available())//
{car = nmea_ais.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence AIS
if (rec_ais.lecture(car)==1)// valeur retour TRUE:1
{// recuperation de la phrase

Serial.print(rec_ais.phrase());

}
}
if (nmea_1.available())//
{car = nmea_1.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence
if (rec_nmea1.lecture(car))
{// recuperation de la phrase

Serial.print(rec_nmea1.phrase());
}
}
EthernetClient client = server.available();
if (client) {
boolean current_line_is_blank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
// if we've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so we can send a reply
if (c == 'n' && current_line_is_blank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
// phrases NMEA à envoyer
client.println(rec_ais.phrase());
client.println(rec_gps.phrase());
break;
}
if (c == ' ') {
// we're starting a new line
current_line_is_blank = true;
} else if (c != ' ') {
// we've gotten a character on the current line
current_line_is_blank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
client.stop();
}

}

 

Résultat sur un navigateur internet : il suffit de taper l' adresse indiquée dans le programme ( byte ip = { 192, 168, 56, 177 };)   

 

Nous voulons maintenant communiquer avec par exemple OpenCPN :

 

Il faut ajouter une bibliothèque qui gère les paquets : EthernetUdp.h ( pour le l’ UDP); elle est comprise dans le programme Arduino , il suffit de la déclarer.
ATTENTION : il est impératif de créer une règle dans le pare feu pour autoriser les communications entrantes ; pour faire des essais on peut aussi désactiver le pare feu.
Un outil peut aider à régler les problèmes d’ ouverture de ports UDP  : UDP Test Tools

 

Le programme est à modifier comme ceci :

//  AIS + GPS + autres entrées + Ethernet +UDP
// utilisation librairie  NMEA_ACQ

#include <nmea_acq.h>//librairie nmea_acq
#define nmea_gps Serial3
#define nmea_ais Serial2
#define nmea_1 Serial1 // autre entree
//Serial  ne peut être utilisé si le PC est connecté
#include <SPI.h>
#include <Ethernet.h>
//------------------------------------------------------
#include <EthernetUdp.h>
// (ethernet hardware) addresses  de la carte (mac et IP):
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
byte ip[] = { 192, 168, 56, 177 }; 
IPAddress broadcastIP(192, 168, 56, 255);
byte subnet[] = { 255, 255, 255, 0 };
unsigned int localPort = 10009;
// ----------------------------------------------------------
EthernetUDP Udp;
//------------------------------------------------------------
ACQ rec_ais(ALL);// librairie pour AIS
ACQ rec_gps(ALL);
ACQ rec_nmea1(ALL);

IPAddress ip_client(192, 168, 56, 180);// adresse du PC ou
// IPAddress ip_client(192, 168, 56,255);// adresse du réseau
unsigned int port_client=10110;// port UDP du PC ( 10110 port par defaut d’OpenCPN)
char* buffer;

void setup()
{
// initialialise la carte ethernet
Ethernet.begin(mac, ip);
Udp.begin(localPort);
// Setup serial connexion vers PC.
Serial.begin(9600);
Serial.println("NMEA Multiplexer... GPS + AIS + Autres");

    // Setup serial connexion NMEA
nmea_gps.begin(4800);
nmea_ais.begin(38400);
nmea_1.begin(4800); // autre entree
//delay(1000); // donne a la carte  ethernet une  seconde pour s’ initialiser
}
void loop()

{
char car = 0; //variable contenant le caractère à lire GPS
// il y a un caractere à lire ?
if (nmea_gps.available())
{car = nmea_gps.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence GPS
if (rec_gps.lecture(car))// valeur de retour TRUE
{// recuperation de la phrase nmea
Serial.print(rec_gps.phrase());
buffer=rec_gps.phrase(); // copy de la phrase nmea dans buffer
envoi_nmea(); // appel de la fonction d’ envoi des paquets


}
}
if (nmea_ais.available())//
{car = nmea_ais.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence AIS
if (rec_ais.lecture(car)==1)// valeur retour TRUE:1
{// recuperation de la phrase
Serial.print(rec_ais.phrase());
buffer=rec_ais.phrase();// copy de la phrase nmea dans buffer
envoi_nmea();// appel de la fonction d’ envoi des paquets

}
}
if (nmea_1.available())//
{car = nmea_1.read(); // lect caractere
// utilisation de la librairie NMEA_ACQ pour lire la sentence
if (rec_nmea1.lecture(car))
{// recuperation de la phrase
Serial.print(rec_nmea1.phrase());
buffer=rec_nmea1.phrase();
envoi_nmea(); // appel de la fonction d’ envoi des paquets   }

}
}
void envoi_nmea() // fonction : envoi des paquets
{
Udp.beginPacket(ip_client, port_client);
Udp.write(buffer);
Udp.endPacket();
//

 

Communication avec OpenCPN établie par le câble Ethernet :

 

L’ adresse ip du PC peut aussi être notée « Localhost » comme le montre l' image ci dessous  ;

 

Le Multiplexeur terminé , avec 2 entrées raccordées :

 

à suivre , ci dessous  : ....................utilisation avec un routeur Wifi.

 

Réalisation d' un multiplexeur NMEA 0183, Wifi (3 entrées , 2 sorties USB et Ethernet)

 

La carte wifi Arduino est chère alors qu’un routeur wifi est bon marché et peut être utilisé aussi en serveur multimédia et serveur de fichier. 

Un routeur TP LINK ref MR3020 coute entre 30 et 40 Euros ; il est compatible d-wrt , une petite merveille.

 

 

Le montage avec la Carte Arduino :

 

Il faut maintenant configurer le routeur , pour cela :

- comme pour les essais avec l' Arduino , le connecter avec le PC en Ethernet ( en ayant modifier l' adresse de la carte Ethernet pour être sur le même réseau que le routeur)

- avec un navigateur internet Taper 192.168.0.254 ( sur certains routeur ce sera 192.168.0.1 , 192.168.1.1 ,... voir les notices constructeurs)

 

- renseigner le login et le mot de passe :

 

Si vous désirez aussi être connecté à internet par la wifi choisir Bridge avec AP sinon AP:

 

dans le cas de Bridge avec AP , choisir le réseau wifi pour l' accès à internet :

;

 

Choisir l' adresse du réseau : 192.168.xxx.254

 

Choisir la plage d' attribution des adresses IP pour le réseau Wifi :

 

D' autres paramètres sont à choisir comme par exemple la sécurité wifi ,.......

 

Il n' y a plus qu à faire un essai :

 

- avec OpenCPN:

Je n' ai pas changé l' adresse , maintenant le PC utilise la carte wifi et pourtant cela fonctionne ,l' important c' est le port UDP car la carte Arduino envoie les données à tous les ordinateurs du réseau si cette option a été choisie : IPAddress ip_client(192, 168, 56,255);// adresse du réseau

J' ai utilisé l' adresse de la carte wifi :

 

En résumé , avec OpenCPN , si on utilise comme adresse localhost les données sont toujours prises en compte; c' est le port UDP qui est important.

 

Visualisation des données du multiplexeur sur l' iPAD

Eh oui ça fonctionne comme sur le sur PC , voici la marche à suivre :

Nous avons l' iPad , iSailor avec des cartes mais sans l' option AIS; Pour l' instant iSailor nous a couté 21,99 Euros , nous allons donc investir en achetant l' option AIS à 8,99 Euros.

 

Le déblocage de cette option s' effectue rapidement sans problème , il faut paramétrer la réception des données:

 

 

Voici les informations concernant Idem:

 

Une application gratuite qui fonctionne aussi très bien : iAIS

pour iOS 4.2 ou supérieur , compatible avec iPhone, iPad, et iPod touch.

 

 

 

CONCLUSION:

Ce montage fonctionne sur PC , sur iPad , il devrait fonctionner sur les tablettes Android , Windows 8.1 et Windows RT8.1.

 

 

crée le 13/07/2014

maj le 25/07/2014 essai iAIS

                                             EQUIPER ET REPARER