[gypsylyon]

Pasamos al tema del hardware.
Si la arduino la vais a usar con un ordenador o con la RAspberry con OpenCPN, en el fondo no necesita una fuente de alimentacion de 5V ya que esta la toma por la conexion de USB del ordenador o raspi.
En mi caso la he necesitado para conectarla a un Plotter de Garmin por puerto serie.



Aqui podeis ver los pines de la placa arduino. Para este proyecto en el fondo solo necesitamos los pines SCL, SDA y GND. En la foto son los que estan a la izquierda arriba. En la pletina llevan los numeros 3-SCL, 2-SDA y GND. Si contamos los pines desde aariba a la izquierda hacia abjo, estos ocupan los lugares 6°-GND, 7°-SDA y 8°-SCL.
Como hemos visto antes estos pines hay que conectarlos al conector DIN con los pines. Al pin 3 la SDA, al pin 1 la SCL y al pin 5 o el pin 2 la GND. Os recuerdo que en la imagen de un posterior post habia un error y la SCL la habian puesto al pin2 que en realidad es el pin1.

Si utilizais una fuente de 5V el positivo va a la ppin 5V y el negativo al pin GND. Esto estan a la derecha. Contando desde arriba a la derecha la GND es el pin 4°, y la de 5V el pin 6°.
En este caso es mejor utilizar una placa perforada para prototipos, para que quede un conjunto la fuente de 5V con la placa arduino. Para las conexiones he utilizado un contector para soldar a circuitos impresos, aunque tambien se pueden soldar los cables directamente.
Mi montaje tiene este aspecto:






El cable para conectar la placa arduino con la sonda NASA

[gypsylyon]

El ultimo paso

Primero conectamos el conector DIN con el correspondiente de la Sonda NASA cuyos cables deben de esta conectado a la placa arduino. Como he comentado antes si no usais la fuente de 5V , a SDA, SCL y GND.
Encendeis la sonda NASA. Luego conectais la arduino micro con el ordenador. Este lo teniais previamente encendido y con el IDE de Arduino abierto.
Controlais la conexion del puerto COM en el IDE de Arduino.
Si todo esta correcto deben de esta fluyendo datos de profundidad de la placa arduino al ordenador.
Para visualizarlo teneis que activa el serial monitor derl IDE de arduino. Para ello click en Tools y luego en serial monitor


Abajo se abre una ventana donde teneis que ver las sentencias NMEA de profundidad

Si es asi enhorabuena, lo habeis conseguido.
Para visualizar la profundidad en OpenCPN, primero cerrais el IDE de Arduino. Abris OpnCPN. En conexiones abris una nueva conexion serial en el COm donde esta la arduino. En mi caso com12. y 4800baudios.
Lo actualizais. Si abris la ventana de depuracion NMEA debeis ver las sentencias NMEA183 de profundidad.

Si es asi OpenCPN ve los datos. Lo siguiente seria añadir en un dashboard la informacion de priofundidad.


Esta informacion esta disponible en ese puerto tambien para otras aplicaciones.

[Svenson]

Mil gracias por el trabajo. Trataré de montarlo este invierno. Entiendo que las sentencias NMEA 0183 serían convertibles a NMEA 2000 usando cualquier convertidor comercial, no? Así podría visualizarse en ambas redes.

[gypsylyon]

Si supongo.
Creo que tu tienes un ocenav. Yo el mio lo tengo en el barco grande así que no puedo comprobar si ocenav lee las sentencias conectándolo el arduino directamente a un canal de entrada con lis pines serial de arduino.
A través de opencpn seguro que si. Tendrías que hacer una conexión de salida con las sentencias de profundidad. 

Ayer me pasó Tehani bibliotecas de nmea2000 para arduino. Aunque yo no lo necesito en cuanto tenga tiempo libre, miraré de cambiar el script para que de sentencias nmea2000.  Aunque en este caso hay que conectarle a la arduino un chip de canbus.

[Tehani]

Gypsy, DTA no es una sentencia NMEA0183 conocida. De dónde la sacas?

[gypsylyon]

No se te escapa una.
Además tu ya te habrás dado cuenta tu de dónde sale esa DTA. Me parece bien que hayas formulado la pregunta.

La pseudo sentencia DTA, son los datos del i2c que lee arduino antes de convertirlos en sentencia DPT.

Tengo una versión sin ese código pero cuando fui al barco probé la que he subido. L a próxima vez que vaya al barquito compruebo que la versión modificada sigue enviando sentencias DPT. Si es asi subiré el nuevo código.

[gypsylyon]

He comprobado el script sin la pseudosentencia NMEA DTA.
Aqui los pantallazos solo con la sentencia DPT
El primero con el serial monitor de la IDE de arduino:


El segundo de la pantalla de NMEA de OpenCPN. A la izquierda se puede ver uns dashboard con la prfundidad


Tambien he tenido tiempo para testear la salida UART serie de la arduino micro.
La arduino micro tuene dos sistemas de comunicacion serie. Uno es por USB y el otro es por UART. El script que os he puesto funciona con la USB.
Con una modificacion minima se pude hacer que los datos salgan por la UART. Para esta interface serie es necesario conectarle un adaptador TTL a RS232 o RS422 o RS485, ya que la salida de la arduino es de 5V y las RS trabaja a unos 12V.
En otro post ampliare la informacion

[Tehani]

Parece ser que DPT se envía unas 2,3 - 2,4 veces por segundo. Entra en lo correcto para NMEA0183.

[gypsylyon]

Parece ser que DPT se envía unas 2,3 - 2,4 veces por segundo. Entra en lo correcto para NMEA0183.

Si, yo también pienso que son demasiadas sentencias por segundo. Mirare de mandar solo 1 por segundo.Hoy hecho el test por uart y es más lento.

[Tehani]

Si supongo.
Creo que tu tienes un ocenav. Yo el mio lo tengo en el barco grande así que no puedo comprobar si ocenav lee las sentencias conectándolo el arduino directamente a un canal de entrada con lis pines serial de arduino.
A través de opencpn seguro que si. Tendrías que hacer una conexión de salida con las sentencias de profundidad. 

Ayer me pasó Tehani bibliotecas de nmea2000 para arduino. Aunque yo no lo necesito en cuanto tenga tiempo libre, miraré de cambiar el script para que de sentencias nmea2000.  Aunque en este caso hay que conectarle a la arduino un chip de canbus.

La salida digital del arduíno se puede conectar directamente a un Ocenav (sin conversores) de la siguiente manera:
Para el ATM105:
Salida Arduino --> IN (-) Ocenav.
5v Arduíno -> IN (+) Ocenav.
Para el REM072F:
Salida Arduíno -> IN (+) Ocenav.
IN (-) Ocenav SIN CONECTAR.

[gypsylyon]

Porque utilizar el puerto serie UART en lugar del USB. Si queremos mandar los datos a otros dispositivos con un Plotter o un gattway (por ejemplo Ocenav) o un conversor de NMEA183 a NMEA2000 o SeaTalk, necesitaremos conectarlos por RS232 o RS422 o RS485.
Mi motivacion era que lo necesito para que el Plotter GPSmap 620 de Garmin me lea las sentencias tambien de profundidad de la sonda NASA.
El problema es que el puerto UART de la arduino micro tiene una salida de solo 5 Voltios, asi que si lo conectamos directamente lo mas probable es que no pueda leer las sentencias el dispositivo conectado. Asi que necesitamos un conversor TTL a RS232 o RS422 o RS485.
Por ejemplo
https://www.turibot.es/conversor-rs232-a-ttl





https://www.turibot.es/coversor-rs485-a-ttl


En esta pagina web esta muy bien explicado como conectar el conversor TTL RS485 con arduino
https://www.luisllamas.es/arduino-rs485-max485/

Las conexiones con el conversor RS232 son muy sencillas:




Se conecta el pin Tx de arduino (el tercero empezando arriba a la izquierda) con el pin TX del conversor. El pin RX de ardiono (el cuarto empezando por arriba a la izquierda). El GND (el sexto empezando arriba a la izquierda) con el GND del conversor. Y el VCC del conversor con los 5V.

Al script hay que hacerle una modificacion minima. Solo cambiar serial por serial1 y ya esta. De todas maneras os pongo el scrip que he modificado y que funciona.


```cpp
/*

    NASAClipper_I2C_to_NMEA v0.5
    Decode the NASA Clipper Data into a NMEA compatible serial string
   
   
    written by Peter Holtermann
    with additions from Victor Klein

   
 
    This software is distributed under the GPL v3.0 License
   
   
    At the back of your NASA Clipper should be a round connector
    with 5 pins, looking roughly like this ASCII art:
      Pin Location          Pin Number
          |                    2
      \      /              4    5
    -          -          1        3
         
          O                    6
         
  Pin 1: SCL
  Pin 2: GND
  Pin 3: SDA
  Pin 4: 12V
  Pin 5: GND

  For Detail refer also to:
 
  http://wiki.open  seamap.org/wiki/De:NASA_Clipper_Range
 
  If you connect SCL, SDA and GND with your arduino
  and upload this sketch you should get the depth
  information as serial data.

*/


#include <Wire.h>
const int ledPin =  13;      // the number of the LED pin

void setup()
{
  pinMode(ledPin, OUTPUT);
  Wire.begin(0x3e);
  Serial1.begin(4800);
  Wire.onReceive(&myHandler);
  Serial1.println("$HELLO SKIPPER! THIS IS NASACLIPPER I2C to NMEA v0.5!\n");
}

static bool FLAG_LED_ON = LOW;
static byte I2C_nrec;
char data_handler[11];
char data[11];
static byte FLAG_NEW_DATA = 0;
static bool FLAG_VALID_DATA = LOW;
static bool FLAG_DEPTH = LOW;
void myHandler(int numBytes)
{
  byte i=0;
  for(i=0;i<numBytes;i++)
  {
    data_handler[i] = Wire.read();
  }
  I2C_nrec = numBytes;
  FLAG_NEW_DATA = 1;
}


// The NASA Clipper sends a 12 byte I2C data packet, this data is directly send to a pcf8566p
// LCD Driver. The first byte is the address and the write direction, the next eleven bytes is data.
// The first 5 bytes is a command, the proceeding 6 bytes are data
// positions and contain the single LCD elements.
// Example data {0x7c,0xce,0x80,0xe0,0xf8,0x70,0x00,0x00,0x00,0x00,0x00,0x00};
//              addr  0    1    2    3    4    5    6    7    8    9    10
//                      com  com  com com  com dta  dta  dta  dta  dta  dta
// Example depth  : 23.3
// Digit number  : 12.3


char I2C_predata[5] =  {0xce,0x80,0xe0,0xf8,0x70};
char depth_mask[6] =    {0x01,0,0,0,0,0};
char decpoint_mask[6] = {0,0,0,0x80,0x0,0x0};
char metres_mask[6] =  {0,0,0,0x40,0x0,0x0};
char digit3_mask[6] =  {0,0xbf,0,0,0,0};
char digit3[10][6] = {                  // from https://en.wikipedia.org/wiki/Seven-segment_display
                  { 0, 0xbb,0,0,0,0  }, // zero, a,b,c,d,e,f,/g
                  { 0, 0x11, 0,0,0,0 }, // one /a,b,c,/d,/e,/f,/g
                  { 0, 0x9e, 0,0,0,0 }, // two a,b,/c,d,e,/f,g
                  { 0, 0x97, 0,0,0,0 }, // three a,b,c,d,/e,/f,g
                  { 0, 0x35, 0,0,0,0 }, // four /a,b,c,/d,/e,f,g
                  { 0, 0xa7, 0,0,0,0 }, // five a,/b,c,d,/e,f,g
                  { 0, 0xaf, 0,0,0,0 }, // six a,/b,c,d,e,f,g
                  { 0, 0x91, 0,0,0,0 }, // seven a,b,c,/d,/e,/f,/g
                  { 0, 0xbf, 0,0,0,0 }, // eight a,b,c,d,e,f,g
                  { 0, 0xb7, 0,0,0,0 }, // nine a,b,c,d,/e,f,g
                };
               
char digit2_mask[6] = {0xfe,0,0,0,0,0};
char digit2[10][6] = {                  // from https://en.wikipedia.org/wiki/Seven-segment_display
                  { 0xee, 0, 0,0,0,0  },// zero, a,b,c,d,e,f,/g
                  { 0x44, 0, 0,0,0,0 }, // one /a,b,c,/d,/e,/f,/g
                  { 0xb6, 0, 0,0,0,0 }, // two a,b,/c,d,e,/f,g
                  { 0xd6, 0, 0,0,0,0 }, // three a,b,c,d,/e,/f,g
                  { 0x5c, 0, 0,0,0,0 }, // four /a,b,c,/d,/e,f,g
                  { 0xda, 0, 0,0,0,0 }, // five a,/b,c,d,/e,f,g
                  { 0xfa, 0, 0,0,0,0 }, // six a,/b,c,d,e,f,g
                  { 0x46, 0, 0,0,0,0 }, // seven a,b,c,/d,/e,/f,/g
                  { 0xfe, 0, 0,0,0,0 }, // eight a,b,c,d,e,f,g
                  { 0xde, 0, 0,0,0,0 }, // nine a,b,c,d,/e,f,g
                };
               

char digit1_mask[6] = {0,0,0,0,0x2f,0xc0};
char digit1[10][6] = {                      // from https://en.wikipedia.org/wiki/Seven-segment_display
                  { 0, 0, 0,0,0x2e,0xc0 }, // zero, a,b,c,d,e,f,/g
                  { 0, 0, 0,0,0x04,0x40 }, // one /a,b,c,/d,/e,/f,/g
                  { 0, 0, 0,0,0x27,0x80 }, // two a,b,/c,d,e,/f,g
                  { 0, 0, 0,0,0x25,0xC0 }, // three a,b,c,d,/e,/f,g
                  { 0, 0, 0,0,0x0d,0x40 }, // four /a,b,c,/d,/e,f,g
                  { 0, 0, 0,0,0x29,0xC0 }, // five a,/b,c,d,/e,f,g
                  { 0, 0, 0,0,0x2b,0xC0 }, // six a,/b,c,d,e,f,g
                  { 0, 0, 0,0,0x24,0x40 }, // seven a,b,c,/d,/e,/f,/g
                  { 0, 0, 0,0,0x2f,0xc0 }, // eight a,b,c,d,e,f,g
                  { 0, 0, 0,0,0x2d,0xc0 }, // nine a,b,c,d,/e,f,g
                };




void loop()
{
  byte i,j;
  byte digit_tmp0,digit_tmp1,dig1,dig2,dig3,dec_point,checksum;
  char dptstr[5],NMEADPTstr[20],cksstr[3],ind_dptstr;
  static char incomingByte,command[60], DEBUG_MODE=0;

  if(FLAG_NEW_DATA)
  {
    // DEBUG, stuff:
    //Serial.print("Got ");
    //Serial.print(I2C_nrec,DEC);
    //Serial.print(" bytes.\n");
    /*
      for(i=0;i<I2C_nrec;i++)
      {
      Serial.print(data_handler[i] & 0xFF, HEX);
      Serial.write('_');
      }
      Serial.print("\n");
    */
   
    // RAW I2C Data as a NMEA string.
    //Serial.print("$IIDTA");
    /*for(i=0;i<I2C_nrec;i++)
    {
      Serial.print(",");
      Serial.print(data_handler[i] & 0xFF, DEC);
    }
    Serial.print("*\n");
    */
   
    ind_dptstr = 0;
   
    // Copy the rawdata
    for(j=0;j<11;j++)
      {
        data[j] = data_handler[j];
        data_handler[j] = 0;
      }
    // Check if the first 5 byte (the command) are correct
    // They seem to stay always the same
    for(i=0;i<5;i++)
    {
      dptstr[i] = 0;
     
      if( (data[i] & 0xFF ) == (I2C_predata[i] & 0xFF) )
      {
        FLAG_VALID_DATA = HIGH;
      }
      else
      {
        FLAG_VALID_DATA = LOW;
        break;
      }
    }
    if((FLAG_VALID_DATA) & (I2C_nrec == 11))
    {
      // Decode the digits
      dig1 = 'N';
      dig2 = 'N';
      dig3 = 'N';
      dec_point = 'N';
 
      // DIGIT 3
      digit_tmp0 = data[6] & digit3_mask[1];
      for(i=0;i<10;i++)
      {
        if((digit3[i][1] & 0xFF) == (digit_tmp0 & 0xFF))
        {
          dig3 = '0' + i;
          break;
        }
      }
      // decimal point
      if((data[8] & decpoint_mask[3] & 0xFF) == (0x80))
      {
        dec_point = '.';
      }
     
      // We only consider data good, when the "DEPTH" symbol appears on the LCD
      if((data[5] & depth_mask[0] & 0xFF) == (0x01))
      {
        FLAG_DEPTH = HIGH;
      }
      else
      {
        FLAG_DEPTH = LOW;
      }
     
     
      // DIGIT 2
      digit_tmp0 = data[5] & digit2_mask[0];
      for(i=0;i<10;i++)
      {
        if((digit2[i][0] & 0xFF) == (digit_tmp0 & 0xFF))
        {       
          dig2 = '0' + i;
          break;
        }
      }
      // DIGIT 1
      digit_tmp0 = data[9] & digit1_mask[4];
      digit_tmp1 = data[10] & digit1_mask[5];
      for(i=0;i<10;i++)
      {
        if(((digit1[i][4] & 0xFF) == (digit_tmp0 & 0xFF)) &
        ( (digit1[i][5] & 0xFF) == (digit_tmp1 & 0xFF)  ))
        {
          dig1 = '0' + i;
          break;
        }
      }
     
      i = 0;
      // Do we have good data? (FLAG_DEPTH and at least one digit
      if(((dig1 != 'N') | (dig2 != 'N') | (dig3 != 'N')) & (FLAG_DEPTH == HIGH))
        {
          ind_dptstr = 0;
          if(dig1 != 'N')
          {
            dptstr[ind_dptstr] = dig1;
            ind_dptstr ++;
          }
          if(dig2 != 'N')
          {
            dptstr[ind_dptstr] = dig2;
            ind_dptstr ++;
          }
          if(dec_point != 'N')
          {
            dptstr[ind_dptstr] = dec_point;
            ind_dptstr ++;
          }
          if(dig3 != 'N')
          {
            dptstr[ind_dptstr] = dig3;
            ind_dptstr ++;
          }
          dptstr[ind_dptstr] = '\0';
          strcpy(NMEADPTstr,"$IIDPT,");
          strcat(NMEADPTstr,dptstr);
          strcat(NMEADPTstr,",0.0*");
          // Calculate Checksum
          checksum = 0;
          i=0;

        while(1)
          {
            i++;
            if(NMEADPTstr[i] == '*')
              break;
            checksum = checksum ^ NMEADPTstr[i];
          }
         
          sprintf(cksstr,"%X",checksum & 0xFF);
          strcat(NMEADPTstr,cksstr);
          strcat(NMEADPTstr,"\r\n");
          if(FLAG_DEPTH == HIGH)
          {
            Serial1.print(NMEADPTstr);
          }
          // Toggle the LED
          if( FLAG_LED_ON == HIGH) {
            FLAG_LED_ON = LOW;
            digitalWrite(ledPin, LOW);
            }
          else {
            FLAG_LED_ON = HIGH;
            digitalWrite(ledPin, HIGH);
            }
        }
      else
        {
          Serial1.println("$bad data");
        }
    }
    // Get rid of old data
    for(i=0;i<11;i++)
    {
      data[i] = 0;
    }
    FLAG_NEW_DATA = 0;
  }
 
}



```

Este es mi montaje. He utilizado un conversor TTL a RS232 que tenia en un cajon. Lo he probado con el plotter Garmin GPSmap 620 y ha funcionado correctamente. Asi que pienso que fincionarà tambien con otros dispositivos. No olvideis que va a 4800 baudios.







Ya solo  queda montarlo en una caja e instalarlo en el barquito

Finalmente solo añadir la coletilla de que yo no me hago responsable de los problemas o daños que puedan tener el que se decida a hacerlo. Esto es una solucion a una mejora que yo queria hacer y que comparto en este foro. Por supuesto que asesorare a aquel que lo necesite, como tambien acepto criticas constructivas  y mejoras

[gypsylyon]

La salida digital del arduíno se puede conectar directamente a un Ocenav (sin conversores) de la siguiente manera:
Para el ATM105:
Salida Arduino --> IN (-) Ocenav.
Masa Arduíno -> IN (+) Ocenav.
Para el REM072F:
Salida Arduíno -> IN (+) Ocenav.
IN (-) Ocenav SIN CONECTAR.

Pero que salidas? Las de UART o sea las RT y TX?

[Tehani]

Pero que salidas? Las de UART o sea las RT y TX?

Sí, directamente la salida TX del arduíno.

[Tehani]

La salida digital del arduíno se puede conectar directamente a un Ocenav (sin conversores) de la siguiente manera:
Para el ATM105:
Salida Arduino --> IN (-) Ocenav.
5v Arduíno -> IN (+) Ocenav.
Para el REM072F:
Salida Arduíno -> IN (+) Ocenav.
IN (-) Ocenav SIN CONECTAR.

Corregido este mensaje. Son 5v en lugar de masa.

[gypsylyon]

Sí, directamente la salida TX del arduíno.

Pues esto es fantastico.  Se simplifica todo el montaje para los que tengan una central de Ocenav o el mando remoto tuyo el REM.
Si aumenta la aficion al arduino habra que habrir una seccion que se llame Arduino.
Se que jiauka es un experto en arduino. Igual puede exponer alguno de sus proyectos.