Arduino: uint8_t array zu string

Habe ich eine NFC-Anwendung, die auf android, sendet ein hash als apdu-Antwort. Dies ist der code den ich in meine Android-app zum senden des hash:

@Override
    public byte[] processCommandApdu(byte[] arg0, Bundle arg1) {

        String hash = "e68d3f574009cbbe011150263634c5c0";

        return hash.getBytes(Charset.forName("UTF-8"));

    }

Nun, wenn ich es auf der Arduino-Seite der Dinge, bekomme ich diese RAW-Daten:

10154561005110253555248485799989810148494949534850255255255255255255255255255

Wie bekomme ich den hash wieder ab?

Dies ist, was ich jetzt haben, aber es ist natürlich nicht arbeiten:

        uint8_t response[32];

        uint8_t responseLength = sizeof(response);

        if (nfc.inDataExchange(message, sizeof(message), response, &responseLength)) {

            Serial.print("RAW: ");
            for (int i = 0; i < sizeof(response); i++) {
                Serial.print(response[i]);
            }

            Serial.println(" ");

            char buffer[32];
            itoa((int)response,buffer,8);

            Serial.print("ITOA: ");
            for (int i = 0; i < sizeof(buffer); i++) {
                Serial.print(buffer[i]);
            }

            Serial.println(" ");
       }

- Und dies ist die serielle Ausgabe von dem code oben:

RAW: 10154561005110253555248485799989810148494949534850255255255255255255255255255 
ITOA: 4253   µ      + 
  3ü       R

Halp!!!

InformationsquelleAutor ReX357 | 2013-11-26

1

Drei Vorschläge, obwohl keiner von Ihnen wirklich erklärt, warum die letzten paar bytes abgeschnitten:
1. Nicht konvertieren des hexadezimalen hash-Darstellung in eine character-Zeichenfolge, um Sie später zu senden, die diese Zeichen in UTF-8-Codierung. Dabei wäre es viel effizienter (und weniger decoding-Aufwand) direkt senden des hash als Byte:
```
@Override
public byte[] processCommandApdu(byte[] arg0, Bundle arg1) {
    byte[] hash = {
            (byte)0xe6, (byte)0x8d, (byte)0x3f, (byte)0x57,
            (byte)0x40, (byte)0x09, (byte)0xcb, (byte)0xbe,
            (byte)0x01, (byte)0x11, (byte)0x50, (byte)0x26,
            (byte)0x36, (byte)0x34, (byte)0xc5, (byte)0xc0
    };

    return hash;
}
```
  Wenn du schon den hash als hexadezimal-string, schlage ich vor, konvertieren Sie ihn in Ihrer byte-Darstellung auf der Android-Seite zuerst.
2. Bei der Verwendung von HCE, Sie sollten stick to ISO/IEC 7816-4 APDUs anstatt nur das senden zufällige Daten. Eine Kommando-APDU (kurz-format) besteht aus den folgenden:
```
+----------+----------+----------+----------+----------+------------+----------+
| CLA      | INS      | P1       | P2       | Lc       | DATA       | Le       |
| (1 Byte) | (1 Byte) | (1 Byte) | (1 Byte) | (1 Byte) | (Lc Bytes) | (1 Byte) |
+----------+----------+----------+----------+----------+------------+----------+
```
  Wo Lc codiert die Anzahl der bytes der DATEN. Wenn leer ist, wird das Lc-leer ist auch. Le kodiert die Anzahl der bytes, die erwartet als Antwort (mit der Sonderfall Le = 0x00, das heißt 256-response-bytes erwartet.
  
  Einer response APDU (das ist, was Sie senden als einen Wert zurück in processCommandApdu) sieht wie folgt aus:
```
+----------+----------+----------+
| DATA     | SW1      | SW2      |
| (n Byte) | (1 Byte) | (1 Byte) |
+----------+----------+----------+
```
  DATEN der response-Daten. SW1 & SW2 form der response-status-word (in der Regel SW1 = 0x90, SW2 = 0x00 für den Erfolg). Beachten Sie, dass SW1 und SW2 sind obligatorisch.
3. Bei der Iteration durch die Reaktion von inDataExchange die response-Länge zur Verfügung gestellt, die durch die Funktion (responseLength) anstatt der maximale buffer Länge:
```
for (int i = 0; i < responseLength; ++i) {
    ...
}
```
  Darüber hinaus schlage ich vor, dass Sie einen Puffer mit mehr als der maximal zu erwartenden response-Länge. (Besonders in deinem Fall wo du die UTF-8-Codierung für eine 32-stellige Zeichenfolge, die vielleicht (für einige Zeichen) Ergebnis, dass 32 bytes.)
- Danke. Dieser arbeitete.
InformationsquelleAutor Michael Roland
-1

OK, so dass ich dachte, meine Antwort. Ich brauche nicht itoa. Ich kann nur Umwandlung der RAW-input-char und bekomme, was ich brauche:
```
            Serial.print("TYPECASTED RAW: ");
            for (int i = 0; i < sizeof(response); i++) {
                Serial.print((char)response[i]);
            }

            Serial.println(" ");
```
Ist und dass ausgegeben wird:
```
e68d3f574009cbbe0111502ÿÿÿÿÿÿÿÿÿ
```
Nun Frage ich mich nur, warum die letzten 9 Zeichen ersetzt werden, mit 255?
- Einige ganzzahlige Werte haben eine Besondere Bedeutung als Zeichen. Sollte es nicht funktionieren, einfach direkt übersetzen, es sei denn, die zahlen waren zu werden chars. Hexadezimal löst dieses in einer Art und Weise, base64 löst es ein anderer.
InformationsquelleAutor ReX357

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.