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.
(24-08-2022, 09:35 AM)gypsylyon escribió: [ -> ]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
El equipo de viento de nasa me suena que saca nmea directamente.
Si el de viento saca nmea183.
Pero el de sonda son bytes por i2c para manejar el display del repetidor.
(24-08-2022, 01:57 PM)onilum escribió: [ -> ]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
(24-08-2022, 02:28 PM)gypsylyon escribió: [ -> ]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.
A mi me interesa si es posible hacerlo
(24-08-2022, 08:49 PM)Tehani escribió: [ -> ]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.
(24-08-2022, 09:53 PM)Svenson escribió: [ -> ]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.
(24-08-2022, 09:35 AM)gypsylyon escribió: [ -> ]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.
Seguimos.
La sonda NASA es la siguiente:
![[Imagen: 450px-NASA-Clipper-Depth-Front.png]](https://i.postimg.cc/HW6hrJ7Y/450px-NASA-Clipper-Depth-Front.png)
En la parte de atras tiene un conector para el repetidor:
![[Imagen: 443px-NASA-Clipper-Depth-BACK.png]](https://i.postimg.cc/rsZn3bL0/443px-NASA-Clipper-Depth-BACK.png)
Aqui und detalle:
![[Imagen: 300px-NASA-Clipper-Depth-connector.png]](https://i.postimg.cc/4dZS9V5d/300px-NASA-Clipper-Depth-connector.png)
La conexion de los pines es la siguiente:
![[Imagen: 300px-NASA-Clipper-Depth-connector-pin-numbers.png]](https://i.postimg.cc/Y0CDX7TB/300px-NASA-Clipper-Depth-connector-pin-numbers.png)
Pin 1: SCL (serial clock)
Pin 2: GND (Masa)
Pin 3: SDA (Serial Data)
Pin 4: 12V
Pin 5: GND
![[Imagen: Plug-connector.png]](https://i.postimg.cc/rs90pXps/Plug-connector.png)
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.
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:
![[Imagen: arduino1.jpg]](https://i.postimg.cc/tg2hJzK5/arduino1.jpg)
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:
![[Imagen: arduino2.jpg]](https://i.postimg.cc/50rLq2NQ/arduino2.jpg)
Ya podeis guardar el proyecto con el nombre que querais en el directorio de vuestra eleccion.
![[Imagen: arduino3.jpg]](https://i.postimg.cc/63qCvvwN/arduino3.jpg)
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
![[Imagen: arduino4.jpg]](https://i.postimg.cc/NFrTNv5J/arduino4.jpg)
Seguimos.
Conectamos la placa arduino con el ordenador por el cable USB A a USB mini B
![[Imagen: 20230904-205236.jpg]](https://i.postimg.cc/J40G8K2Q/20230904-205236.jpg)
A continuacion elejimos el puerto serie en el que aparece la placa arduino.
En mi caso COM 12.
![[Imagen: arduino5.jpg]](https://i.postimg.cc/HsNwQGCR/arduino5.jpg)
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.
![[Imagen: arduino6.jpg]](https://i.postimg.cc/2SB4GHk6/arduino6.jpg)
Si esta todo correcto debe de aparecer la siguiente pantalla
![[Imagen: arduino7.jpg]](https://i.postimg.cc/d1Jrqw8k/arduino7.jpg)
Como veis nuestro programa solo ha usado un 27% de la capacidad de la placa arduino.
