Architektur von Code mit Knoten js

Question

Ich habe Probleme mit meiner Code-Architektur und bin auf der Suche nach Rat. Ich sende mehrere Leseanforderungen über udp an einen Server und drucke die Leseantwort aus. Ein Beispiel dafür, wie die Anfrage und die Antwort aussehen, ist unten. Ich bekomme die Antwort zurück als eine große Hex-Zeichenfolge beginnend bei 0008 .. Ich brauche eine Möglichkeit für den Code zu wissen, wie viele Adressen zum Lesen gesendet wurden und welche Datengröße angefordert wurde und dies beim Ausdrucken der Daten berücksichtigen. Da sich die Datengröße ändern kann, kann ich die Zeichenfolge nicht einfach mit einem bestimmten Wert aufteilen. Ich suche nicht nach Code, sondern nach Ideen, wie man das angehen könnte.

Request 
    00 06 - Opcode 
    00 00 - Block # 
    02 - Count 
    34 97 00 20 - Address 1 
    04 00 - Data Size 1 (bytes) 
    30 97 00 20 - Address 2 
    01 00 - Data Size 2 (bytes) 


Response- 00080001e60300009 
    00 08 - Opcode 
    00 01 - Block # 
    e6 03 00 00 - Data 1 
    09 - Data 2 

    What I am printing right now- e603000009 
    How I want it printed - Address 1 = e6030000 
          Address 2 = 09 ... 

          Address 3 = 00 00 
          etc. 
    (it would know what it is a new data by the data size that was requested and the # of addresses that were requested) 

Teil des Codes, wo ich eine Leseanforderung schicke und Emittieren es

app.post('/output3', function(req, res){ 

    res.sendFile(__dirname + '/upload3.html'); 
//Define the host and port values of UDP 

    var HOST= '192.168.0.136'; 
    var PORT= 69;  

    var io = require('socket.io')(http); 

    //Mulitple parameters 
    //setInterval will send message constantly. 
    var client= dgram.createSocket('udp4'); 
    var counter = 0; 

     //array for addresses 
     var address=[]; 
     //array for size 
     var size=[]; 
     //iterate through all addresses and convert to little endian 
     for (var i=0; i<req.body.address.length; i++) { 
     var n= req.body.address[i]; 
     var s = n.toString(16).match(/.{1,2}/g); 
     address[i]= s.reverse().join("").toString(16); // ==> "0x985c0020" (= 2556166176) 
     } 

     //iterate through all size and make hex strings and little endian 
     for (var i=0; i<req.body.size.length; i++) { 
     function pad(number, length) { 
      var my_string = '' + number; 
      while (my_string.length < length) { 
      my_string = '0' + my_string; 
      } 
      return my_string; 
     } 

     var n2= pad(req.body.size[i], 4); 
     var s2 = n2.toString(16).match(/.{1,2}/g); 
     size[i]= s2.reverse().join("").toString(16); 
     } 

     //empty string to add address and size together 
     var x=''; 
     for (var i=0; i<req.body.address.length; i++) { 
     x += address[i]+size[i]; 
     } 

     console.log(req.body.size); 
     var mrq= read(x); 

     //Open listener to recieve intial message and print in to webpage 
     io.on('connection', function(socket){ 
     var mrq= read(x); 
      io.emit('mrq', mrq); 
     }); 
     function read() { 
     // Memory Read Request is a 16-bit word with a value of 6 
     var message = '0006' 
     // Block number is a 16-bit word that we will always set to 0 
     message += '0000' 
     // Count is variable, and calculated by the size of the parameter list 
     message += '02' 

     for (var i=0; i < arguments.length; i++) { 
      message += arguments[i]; 
     } 
     return message; 
     } 


     var message = new Buffer(mrq, 'hex'); 
     counter++; 

     var loop= setInterval(function() { 
     //Sends packets to UDP and setInterval sends packets again for specific time 
     client.send(message, 0, message.length, PORT, HOST, function (err, bytes) { 
     if (err) throw err; 
     }); 
     if (counter === 1000000000000000) { 
     clearInterval(loop); 
     } 
    }, 1/50); 



    //Open listener to recieve intial message and print in to webpage 
    io.on('connection', function(socket){ 
     client.on('message', function(message, rinfo){ 
     //hex string 
     var temp = message.readUIntBE(0, 2); 
     //console.log(message.toString(16)); 
     io.emit('temp', temp); 
     }); 
    }); 

Answer 1

Zeigen Sie Ihre aktuellen Code HTML würde uns dies besser helfen zu beantworten.

aber im Allgemeinen wäre der Weg, einen Schreibstrom zu verwenden und den String in Blöcken auszudrücken, anstatt als ganzen Block.