Serial1.write() - pointer

[Christian B. (christian_b606)]

Hallo zusammen,

ich stehe gerade auf dem Schlauch und verstehe es nicht...


Ich möchte mit meinem Particle Electron ein GPS-Modul (SkyTraq Venus 6) 
ansteuern.



Folgendes konfiguriert den Venus 6 und liefert mir nen ACK und die 
richtige Message.

uint8_t queryA[] = {160, 161, 0, 2, 9, 2, 11, 13, 10};//binary mode
uint8_t queryB[] = {160, 161, 0, 2, 2, 1, 3, 13, 10}; //software query

void setup() {
  Serial.begin(9600);
  Serial1.begin(9600);

  delay(500);
  Serial1.write(queryA, sizeof(queryA));
  Serial1.flush();
}

void loop() {

  if (Serial1.available() > 0){
    char c = Serial1.read();
    Serial.print(c, HEX);
  } else {
    Serial.println("-------------");
    Serial1.write(queryB, sizeof(queryB));
    Serial1.flush();
    Serial.println("-------------");
    delay(50);
  }

};

Führe ich die commands jedoch über meine Klasse aus, erhalte ich vom 
receiver nur Müll. Der unterschied ist nur, dass ich in Serial1.write() 
einen uint8_t array pointer (msg_ptr) stecke.

#include "Particle.h"
#include "Serial2/Serial2.h"
#include "webservice.h"
#include "gps.h"

using gps::Gps;

SYSTEM_MODE(MANUAL);
SYSTEM_THREAD(ENABLED);
SerialLogHandler logHandler;

WebService projectWebService(20, 8080, "xxxxxx.xxx");
Gps projectGps(&Serial1);


void gpsCallback(uint8_t message, size_t logID) {
  String _message = (char*)message;
  projectWebService.put(&_message, logID);
};

void setup() {
  Serial.begin(9600);
  delay(500);

  projectGps.defaultMessageCallback(gpsCallback);
  projectGps.Connect(9600);
  projectGps.SetOutputFormatToBinary();
}

void loop() {

  projectGps.QuerySoftwareVersion();
  projectGps.ReadSerialPort();
   
}

gps.cpp (Die wichtigstens Teile vom Code)

#include "gps.h"

using namespace gps;

Gps::Gps(USARTSerial* serial) {
  _gpsSerial = serial;
  _is_connected = false;
  _reading_status = false;
};

bool Gps::Connect(uint8_t baudrate) {
  //Log.info("Connect");
  //_gpsSerial->begin(baudrate);
  Serial1.begin(baudrate);
  _is_connected = true;
  return true;
};

void Gps::defaultMessageCallback(void (*messageCallback)(uint8_t message, size_t logID))
{
  _messageCallback = messageCallback;
};

void Gps::StopReading() {
  Log.info("StopReading");
  _reading_status = false;
};

void Gps::ReadSerialPort() {
  Log.info("ReadSerialPort");
  _reading_status = true;

  uint8_t buffer[MAX_NOUT_SIZE];
  size_t len = 0;
  char incomingByte = 0;

  while (Serial1.available() && _reading_status) {
    //incomingByte = _gpsSerial->read();
    incomingByte = Serial1.read();
    buffer[len] = incomingByte;
    len++;

    if (len == MAX_NOUT_SIZE)
      break;
  }

  if (len > 0) {
    _BufferIncomingData(buffer, len);
  }
  else {
    Log.info("no data");
  };

  Serial.println("-----");
  return;
};

bool Gps::_SendMessage(uint8_t *msg_ptr, size_t length) {
  Log.info("_SendMessage");

  /*for (unsigned int i = 0; i < length; i++) {
    Serial.print(msg_ptr[i], HEX);
    Serial.print("-");
  };*/

  size_t bytes_written;

  //bytes_written=_gpsSerial->write(msg_ptr, length);
  bytes_written=Serial1.write(msg_ptr, length);
  //_gpsSerial->flush();
  Serial1.flush();
  //delay(50);
  // check that full message was sent to serial port
  if (bytes_written != length) {
      Log.error("Full message was not sent over serial port.");
      return false;
  }
  return true;
};

bool Gps::_ConfigureOutputFormat(OutputType output_type) {
  Log.info("_ConfigureOutputFormat");
  bool send_result;

  gps::ConfigureOutputFormat message;
  message.header.sync1 = SKYTRAQ_SYNC_BYTE_1;
  message.header.sync2 = SKYTRAQ_SYNC_BYTE_2;
  message.header.first_payload_byte = FIRST_PAYLOAD_BYTE;
  message.header.payload_length = CONFIGURE_OUTPUT_FORMAT_PAYLOAD_LENGTH;
  message.message_id = CFG_OUTPUT_FORMAT;
  message.type = output_type;
  message.footer.end1 = SKYTRAQ_END_BYTE_1;
  message.footer.end2 = SKYTRAQ_END_BYTE_2;

  //unsigned char* msg_ptr = (unsigned char*)&message;
  //_calculateCheckSum(msg_ptr+HEADER_LENGTH, CONFIGURE_OUTPUT_FORMAT_PAYLOAD_LENGTH,
  //                  &message.footer.checksum);
  uint8_t msg_ptr[] = {160, 161, 0, 2, 9, 2, 11, 13, 10};
  send_result = _SendMessage(msg_ptr,HEADER_LENGTH+CONFIGURE_OUTPUT_FORMAT_PAYLOAD_LENGTH+FOOTER_LENGTH);
  return send_result;
};

bool Gps::SetOutputFormatToBinary() {
  Log.info("SetOutputFormatToBinary");

  bool send_result;
  send_result = _ConfigureOutputFormat(BINARY_OUTPUT);
  return send_result;
};

bool Gps::QuerySoftwareVersion() {
    bool send_result;

  gps::QuerySoftwareVersion message;
  message.header.sync1 = SKYTRAQ_SYNC_BYTE_1;
  message.header.sync2 = SKYTRAQ_SYNC_BYTE_2;
  message.header.first_payload_byte = FIRST_PAYLOAD_BYTE;
  message.header.payload_length = QUERY_SOFTWARE_VERSION_PAYLOAD_LENGTH;
  message.message_id = QUERY_SOFTWARE_VERSION;
  message.software_type = SYSTEM_CODE;
  message.footer.end1 = SKYTRAQ_END_BYTE_1;
  message.footer.end2 = SKYTRAQ_END_BYTE_2;

  uint8_t msg_ptr[] = {160, 161, 0, 2, 2, 1, 3, 13, 10};
  //unsigned char* msg_ptr = (unsigned char*)&message;
  //_calculateCheckSum(msg_ptr+HEADER_LENGTH, QUERY_SOFTWARE_VERSION_PAYLOAD_LENGTH,
  //                  &message.footer.checksum);

  send_result = _SendMessage(msg_ptr,HEADER_LENGTH+QUERY_SOFTWARE_VERSION_PAYLOAD_LENGTH+FOOTER_LENGTH);
  return send_result;
};

Was mache ich falsch?

danke
chris

[Rufus Τ. F. (rufus)]

Christian B. schrieb:
> uint8_t msg_ptr[] = {160, 161, 0, 2, 9, 2, 11, 13, 10};
>   send_result =
> _SendMessage(msg_ptr,HEADER_LENGTH+CONFIGURE_OUTPUT_FORMAT_PAYLOAD_LENGT 
H+FOOTER_LENGTH);


Deine "Längenberechnung" ist hier fragwürdig. Denn die von Dir weiter 
oben ausgefüllte "message"-Struktur verwendest Du überhaupt nicht, 
sondern das gleiche Array wie in Deinem Beispiel weiter oben, nämlich 
das unsinnigerweise "msg_ptr" genannte Array. Und wenn Du das der 
Sendefunktion übergibst, ist die Länge die Größe des Arrays und nicht 
irgendeine Addition irgendwelcher Konstanten.

Allerdings bist Du dann natürlich auch keinen Schritt weiter, denn das 
ganze Gehampel mit der "message"-Struktur ist dann komplett sinnlos.

[Christian B. (christian_b606)]

Danke für deine Antwort.

Das "msg_ptr" genannte Array habe ich nur zum testen und zur 
Verdeutlichung zugefügt. Standard soll und wird die Message verwendet. 
Die übergebene Länge ist 9, wie die Länge des Arrays.
Auch wenn ich die 9 übergebe, funktioniert der Code nicht.


Danke
Christian

[Rufus Τ. F. (rufus)]

Christian B. schrieb:
> Standard soll und wird die Message verwendet.

Das machst Du aber in Deinem Code nicht.

[Christian B. (christian_b606)]

Unabhängig welches der beiden Arrays ich in die Methode _sendMessage und 
dann in Serial1.write stecke, es funktioniert nicht.
Die 9 Bytes werden zwar geschrieben,
 zumindest liefert mir write die gleiche Länge ==9 zurück, aber der GPS 
receiver reagiert nicht darauf.
Im ersten Beispiel jedoch schon! Nur, dass hier kein Pointer vorliegt.

Ebenso wenn ich die Message in ein uint_8 Array caste
uint_8* msg_ptr = (uint_8*)&message. ->keine Reaktion.
Auf unsigned char* msg_ptr = (unsigned char*)&message;  reagiert er 
ebenfalls nicht.

Und wie geschrieben, das array msg_ptr dient zur Veranschaulichung und 
ist identisch mit dem, welches in dem ersten Beispiel funktioniert. 
Daher habe ich es hierfür eingefügt. Daher kann man gleich Mal einen 
Fehler im struct Ausgrenzen.

Danke
Chris

[Bert3 (Gast)]

Log doch mal die serielle Kommunikation bei dem laufenden Beispiel und 
deinem Code

oder z.B. mit Nullmodem-Kabel + 2xRS232(PCI oder FTDI) und Hercules 
(http://www.hw-group.com/products/hercules/index_de.html) die 
Kommunikation auf einen anderen Comport leiten

[Bert3 (Gast)]

oder ein Logger wie: 
https://www.eltima.com/products/serial-port-monitor/

[Heiko G. (heikog)]

Christian B. schrieb:

> projectGps.Connect(9600);

.
.
.

> bool Gps::Connect(uint8_t baudrate) {
>   //Log.info("Connect");
>   //_gpsSerial->begin(baudrate);
>   Serial1.begin(baudrate);
>   _is_connected = true;
>   return true;
> };

Für eine Baudrate von 9600 ist ein uint8_t ein bisschen zu klein :)

[Dirk B. (dirkb2)]

Wie ist denn die Definition von gps::ConfigureOutputFormat ?

[Christian B. (christian_b606)]

Omg. Dankeschön. Ich Honck.... 9600 passt doch nicht in uint_8...

Der Hinweis mit einem logger ist auch super. Dies werde ich machen. 
Somit komme ich zukünftig hoffentlich gleich auf das Problem. Denn 
Debuggen geht leider nicht  wirklich mit dem electron, soweit ich 
gelesen habe.

Melde mich wenn ich zuhause bin und es testen kann.


Danke
Chris

[Dirk B. (dirkb2)]

Christian B. schrieb:
> Ich Honck.... 9600 passt doch nicht in uint_8...

Dagegen hat der Compiler Warnungen, die man evtl. aktiviern, aber in 
jedem Fall beachten muss.

[Christian B. (christian_b606)]

Herzlichen Dank!!
Nun läuft der Code problemlos. :9
Es lag "nur" an dem falschen / zu kleinen Datentyp uint8_t

Danke für den Hinweis mit der compiler warnung, Dirk. Hier muss ich mich 
noch einlesen, da der Code aktuell noch in der particle cloud compiliert 
wird.
IDE verwende ich die Particle IDE (offline) mit PlatformIO.


vg
chris