[gypsylyon]

Abro este hilo para preguntar si hay muchos usuarios del profundimetro de NASA marine Clipper.
Lo pregunto porque he encontrado la manera de convertir la salida para el repetidor en sentencias nmea183. 

Si hubiera muchos interesados subiría como hacerlo.

[onilum]

Abro este hilo para preguntar si hay muchos usuarios del profundimetro de NASA marine Clipper.
Lo pregunto porque he encontrado la manera de convertir la salida para el repetidor en sentencias nmea183. 

Si hubiera muchos interesados subiría como hacerlo.

Tengo el wind marine cliper inalámbrico (anemómetro, no sonda) No se si podría servirme? 

 De todos modos, tengo pensado cuando pueda ponerme en contacto con Tehani para centralizar todo similar a lo que quiere hacer Josefu, pero antes tengo que ver un poco los equipos que llevo, lo que quiero o lo que puedo hacer, por ahora no tengo claro que opciones tendría. 
 Este invierno seguramente me pueda poner con ello y os pida opinión, por ahora no quiero dar la brasa si no puedo aún invertir en ese asunto. Pero está en la lista. 

 De todas formas si crees que me puede servir y lo compartes genial! 

Saludos

[josefu]

El equipo de viento de nasa me suena que saca nmea directamente.

[gypsylyon]

Si el de viento saca nmea183. 
Pero el de sonda son bytes por i2c para manejar el display del repetidor.

[gypsylyon]

Tengo el wind marine cliper inalámbrico (anemómetro, no sonda) No se si podría servirme? 

 De todos modos, tengo pensado cuando pueda ponerme en contacto con Tehani para centralizar todo similar a lo que quiere hacer Josefu, pero antes tengo que ver un poco los equipos que llevo, lo que quiero o lo que puedo hacer, por ahora no tengo claro que opciones tendría. 
 Este invierno seguramente me pueda poner con ello y os pida opinión, por ahora no quiero dar la brasa si no puedo aún invertir en ese asunto. Pero está en la lista. 

 De todas formas si crees que me puede servir y lo compartes genial! 

Saludos

Yo tengo el mismo . Este no necesita nada ya que da salida en nmea183.  Por lo demas sin problemas, nos dices que electronica tienes en el barco y te orientamos en lo que necesites

[Tehani]

Si el de viento saca nmea183. 
Pero el de sonda son bytes por i2c para manejar el display del repetidor.

No recomiendo usar I2c con cables de más de 0,5 metros aprox. Son señales digitales con impedancia alta (unos 10k). La velocidad estándard es de 400.000 bits por segundo.
Normalmente, estos sensores van en la misma PCB que el microcontrolador, o en una plaquita conectada directamente a la del uC.

[Svenson]

A mi me interesa si es posible hacerlo

[gypsylyon]

No recomiendo usar I2c con cables de más de 0,5 metros aprox. Son señales digitales con impedancia alta (unos 10k). La velocidad estándard es de 400.000 bits por segundo.
Normalmente, estos sensores van en la misma PCB que el microcontrolador, o en una plaquita conectada directamente a la del uC.

Gracias por la recomendacion. En mi caso el sistema estaría a menos de 20 cm.

[gypsylyon]

A mi me interesa si es posible hacerlo

Estoy estudiando si puedo pasar el script en C++ para arduino en Python para la raspberry.  Decesa manera no se necesitaría una placa arduino 1.

[Zamar]

Abro este hilo para preguntar si hay muchos usuarios del profundimetro de NASA marine Clipper.
Lo pregunto porque he encontrado la manera de convertir la salida para el repetidor en sentencias nmea183. 

Si hubiera muchos interesados subiría como hacerlo.

Buenas gypsylyon, tengo esa sonda instalada, la información vendría bien pero no tengo Raspberry, tablet y pc con open... 
Si te interesa un repetidor del nasa también lo tengo, pero falla a veces, se apagan los dígitos no la luz...  lo quité, tu a lo mejor lo puedes hacer revivir, o te sirve de pruebas o donante...no pido nada por el, es más, seria un placer para mí, que te lo quedarás. Mucha información has aportado... Lo tienes en Tenerife.
Instalé un triducer sonda, corredera y temperatura y con las dos sondas encendidas a la vez no hay interferencias en ninguna, están juntas menos de medio metro, la nasa está pegada por dentro del casco con Sika, por si ayuda a alguien la información.
Un saludo.

[Piratacojo]

Abro este hilo para preguntar si hay muchos usuarios del profundimetro de NASA marine Clipper.
Lo pregunto porque he encontrado la manera de convertir la salida para el repetidor en sentencias nmea183. 

Si hubiera muchos interesados subiría como hacerlo.

A mi me interesa.

[gypsylyon]

Aunque no ha habido muchos interesados en el proyecto, pero dos y contando conmigo ya somos multitud.

Despues de las vacaciones he tenido tiempo de montar el conversor de Sonda NASA a nmea183, y funciona.

Aunque en la publicacion original emplean un arduino uno, yo he utilizado un arduino micro y ha funcionado sin problemas.

Aviso que para hacer el montaje se requieren algunas habilidades como soldar. Para los que no programan tambien lo pueden realizar.

Que vams a necesitar:
Aduino micro:
https://store.arduino.cc/products/arduino-micro

DCDC de 12V a 5V para alimentar la placa arduino con el voltaje de la Sonda NASA:
Por ejemplo
https://leantec.es/tienda/mini-dc-dc-de-...able-97-5/

Una pletina perforada para hacer prototipos:
https://www.concashop.com/placa-pcb-perf...y-254.html

Conector DIN de 5 polos:
https://es.rs-online.com/web/p/conectores-din/0491172

Cable USB A a USB miniB:
https://www.kubii.com/es/hub-cables-adap...06882.html

IDE de programacion de Arduino.
https://www.arduino.cc/en/software

Otros materiales y herramientas como soldador, estaño, cables finos y paciencia.

[gypsylyon]

Seguimos.
La sonda NASA es la siguiente:


En la parte de atras tiene un conector para el repetidor:



Aqui und detalle:


La conexion de los pines es la siguiente:


Pin 1: SCL (serial clock)
Pin 2: GND (Masa)
Pin 3: SDA (Serial Data)
Pin 4: 12V
Pin 5: GND



La foto esta tomada de la publicacion alemana del proyecto se puede ver la correspondencia de pines en el macho DIN. Los colores empleados son un ejemplo . Si os fijais hay un fallo, la SCL esta con el pin1 y no el 2 (que esta repetido). Cada uno puede utilizar los colores que quiera. Yo respetaria el positivo rojo y el negativo negro.

Segun comentan en la publicacion, si se tiene conectado un repetidor, la tension no es de 12V si no de 5, ya que el repetidor tiene un conversor de tensiones DCDC.
Como yo no tengo repetidor, la tension es de 12V. Por ello hay que utilizar un conversor DCDC de 12V a 3V  que tenga unos 2 A.

[gypsylyon]

Lo mas sencillo es pasar el programa del ordenador al arduino micro

Para ello os bajais el IDE de Arduino y lo instalais en el ordenador

https://www.arduino.cc/en/software



Cuando abrais el IDE os aparecera una pantalla como esta:





Marcais todo con el raton y lo borrais.

Copiais el programa a continuacion y lo pegais.



Programa o skript:


```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);
  Serial.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)
  {
     
    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)
          {
            Serial.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
        {
          Serial.println("$bad data");
        }
    }
    // Get rid of old data
    for(i=0;i<11;i++)
    {
      data[i] = 0;
    }
    FLAG_NEW_DATA = 0;
  }
 
}



```
   
He editado el script y lo lo he corregido para que no aparezca la pseudo sentencia de NMEA DTA. Esta comprobado y funciona. Solo sale la sentencia DPT

Y os quedara asi:





Ya podeis guardar el proyecto con el nombre que querais en el directorio de vuestra eleccion.







El siguiente paso es elgir el hardwar que vais a utilizar. En este caso Arduino micro.

Click en Tools, luego en boards, luego Aduino AVR Board y finalmente arduino micro

[gypsylyon]

Seguimos.
Conectamos la placa arduino con el ordenador por el cable USB A a USB mini B

A continuacion elejimos el puerto serie en el que aparece la placa arduino.
En mi caso COM 12.


Ya tenemos todo listo para pasar el programa del ordenador a la placa arduino. Para ello solo tenemos que pulsal la flecha arriba a la izquierda que queda debajo de la barra de menu entre Edit y Sketch. Al posicionar el raton encima aparecera la etiqueta "Upload".. Solo teneis que pulsar y el IDE compilara el programa y lo mandara por USB a la placa arduino.


Si esta todo correcto debe de aparecer la siguiente pantalla



Como veis nuestro programa solo ha usado un 27% de la capacidad de la placa arduino.