Übertragungs Probleme

International Deutsch
1

Hallo liebe Community,

Dies ist mein erster Post hier verzeiht mir bitte also kleiner Fehler / mein Unwissen.
Ich bin ebenfalls noch sehr neu im gesamten Microcontroller Programmierung Bereich und habe algemein wenig Ahnung von Arduino . :disappointed_relieved:

Ich arbeite Momentan an einer Platine welche mit einem Microcontroller SAMD21G18A bestückt ist welchen ich per Arduino programmiere.
Das ganze Projekt basiert auf diesem Grundlagen Projekt (GitHub - danielknox/lorawan_network_tester: A network tester for lorawan networks. Released under GPLv3).

Mein Problem ist nun jedoch das mein Chip scheinbar nur noch wirre Buchstaben und Zeichen Kombinationen ausspuckt. Nach etwas Research bin ich auf ein ähnliches Problem gestoßen welches anscheinend mit der Baut rate des Seriellen Monitors zusammenhing, jedoch habe ich bei mir die im Projekt angegebene Baut rate von 115200 ausgewählt und bekomme immer noch nur "Mist" zurück.

Hier ein Ausschnitt meines Seriellen Monitors:

USB MODE
Folgende Kommandos zum Konfigurieren sind möglich:
!AT+CFGOTAA [appEui] [appKey]             //Übergabe von angegebenen Daten
!AT+CFGABP [devAddr] [NwksKey] [AppsKey]  //Übergabe von angegebenen Daten
!AT+HWEUI?                                //Gibt die HardwareEui des Gerätes aus
!AT+EXIT                                  //Beendet die Seriele Verbindung
OK
Dev EUI: invalid_param

#~=⸮r⸮ /0N;⸮X 4invalid_param
⸮h(Sending:   H⸮⸮ invalid_param
⸮p⸮invalid_param
Sending:   B"tct"vcv-⸮Ѡ⸮+ off
⸮p⸮invalid_param
Sending:   H⸮⸮ invalid_param
⸮p⸮invalid_param
Sending:   ⸮⸮⸮#⸮     Key1
⸮p⸮invalid_param
Sending:   ⸮Eљ!)H⸮⸮ Key2
⸮p⸮invalid_param
Sending:  #[ 
⸮p⸮invalid_param
OK

Die hierbei verwendete Funktion !AT+CFGOTAA [appEui] [appKey] hat auf einem vorherigen Build bereits Funktioniert.

Erkennt jemand dieses Problem und kann mir noch einen Tipp geben wo ich suchen kann?
Oder kann ich noch Informationen beisteuern welche die Fehlersuche erleichtern?

Im hoffen auf rückmeldung,
Qwyxc

2

Moin,
Dein link ist kaputt.
richtig: GitHub - danielknox/lorawan_network_tester: A network tester for lorawan networks. Released under GPLv3

qwyxc:
Nach etwas Research bin ich auf ein ähnliches Problem gestoßen welches anscheinend mit der Baut rate des Seriellen Monitors zusammenhing,

Gibt es dazu irgendwas, was man ggfls. nachlesen kann?
Ansonsten wäre evtl. das runterbrechen des Codes auf ein Minimum und dann hier einstellen mit allem was rundrum so verwendet wird nen Ansatz...

3

Hallo,

ich würde dennoch erst mal ein paar andere Boudraten versuchen. ich denke das liegt daran. Die anderen Parameter stimmen , 7,8 bit parity....

hat das Ding eine TTY schnittstelle oder geht es um 232, da gab´s schon mal was mit invertietern Pegeln

Heinz

4

Meine Güte,

da hast du dir aber ein fettes Projekt zum Einsteigen ausgesucht.

Die (wie immer) spärliche Dokumentation auf GitHUB beschreibt was auf dem Grafik-Display zu sehen ist.
Du schreibst etwas von seriellem Monitor.

im code steht baudrate 115200. Damit müsste es dann etwas vernüftiges anzeigen.
Wenn es bei 115200 baud nichts venrünftiges ausgibt dann könnte es in der Tat an invertierten Pegeln liegen

Andererseits ist ein Teil der Zeichen ja lesbar. Das ist schon merkwürdig.

Bekommst du denn eine vernünftige serielle Ausgabe wenn du ein gaaanz simples ich sende Dir Zeichen und du sendest mir das Zeichen zurück laufen lässt?

vgs

5

Da ein großer Teil des Textes korrekt und lesbar ist, scheidet eine falsche Baudrate aus. Wenn die Baudrate nicht stimmt, kommt kein Zeichen korrekt an. Ich könnte mir da ein Problem mit dem Zeichensatz vorstellen. Zb.gesendet wird UTF8, der Empfänger versteht aber nur standard ASCII.

6

Hey danke für eure vielen Antworten!

Und sorry das ich mich erst jetzt wieder melde, hab momentan noch viel mit der Schule selbst zu tun (Techniker Weiterbildung) und daher zumeist nur am We oder an Dienstagen zeit für mein Projekt.

Danke my_xy_projekt für den Richtigen link! Der Eintrag war glaube ich hier aus dem English sprachigem Bereich des Forums hat mir jedoch nicht so wirklich weitergeholfen und wie ja jetzt auch schon angemerkt wurde wäre dann wohl die gesamte Übertragung falsch.

Rentner:
Hallo,

ich würde dennoch erst mal ein paar andere Boudraten versuchen. ich denke das liegt daran. Die anderen Parameter stimmen , 7,8 bit parity....

hat das Ding eine TTY schnittstelle oder geht es um 232, da gab´s schon mal was mit invertietern Pegeln

Heinz

Also ich habe mal noch andere Boudraten versucht scheine aber immer das selbe Problem zu haben.
Schnittstellen technisch habe ich keine der zwei angesprochenen. Sondern an sich nur eine Micro-B Usb Schnittstelle über welche ich dann eine direkte Verbindung zum Chip aufbauen kann so wie die Schnittstelle um den Chip das erste mal zu konfigurieren.

Das mit den Parity bits finde ich interresant und könnte ich mir noch als möglichen ursprung des Problems vorstellen habe jetzt aber nichts konkretes dazu gefunden, hast du mir da evtl eine möglichkeit zum nachschlagen des Problems?

StefanL38:
Meine Güte,

da hast du dir aber ein fettes Projekt zum Einsteigen ausgesucht.

Die (wie immer) spärliche Dokumentation auf GitHUB beschreibt was auf dem Grafik-Display zu sehen ist.
Du schreibst etwas von seriellem Monitor.

im code steht baudrate 115200. Damit müsste es dann etwas vernüftiges anzeigen.
Wenn es bei 115200 baud nichts venrünftiges ausgibt dann könnte es in der Tat an invertierten Pegeln liegen

Andererseits ist ein Teil der Zeichen ja lesbar. Das ist schon merkwürdig.

Bekommst du denn eine vernünftige serielle Ausgabe wenn du ein gaaanz simples ich sende Dir Zeichen und du sendest mir das Zeichen zurück laufen lässt?

vgs

Tatsächlich hatte ich auch nicht gedacht das es solch ein Riesen Projekt sein würde :fearful:

Wie könnte ich den das invertierte Pegel Problem angehen?

Meine Platine besitzt einen Display dessen anzeige soweit gut funktioniert und auch korrekte ausgaben macht, wenn ich dann das gerät in den USB Modus schalte kann ich per Seriellem monitor AT befehle aufspielen welche dann bestimmte Rückgaben triggern und eben jene Rückgaben führen zu diesen fehl ausgaben.

Und ja ein Teil des Codes sind Keys die ich per Seriellen monitor einlesen und diese Keys empfängt das Programm Korrekt und gibt sie auch in der Rückgabe selbst sauber wieder. Siehe Key1 und Key2 im Code selbst (hier stehen bei mir die korrekten eingaben wollte nur nicht die eigentlichen Werte hier veröffentlichen)

Ich hänge mal noch ein Bild des ganzen an welches evtl beim Verständnis hilft :slight_smile:

Gruß Qwyxc

7

![](http://<a href=)">

8

qwyxc:
Ich hänge mal noch ein Bild des ganzen an welches evtl beim Verständnis hilft :slight_smile:

Poste außerdem mal den Sketch, um den es geht.

Gruß

Gregor

9 
#include "usb.h"

#include <Arduino.h>
#include "icons.h"
#include "screen.h"
#include "lorawan.h"
#include "SerialCommand.h"
#include "menu.h"

SerialCommand sCmd;

/**************************************************************************/
/*!
    @brief  Wird von SerialCommand aufgerufen, um die OTAA-Schlüssel einzustellen.
*/
/**************************************************************************/
void setOtaaKeys(){
Serial.println("");
  
  char *arg1;
  char *arg2;
  arg1 = sCmd.next();
  if (arg1 == NULL || !(strlen(arg1) == 16)) {
    Serial.println("INVALID APPEUI");
    return;
  }
  arg2 = sCmd.next();
  if (arg2 == NULL || !(strlen(arg2) == 32)) {
    Serial.println("INVALID APPKEY");
    return;
  }
  if(provisionOTAA(arg1,arg2)){
      Serial.println("OK");
      return;
  } else {
    Serial.println("RN2483 FAILURE");
  }
  return;
}

/**************************************************************************/
/*!
    @brief  Wird von SerialCommand aufgerufen, um die ABP-Schlüssel einzustellen.
*/
/**************************************************************************/
void setAbpKeys(){
  char *arg1;
  char *arg2;
  char *arg3;
  arg1 = sCmd.next();
  if (arg1 == NULL || !(strlen(arg1) == 8)) {
    Serial.println("INVALID DEVADDR");
    return;
  }
  arg2 = sCmd.next();
  if (arg2 == NULL || !(strlen(arg2) == 32)) {
    Serial.println("INVALID NWKSKEY");
    return;
  }
  arg3 = sCmd.next();
  if (arg3 == NULL || !(strlen(arg3) == 32)) {
    Serial.println("INVALID APPSKEY");
    return;
  }

  if(provisionABP(arg1,arg2,arg3)){
      Serial.println("OK");
      return;
  } else {
    Serial.println("RN2483 FAILURE");
  }
  
  return;
}

/**************************************************************************/
/*!
    @brief  Wird von SerialCommand auf Anfrage für die Hardware-EUI aufgerufen.
*/
/**************************************************************************/
void getHweui(){
  char buffer[16];
  if(getHweui(buffer, 16)>0){
    Serial.println("OK");
    Serial.print("Dev EUI: ");
    Serial.println(buffer);
    return;
  }
  Serial.println("RN2483 FAILURE");
  return;
}

/**************************************************************************/
/*!
    @brief  Wird von SerialCommand aufgerufen, um den AT/USB/Serial-Modus zu verlassen.
*/
/**************************************************************************/
void goToMenu() {
  Serial.println("Exiting");
  setState(&menuState);
}

/**************************************************************************/
/*!
    @brief  Richtet den seriellen Monitor mit den möglichen Eingaben ein und gibt die Möglichkeiten am Monitor aus.
*/
/**************************************************************************/
void enterUSBMode() {
  drawFullScreenIcon(usbConnector);
  
  sCmd.addCommand("!AT+CFGOTAA", setOtaaKeys);    
  sCmd.addCommand("!AT+CFGABP", setAbpKeys);
  sCmd.addCommand("!AT+HWEUI?", getHweui);
  sCmd.addCommand("!AT+EXIT", goToMenu);
  
  Serial.println("USB MODE");
  Serial.println("Folgende Kommandos zum Konfigurieren sind möglich:");
  Serial.println("!AT+CFGOTAA [appEui] [appKey]             //Übergabe von angegebenen Daten");
  Serial.println("!AT+CFGABP [devAddr] [NwksKey] [AppsKey]  //Übergabe von angegebenen Daten");
  Serial.println("!AT+HWEUI?                                //Gibt die HardwareEui des Gerätes aus");
  Serial.println("!AT+EXIT                                  //Beendet die Seriele Verbindung");
}

/**************************************************************************/
/*!
    @brief  Überprüft die serielle Zeile im Monitor auf Befehle
*/
/**************************************************************************/
void usbSpin() {
  sCmd.readSerial();
}

state usbState = {
  &enterUSBMode,
  &usbSpin,
  NULL
};

Hier ist der Code des Sketches "usb.cpp" welcher jedoch häufig auf andere Liberias verweist.
Es scheint mir so als ob die eigentlichen Funktionen und Übertragungen korrekt ablaufen da z.b.

void getHweui(){
  char buffer[16];
  if(getHweui(buffer, 16)>0){
    Serial.println("OK");
    Serial.print("Dev EUI: ");
    Serial.println(buffer);
    return;
  }
  Serial.println("RN2483 FAILURE");
  return;
}

als Rückgabe Invalid Parameter zurück liefert jedoch keinen Fehler, daraus schlussfolgere ich das der Key wohl korrekt vorhanden sein muss (länge) jedoch keinen sinn ergibt?

10

qwyxc:
...
Hier ist der Code des Sketches "usb.cpp" welcher jedoch häufig auf andere Liberias verweist.

Liberianer und Liberianerinnen gibt's, von Liberias habe ich noch nie gehört :slight_smile:

Der von Dir gepostete Code ist - soweit ich das auf die Schnelle sehe - etwas unübersichtlich.

Mein erster Schritt bei der Fehlersuche ist immer, den Code übersichtlich zu formatieren.

Dein Programm besteht außerdem aus deutlich mehr als aus dem geposteten Stück. Ganz oben werden noch fünf Header-Dateien eingebunden - die tauchen in der IDE in mehreren Tabs auf.

11

OKay danke schonmal für den Hinweis, werde mich heute mal dran machen das ganze etwas sauberer zu gestalten.
Selbstverständlich meinte ich libraries... English ist fast so schwer wie Deutsch

Die eingebundenen Header sind aus dem oben verlinkten Projekt und nicht geändert. kann sie aber natürlich hier nochmal zur Verfügung stellen:

USB.h

#ifndef PROBE_USB__H_
#define PROBE_USB__H_

#include "state.h"

extern state usbState;

#endif //PROBE_USB__H_

Lorawan.h

#include "Arduino.h"
#ifndef PROBE_LORAWAN__H_
#define PROBE_LORAWAN__H_

enum spread_factor {
  SF_7 = 7, SF_8, SF_9, SF_10, SF_11, SF_12
};

enum join_type {
  OTAA, ABP
};

enum transmit_responce {
  TEST_SUCCESS, TEST_FAIL, TEST_ERROR
};

typedef struct transmit_result {
  int noise;
  float freq;
  int gateways;
};

bool isDeviceProvisioned();
bool provisionOTAA(const char *appEui, const char *appKey);
bool provisionABP(const char *devAddr, const char *nwkSKey, const char *appSKey);

int getTransmitPower();
int getSNR();

int sfToNum();
char* sfToText(spread_factor sf);

void hardwareReset();
void initLorawan();
size_t getHweui(char *buffer, size_t size);
bool loraJoinIfNeeded();

bool loraIsJoined();

transmit_responce loraTransmit(bool manual, spread_factor sf, transmit_result& result);

#endif //PROBE_LORAWAN__H_

Serialcomand.h

/**
 * SerialCommand - A Wiring/Arduino library to tokenize and parse commands
 * received over a serial port.
 * 
 * Copyright (C) 2012 Stefan Rado
 * Copyright (C) 2011 Steven Cogswell <steven.cogswell@gmail.com>
 *                    http://husks.wordpress.com
 * 
 * Version 20120522
 * 
 * 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, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * 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 General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef SerialCommand_h
#define SerialCommand_h

#if defined(WIRING) && WIRING >= 100
  #include <Wiring.h>
#elif defined(ARDUINO) && ARDUINO >= 100
  #include <Arduino.h>
#else
  #include <WProgram.h>
#endif
#include <string.h>

// Size of the input buffer in bytes (maximum length of one command plus arguments)
#define SERIALCOMMAND_BUFFER 128
// Maximum length of a command excluding the terminating null
#define SERIALCOMMAND_MAXCOMMANDLENGTH 12

// Uncomment the next line to run the library in debug mode (verbose messages)
//#define SERIALCOMMAND_DEBUG


class SerialCommand {
  public:
    SerialCommand();      // Constructor
    void addCommand(const char *command, void(*function)());  // Add a command to the processing dictionary.
    void setDefaultHandler(void (*function)(const char *));   // A handler to call when no valid command received.

    void readSerial();    // Main entry point.
    void clearBuffer();   // Clears the input buffer.
    char *next();         // Returns pointer to next token found in command buffer (for getting arguments to commands).

  private:
    // Command/handler dictionary
    struct SerialCommandCallback {
      char command[SERIALCOMMAND_MAXCOMMANDLENGTH + 1];
      void (*function)();
    };                                    // Data structure to hold Command/Handler function key-value pairs
    SerialCommandCallback *commandList;   // Actual definition for command/handler array
    byte commandCount;

    // Pointer to the default handler function
    void (*defaultHandler)(const char *);

    char delim[2]; // null-terminated list of character to be used as delimeters for tokenizing (default " ")
    char term;     // Character that signals end of command (default '\n')

    char buffer[SERIALCOMMAND_BUFFER + 1]; // Buffer of stored characters while waiting for terminator character
    byte bufPos;                        // Current position in the buffer
    char *last;                         // State variable used by strtok_r during processing
};

#endif //SerialCommand_h

menu.h

#ifndef PROBE_MENU__H_
#define PROBE_MENU__H_

#include "state.h"

extern state menuState;

#endif //PROBE_MENU__H_

icons.h sind lediglich die icons da ist kein wirkliches fehler potential vorhanden.
und Arduino.h ist Standart?!

Jedoch ist das gesamte Programm nochmals umfangreicher siehe: GitHub - danielknox/lorawan_network_tester: A network tester for lorawan networks. Released under GPLv3

12

Also wo die Meldung

!AT+EXIT                                  //Beendet die Seriele Verbindung
OK
Dev EUI: invalid_param

herkommt, kann ich nachvollziehen, aber das nicht:

void getHweui(){ // <----------------+
  char buffer[16];             //    |
  if(getHweui(buffer, 16)>0){  // ???|
    Serial.println("OK");
    Serial.print("Dev EUI: ");
    Serial.println(buffer);
    return;
  }
13

Ich nehme an der Hier erwähnte Buffer bezieht sich auf eine cpp namens "TheThinsNetwork.cpp" welche sich in der arduino-device-lib versteckt.

Hier zu finden: arduino-device-lib/TheThingsNetwork.cpp at master · TheThingsNetwork/arduino-device-lib · GitHub

Im code findet man die Funktion getHweui in zeile 307 - 310:

size_t TheThingsNetwork::getHardwareEui(char *buffer, size_t size){
  return readResponse(SYS_TABLE, SYS_TABLE, SYS_GET_HWEUI, buffer, size);
}

Außerdem ist hier auch die aufgerufene "readResponse" zu finden Z. 379 - 386:

size_t TheThingsNetwork::readResponse(uint8_t prefixTable, uint8_t index, char *buffer, size_t size){  
  clearReadBuffer();
  sendCommand(prefixTable, 0, true, false);
  sendCommand(prefixTable, index, false, false);
  modemStream->write(SEND_MSG);  
return readLine(buffer, size);
}
14

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.