UDP-Pakete Fehlzündungen

Question

Versuchen, meine Frage so allgemein wie möglich hier zu inszenieren. Vielleicht denke ich nur laut nach.

Mein Programm sollte ein großes Paket senden, etwa 24 Bytes, aber stattdessen scheint es, dass es 6 Pakete der Länge feuern: 2,2,4,4,4,8 jeweils.

Tragene von meinem Adafruit WICED Feder ist:

So wird das Paket von meinem PC ist in diesem Fall 24bytes gesendet zu werden. Der Handshake sollte ein Paket von ungefähr der gleichen Größe zurückgeben. Aber hier ist das, was am anderen Ende aufgenommen wird immer:

Wie Sie sehen können, werden die eingehenden Pakete sind von den Größen 2, 2, 4, 4, 4, und dann ein Puffer von 8+ Bits .

Mein erster Gedanke ist, dass es ist etwas los in der Hauptschreibfunktion, die eine Vorlage:

template<class UdpClass> 
inline void AppleMidi_Class<UdpClass>::write(UdpClass& udp, AppleMIDI_InvitationAccepted& ia, IPAddress ip, uint16_t port) 
{ 
    Serial.println("+++++ Writing Packet"); 
    udp.beginPacket(ip, port); 

     udp.write(ia.signature, sizeof(ia.signature)); 
     udp.write(ia.command, sizeof(ia.command)); 

     // To appropriate endian conversion 
     uint32_t _version = AppleMIDI_Util::toEndian(ia.version); 
     uint32_t _initiatorToken = AppleMIDI_Util::toEndian(ia.initiatorToken); 
     uint32_t _ssrc = AppleMIDI_Util::toEndian(ia.ssrc); 

     // write then out 
     udp.write((uint8_t*) ((void*) (&_version)), sizeof(_version)); 
     udp.write((uint8_t*) ((void*) (&_initiatorToken)), sizeof(_initiatorToken)); 
     udp.write((uint8_t*) ((void*) (&_ssrc)), sizeof(_ssrc)); 

     udp.write((uint8_t*) ia.name, strlen(ia.name) + 1); 

    udp.endPacket(); 
    udp.flush(); 
} 

Diese Vorlage ist eigentlich die folgende Schreibfunktion (6-mal in der Tat) Aufruf:

size_t AdafruitUDP::write(const uint8_t* buffer, size_t size) 
{ 
    if (_udp_handle == 0 || _sndIP == 0 || _sndPort == 0) { 
    Serial.println("Handle, IP, port == 0 returning"); 
    return 0; 
    } 
    //Serial.printf("+++++ Handle: %s IP: %s Send Port: %s\n", _udp_handle, _sndIP, _sndPort); 

    sdep_cmd_para_t para_arr[] = 
    { 
     { .len = 4 , .p_value = &_udp_handle }, 
     { .len = 4 , .p_value = &_sndIP  }, 
     { .len = 2 , .p_value = &_sndPort }, 
     { .len = size, .p_value = buffer  } 
    }; 
    uint8_t para_count = sizeof(para_arr)/sizeof(sdep_cmd_para_t); 

    VERIFY_RETURN(sdep_n(SDEP_CMD_UDP_WRITE, para_count, para_arr, NULL, NULL), 0); 
    return size; 
} 

Diese ruft dann:

bool AdafruitSDEP::sdep_n(uint16_t cmd_id  , 
      uint8_t para_count , sdep_cmd_para_t const* para_arr, 
      uint16_t* p_result_len , void* p_result) 
{ 
    _errno = FEATHERLIB->sdep_execute_n(cmd_id, para_count, para_arr, p_result_len, p_result); 
    handle_error(cmd_id); 
    return (ERROR_NONE == _errno); 
} 

Also, ich denke, die nächste offensichtliche qu estion ist: was passiert während beginPacket und endPacket. Nicht viel - ich habe keine Rückrufe sehen entweder:

int AdafruitUDP::beginPacket(IPAddress ip, uint16_t port) 
{ 
    _sndIP = (uint32_t) ip; 
    _sndPort = port; 

    return 1; 
} 

/******************************************************************************/ 
/*! 
    @brief Called after writing UDP data to the remote connection. 
*/ 
/******************************************************************************/ 
int AdafruitUDP::endPacket() 
{ 
    _sndIP = 0; 
    _sndPort = 0; 

    return 1; 
} 

Also meine eigentliche Frage, bevor ich someones wunderbare Bibliothek zu ändern um zu bekommen, ist dies: es so aussieht, wenn der Header mit jedem appleMidi.write() geschrieben wird immer Funktion? Gibt es eine Möglichkeit, diese 6 Schreibaufrufe von der AppleMidi-Klasse zu verketten?

Ich denke, ich bin hier auf dem richtigen Weg, aber die Eingabe wird immer sehr geschätzt.

Mit freundlichen Grüßen,

bei der Arbeit -Daydreaming

Answer 1

Es wäre, dass auf Ihrem spezielles Embedded-System erscheinen, ein Aufruf an udp.write() entspricht ein übertragenes Paket, mit den beginPacket/endPacket lediglich der Einrichtung und zunichte gemacht den Kontext notwendig um einen zu übertragen, anstatt Grenzen tatsächlich zu skizzieren.

Die einfachste Lösung kann sein, Ihr gesamtes Paket in einem Puffer zusammenzusetzen, und dann das in einem einzigen Anruf zu schreiben.

Sie können dies auch zu den Adafruit-Support-Foren bringen.